def evalonebitangency(srfs, pts):
ruling = irit.nil()
tmp1pts = irit.nil()
tmp2pts = irit.nil()
if (irit.ThisObject(srfs) == irit.SURFACE_TYPE):
srf1 = srfs
srf2 = srfs
else:
srf1 = irit.nth(srfs, 1)
srf2 = irit.nth(srfs, 2)
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
pt1 = irit.seval(srf1, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2)))
pt2 = irit.seval(srf2, irit.FetchRealObject(irit.coord(pt, 3)),
irit.FetchRealObject(irit.coord(pt, 4)))
irit.snoc(pt1 + pt2, ruling)
irit.snoc(pt1 * irit.tx(0), tmp1pts)
irit.snoc(pt2 * irit.tx(0), tmp2pts)
i = i + 1
irit.attrib(ruling, "rgb", irit.GenStrObject("255, 128, 128"))
if (irit.SizeOf(tmp1pts) > 1 and irit.SizeOf(tmp2pts) > 1):
tmp1pts = irit.poly(tmp1pts, irit.TRUE)
tmp2pts = irit.poly(tmp2pts, irit.TRUE)
irit.attrib(tmp1pts, "rgb", irit.GenStrObject("128, 255, 128"))
irit.attrib(tmp2pts, "rgb", irit.GenStrObject("128, 255, 128"))
retval = irit.list(ruling, tmp1pts, tmp2pts)
else:
retval = irit.nil()
return retval
def bishop(s, clr):
retval = (-irit.surfprev( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.0001, 0.82 ), \
irit.ctlpt( irit.E2, 0.028, 0.82 ), \
irit.ctlpt( irit.E2, 0.028, 0.77 ), \
irit.ctlpt( irit.E2, 0.01, 0.77 ), \
irit.ctlpt( irit.E2, 0.01, 0.765 ), \
irit.ctlpt( irit.E2, 0.06, 0.76 ), \
irit.ctlpt( irit.E2, 0.09, 0.69 ), \
irit.ctlpt( irit.E2, 0.06, 0.625 ), \
irit.ctlpt( irit.E2, 0.02, 0.62 ), \
irit.ctlpt( irit.E2, 0.02, 0.61 ), \
irit.ctlpt( irit.E2, 0.08, 0.6 ), \
irit.ctlpt( irit.E2, 0.08, 0.59 ), \
irit.ctlpt( irit.E2, 0.03, 0.58 ), \
irit.ctlpt( irit.E2, 0.03, 0.56 ), \
irit.ctlpt( irit.E2, 0.12, 0.55 ), \
irit.ctlpt( irit.E2, 0.12, 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 ) ) ) * irit.sc( s )
bishoptop = irit.sregion(retval, irit.ROW, 0, 0.1)
bishopbody = irit.sregion(retval, irit.ROW, 0.1, 1)
irit.attrib(bishoptop, "rgb", irit.GenStrObject("255,255,100"))
irit.attrib(bishopbody, "rgb", irit.GenStrObject(clr))
retval = irit.list(bishopbody, bishoptop)
return retval
def crvtrcolorblend2( k, h, r1, g1, b1, r2,\
g2, b2, r3, g3, b3, r4,\
g4, b4, r5, g5, b5, r6,\
g6, b6 ):
if ( k > 1 ):
k = 1
if ( h > 1 ):
h = 1
t1 = ( 1 - k ) * ( 1 - h )
t2 = ( 1 - k ) * h
t3 = k * ( 1 - h )
t4 = k * h
if ( h > 0 ):
retval = irit.GenStrObject(str(int(t1 * r1 + t2 * r2 + t3 * r3 + t4 * r4)) + \
"," + \
str(int(t1 * g1 + t2 * g2 + t3 * g3 + t4 * g4)) + \
"," + \
str(int(t1 * b1 + t2 * b2 + t3 * b3 + t4 * b4)) )
else:
retval = irit.GenStrObject(str(int(t1 * r1 + t2 * r2 + t3 * r5 + t4 * r6)) + \
"," + \
str(int(t1 * g1 + t2 * g2 + t3 * g5 + t4 * g6)) + \
"," + \
str(int(t1 * b1 + t2 * b2 + t3 * b5 + t4 * b6)) )
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 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 buildvisibilitymap( c, step, highlightangle ):
retval = irit.nil( )
i = 0
while ( i <= 360 ):
dir = irit.point( math.cos( i * math.pi/180 ), math.sin( i * 3.14159/180 ), 0 )
crvs = irit.cvisible( c, irit.Fetch3TupleObject(dir), 1e-005 )
crvdmn = cnvrtcrvs2domains( crvs, i )
if ( highlightangle == i ):
irit.attrib( crvdmn, "width", irit.GenRealObject(0.01 ))
irit.attrib( crvdmn, "gray", irit.GenRealObject(0 ))
irit.attrib( crvdmn, "rgb", irit.GenStrObject("255, 255, 128" ))
irit.adwidth( crvdmn, 3 )
highcrvdmn = crvdmn * irit.sx( 1/360.0 )
irit.attrib( crvs, "width", irit.GenRealObject(0.03 ))
irit.adwidth( crvs, 3 )
irit.attrib( crvs, "rgb", irit.GenStrObject("255, 255, 128" ))
irit.snoc( crvs, retval )
else:
irit.attrib( crvdmn, "width", 0.01 )
irit.attrib( crvdmn, "gray", 0.5 )
irit.attrib( crvdmn, "rgb", "128, 128, 255" )
irit.snoc( crvdmn * irit.sx( 1/360 ), retval )
i = i + step
retval = ( retval + irit.list( highcrvdmn ) )
return retval
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 computeparaboliclines(s):
retval = irit.sparabolc(s, 1)
irit.adwidth(retval, 2)
irit.awidth(retval, 0.01)
irit.attrib(retval, "gray", irit.GenRealObject(0.5))
irit.attrib(retval, "rgb", irit.GenStrObject("100,255,255"))
return retval
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 ant(scl):
save_res = irit.GetResolution()
bodyall = antbody()
body = irit.nth(bodyall, 1)
eyes = irit.nth(bodyall, 2)
leg = antleg()
llegs = irit.list(
leg * irit.sc(1.1) * irit.sx(1.3) * irit.ry((-45)) * irit.trans(
(0.1, 0, 1.02)),
leg * irit.sc(1.3) * irit.ry(10) * irit.trans((0.1, 0.05, 1)),
leg * irit.sc(1.2) * irit.sx(1.4) * irit.ry(40) * irit.trans(
(0.1, 0.02, 0.95)))
irit.SetResolution(20)
irit.attrprop(llegs, "u_resolution", irit.GenRealObject(0.2))
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(llegs, 1) + irit.gpolygon(llegs, 1) * irit.sx(
(-1)) + irit.gpolygon(antennas, 1))
irit.attrib(body, "rgb", irit.GenStrObject("255,50,50"))
irit.SetResolution(save_res)
retval = irit.list(
body,
eyes) * irit.sz(1.3) * irit.sc(1) * irit.ty(0.28785) * irit.rx(90)
return retval
def drawtritangencies(srfs, orient, subtol, numtol, savename):
tritans = irit.srf3tans(srfs, orient, subtol, numtol)
tritansedges = evaltritangency(srfs, tritans)
irit.color(tritansedges, irit.YELLOW)
irit.color(srfs, irit.CYAN)
if (irit.SizeOf(irit.GenStrObject(savename)) > 0):
irit.save(savename, irit.list(srfs, tritansedges))
irit.interact(irit.list(srfs, tritansedges))
def intercrvspaint(crvs):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(crvs)):
crv = irit.nth(crvs, i)
irit.attrib(crv, "rgb", irit.GenStrObject(getrandrgb()))
irit.snoc(crv * irit.sc(1), retval)
i = i + 1
return retval
def drawbitangencies( srfs, orient, subtol, numtol, mergetol, merged,\
savename ):
bitans = irit.srf2tans(srfs, orient, subtol, numtol, mergetol)
bitansedges = evalbitangency(srfs, bitans, merged)
irit.color(bitansedges, irit.YELLOW)
irit.color(srfs, irit.CYAN)
if (irit.SizeOf(irit.GenStrObject(savename)) > 0):
irit.save(savename, irit.list(srfs, bitansedges))
irit.interact(irit.list(srfs, bitansedges))
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 king(s, clr):
kingbase = (-irit.surfprev( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.001, 1.04 ), \
irit.ctlpt( irit.E2, 0.04, 1.04 ), \
irit.ctlpt( irit.E2, 0.04, 1.02 ), \
irit.ctlpt( irit.E2, 0.06, 1.02 ), \
irit.ctlpt( irit.E2, 0.06, 1 ), \
irit.ctlpt( irit.E2, 0.08, 1 ), \
irit.ctlpt( irit.E2, 0.08, 0.97 ), \
irit.ctlpt( irit.E2, 0.1, 0.97 ), \
irit.ctlpt( irit.E2, 0.1, 0.94 ), \
irit.ctlpt( irit.E2, 0.07, 0.82 ), \
irit.ctlpt( irit.E2, 0.07, 0.8 ), \
irit.ctlpt( irit.E2, 0.09, 0.8 ), \
irit.ctlpt( irit.E2, 0.09, 0.78 ), \
irit.ctlpt( irit.E2, 0.07, 0.78 ), \
irit.ctlpt( irit.E2, 0.07, 0.74 ), \
irit.ctlpt( irit.E2, 0.1, 0.72 ), \
irit.ctlpt( irit.E2, 0.1, 0.7 ), \
irit.ctlpt( irit.E2, 0.14, 0.67 ), \
irit.ctlpt( irit.E2, 0.14, 0.64 ), \
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 ) ) )
kingcrosscrv = ( \
irit.ctlpt( irit.E2, (-0.07 ), 0 ) + \
irit.ctlpt( irit.E2, (-0.07 ), 0.53 ) + \
irit.ctlpt( irit.E2, (-0.3 ), 0.53 ) + \
irit.ctlpt( irit.E2, (-0.3 ), 0.67 ) + \
irit.ctlpt( irit.E2, (-0.07 ), 0.67 ) + \
irit.ctlpt( irit.E2, (-0.07 ), 1 ) + \
irit.ctlpt( irit.E2, 0, 1 ) )
kingcrosssrf1 = irit.ruledsrf(kingcrosscrv, kingcrosscrv * irit.sx((-1)))
kingcrosssrf2 = (-kingcrosssrf1) * irit.tz(0.08)
kingcrosscrv2 = (kingcrosscrv + (-kingcrosscrv) * irit.sx((-1)))
kingcrosssrf3 = irit.ruledsrf(kingcrosscrv2, kingcrosscrv2 * irit.tz(0.08))
kingcross = irit.list(
kingcrosssrf1, kingcrosssrf2, kingcrosssrf3) * irit.tz(
(-0.04)) * irit.sc(0.16) * irit.rx(90) * irit.tz(1)
irit.attrib(kingcross, "rgb", irit.GenStrObject("255,255,100"))
irit.attrib(kingbase, "rgb", irit.GenStrObject(clr))
retval = irit.list(kingbase, kingcross) * irit.sc(s)
return retval
def crvtrcolorblend( k, eps, r1, g1, b1, r2, g2, b2 ):
t = float(abs( k ))/eps
if ( t > 1 ):
t = 1
t1 = ( 1 - t )
retval = irit.GenStrObject(str(int(t1 * r1 + t * r2) ) + \
"," + \
str(int(t1 * g1 + t * g2) ) + \
"," + \
str(int(t1 * b1 + t * b2) ) )
return retval
def extractidparts(obj, id, rgb):
retval = irit.nil()
i = 0
while (i <= irit.SizeOf(obj) - 1):
p = irit.coord(obj, i)
if (irit.getattr(p, "id") == irit.GenRealObject(id)):
irit.snoc(p, retval)
i = i + 1
retval = irit.mergepoly(retval)
irit.attrib(retval, "rgb", irit.GenStrObject(rgb))
return retval
def cmpoffalltols(crv, header, fname, dist, tol, steps):
i = 0
while (i <= steps):
irit.printf("\n\n%s: tolerance = %lf, dist = %lf",
irit.list(header, tol, dist))
c1 = irit.offset(crv, irit.GenRealObject(dist), tol, 0)
c2 = irit.offset(crv, irit.GenRealObject(dist), tol, 1)
c3 = irit.aoffset(crv, irit.GenRealObject(dist), tol, 0, 0)
c4 = irit.loffset(crv, dist, 300, irit.SizeOf(c2), 4)
irit.attrib(c1, "dash", irit.GenStrObject("[0.1 0.01] 0"))
irit.color(c1, irit.RED)
irit.attrib(c2, "dash", irit.GenStrObject("[0.01 0.01] 0"))
irit.color(c2, irit.GREEN)
irit.attrib(c3, "dash", irit.GenStrObject("[0.2 0.01 0.05 0.01] 0"))
irit.color(c3, irit.YELLOW)
irit.attrib(c4, "dash", irit.GenStrObject("[0.1 0.1 0.01 0.01] 0"))
irit.color(c4, irit.CYAN)
irit.save(fname + "_" + str(i + 1), irit.list(crv, c1, c2, c3, c4))
compareoffset(crv, abs(dist), c1, c2, c3, c4)
tol = tol * math.sqrt(0.1)
i = i + 1
def computeviews( c, step, fname ):
dms = buildvisibilitymap( c, step )
ranges = irit.nil( )
i = 1
while ( i <= irit.SizeOf( dms ) ):
ranges = cnvrtcrvs2ranges( irit.nth( dms, i ), i, 1 ) + ranges
i = i + 1
irit.printf( "%d views are considered\n", irit.list( irit.SizeOf( dms ) ) )
cvrs = irit.setcover( ranges, 0.001 )
cvrcrvs = irit.nil( )
i = 1
while ( i <= irit.SizeOf( cvrs ) ):
cvr = irit.nth( ranges, irit.FetchRealObject(irit.nth( cvrs, i )) + 1 )
irit.printf( "curve %d [idx = %d] covers from t = %f to t = %f\n", irit.list( i, irit.getattr( cvr, "index" ), irit.nth( cvr, 1 ), irit.nth( cvr, 2 ) ) )
irit.snoc( extractcrvregion( c, irit.nth( cvr, 1 ), irit.nth( cvr, 2 ), (irit.getattr( cvr, "index" )/irit.SizeOf( dms ) ) * 360 ), cvrcrvs )
i = i + 1
irit.attrib( c, "width", irit.GenRealObject(0.005 ))
irit.attrib( c, "rgb", irit.GenStrObject("255, 255, 255" ))
retval = irit.list( c, cvrcrvs )
if ( irit.SizeOf( irit.GenStrObject( fname ) ) > 0 ):
irit.save( fname, retval )
return retval
def antantenna():
c = irit.pcircle((0, 0, 0), 0.03) * irit.ry(90)
retval = (-irit.sfromcrvs(
irit.list(
c * irit.sy(1.4) * irit.rz(45) * irit.tx(0.1) * irit.ty((-0.15)),
c * irit.rz(45) * irit.tx(0.2) * irit.ty(0.2),
c * irit.sy(1.4) * irit.tx(0.3) * irit.ty(0.4),
c * irit.rz((-55)) * irit.tx(0.4) * irit.ty(0.15),
c * irit.sc(0.8) * irit.rz((-45)) * irit.tx(0.5) * irit.ty((-0.1)),
c * irit.sc(0.65) * irit.rz((-45)) * irit.tx(0.58) * irit.ty(
(-0.22)),
c * irit.sc(0.001) * irit.rz((-45)) * irit.tx(0.58) * irit.ty(
(-0.22))), 3, irit.KV_OPEN))
irit.attrib(retval, "rgb", irit.GenStrObject("255,50,50"))
return retval
def pawn(s, clr):
retval = (-irit.surfprev( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.0001, 0.635 ), \
irit.ctlpt( irit.E2, 0.06, 0.63 ), \
irit.ctlpt( irit.E2, 0.08, 0.56 ), \
irit.ctlpt( irit.E2, 0.06, 0.52 ), \
irit.ctlpt( irit.E2, 0.03, 0.5 ), \
irit.ctlpt( irit.E2, 0.03, 0.49 ), \
irit.ctlpt( irit.E2, 0.1, 0.48 ), \
irit.ctlpt( irit.E2, 0.1, 0.46 ), \
irit.ctlpt( irit.E2, 0.04, 0.44 ), \
irit.ctlpt( irit.E2, 0.05, 0.25 ), \
irit.ctlpt( irit.E2, 0.15, 0.1 ), \
irit.ctlpt( irit.E2, 0.15, 0 ) ), irit.list( irit.KV_OPEN ) ) * irit.rx( 90 ) ) ) * irit.sc( s )
irit.attrib(retval, "rgb", irit.GenStrObject(clr))
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 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 buildoffsetvisibilitymap( c, step, ofst ):
retval = irit.nil( )
co = irit.offset( c, irit.GenRealObject(ofst), 1e-006, 1 )
tmin = irit.nth( irit.pdomain( co ), 1 )
tmax = irit.nth( irit.pdomain( co ), 2 )
t = tmin
while ( t <= tmax ):
pt = irit.coerce( irit.ceval( co, irit.FetchRealObject(t) ), irit.POINT_TYPE ) * \
irit.tz( 1 )
crvs = irit.cvisible( c, irit.Fetch3TupleObject(pt) , 1e-005 )
crvdmn = cnvrtcrvs2domains( crvs, t )
irit.attrib( crvdmn, "width", irit.GenRealObject(0.01) )
irit.attrib( crvdmn, "gray", irit.GenRealObject(0.5) )
irit.attrib( crvdmn, "rgb", irit.GenStrObject("128, 128, 255" ))
irit.snoc( crvdmn, retval )
t = t + step
return retval
def skel2dcolor( prim1, prim2, prim3, eps, mzerotols, drawall, fname ):
equapt = irit.skel2dint( prim1, prim2, prim3, 100, eps, 300, mzerotols )
if ( irit.SizeOf( equapt ) > 1 ):
irit.printf( "%d solutions detected\n", irit.list( irit.SizeOf( equapt ) ) )
irit.color( equapt, irit.WHITE )
irit.adwidth( prim1, 2 )
irit.adwidth( prim2, 2 )
irit.adwidth( prim3, 2 )
tans = irit.nil( )
edges = irit.nil( )
circs = irit.nil( )
i = 1
while ( i <= irit.SizeOf( equapt ) ):
e = irit.nth( equapt, i )
clrs = getrandomcolors( )
clr = irit.nth( clrs, 1 )
dclr = irit.nth( clrs, 2 )
d = irit.getattr( e, "prim1pos" )
irit.snoc( d, tans )
irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim1pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges )
irit.snoc( irit.getattr( e, "prim2pos" ), tans )
irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim2pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges )
irit.snoc( irit.getattr( e, "prim3pos" ), tans )
irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim3pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges )
irit.snoc( setcolor( irit.pcircle( irit.Fetch3TupleObject(irit.coerce( e, irit.VECTOR_TYPE )),
irit.dstptpt( d,
e ) ),
clr ),
circs )
i = i + 1
irit.color( edges, irit.MAGENTA )
irit.color( tans, irit.GREEN )
if ( drawall ):
all = irit.list( prim1, prim2, prim3, edges, tans, circs,\
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 )
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
irit.free(prof1a)
irit.free(prof2)
irit.free(prof2a)
irit.free(prof3)
irit.free(prof3a)
irit.free(prof4)
irit.free(prof4a)
leg1 = irit.surfrev(cross1 * irit.ry((-90)))
leg2 = irit.surfrev(cross2 * irit.ry((-90)))
irit.free(cross1)
irit.free(cross2)
legs = irit.list(leg1, leg1 * irit.tx(80), leg2 * irit.trans((0, 190, 0)),
leg2 * irit.trans((80, 190, 0)))
irit.attrib(legs, "rgb", irit.GenStrObject("244,164,96"))
irit.free(leg1)
irit.free(leg2)
skel = irit.list( irit.box( ( (-1 ), (-1 ), 25 ), 80, 2, 20 ),\
irit.box( ( (-1 ), (-1 ), 25 ), 2, 190, 20 ),\
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 ), \
# Seed-initiate the randomizer,
irit.free(ri)
size = 0.25
v1 = (0, 0, 0)
v2 = (size * 3, 0, 0)
v3 = (size * 3, size * 3, 0)
v4 = (0, size * 3, 0)
plaux = irit.poly(irit.list(v1, v2, v3, v4, v1), irit.TRUE)
cubebbox = irit.list(plaux, plaux * irit.tz(size * 3), plaux * irit.rx(90),
plaux * irit.rx(90) * irit.ty(size * 3),
plaux * irit.ry((-90)),
plaux * irit.ry((-90)) * irit.tx(size * 3))
irit.attrib(cubebbox, "rgb", irit.GenStrObject("255, 255, 255"))
irit.free(plaux)
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
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.free( teapotorig )
irit.free( teapot )
irit.free( warpedteapot )
irit.free( clr )
irit.free( warpedsrf )
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"))
s2 = irit.spheresrf(1.25)
# s2 = sregion( sregion( sphereSrf( 1.25 ), row, 0, 2 ), col, 0, 4 );
s2 = irit.sreparam( irit.sreparam( s2, irit.ROW, 0, 1 ), irit.COL, 0,\
1 )
irit.attrib(s2, "color", irit.GenRealObject(7))
irit.attrib(s2, "rgb", irit.GenStrObject("164,244,96"))
t1 = irit.tbezier( irit.list( irit.list( irit.list( irit.ctlpt( irit.E3, (-0.69 ), 0.31, (-0.6 ) ), \
irit.ctlpt( irit.E3, (-0.68 ), 0.35, (-0.39 ) ), \
irit.ctlpt( irit.E3, (-0.67 ), 0.31, (-0.18 ) ) ), irit.list( \
irit.ctlpt( irit.E3, (-0.66 ), 0.63, (-0.65 ) ), \
irit.ctlpt( irit.E3, (-0.75 ), 0.67, (-0.23 ) ), \
irit.ctlpt( irit.E3, (-0.64 ), 0.63, (-0.11 ) ) ), irit.list( \
irit.ctlpt( irit.E3, (-0.63 ), 0.84, (-0.65 ) ), \
