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 positioncurvature(srf, u, v):
eps = 1e-012
c = irit.circle((0, 0, 0), 1)
k = irit.scrvtreval(srf, u, v, 1)
r1 = irit.max(
irit.min(1.0 / (irit.FetchRealObject(irit.nth(k, 1)) + eps), 1000),
(-1000))
r2 = irit.max(
irit.min(1.0 / (irit.FetchRealObject(irit.nth(k, 3)) + eps), 1000),
(-1000))
v1 = irit.nth(k, 2)
v2 = irit.nth(k, 4)
p = irit.seval(srf, u, v)
n = irit.snormal(srf, u, v)
d1 = v1 ^ n
d2 = v2 ^ n
c1 = c * \
irit.sc( r1 ) * \
irit.rotz2v( irit.Fetch3TupleObject(d1) ) * \
irit.trans( irit.Fetch3TupleObject(irit.coerce( p, irit.VECTOR_TYPE ) + n * r1 ))
c2 = c * \
irit.sc( r2 ) * \
irit.rotz2v( irit.Fetch3TupleObject(d2) ) * \
irit.trans( irit.Fetch3TupleObject(irit.coerce( p, irit.VECTOR_TYPE ) + n * r2) )
retval = irit.list(
p, c1, c2,
p + irit.coerce(irit.coerce(p, irit.POINT_TYPE) + v1, irit.E3),
p + irit.coerce(irit.coerce(p, irit.POINT_TYPE) + v2, irit.E3),
positionasymptotes(srf, u, v))
irit.adwidth(retval, 2)
irit.color(retval, irit.YELLOW)
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 displayposnormal(crv, t1, t2, scl, bg_obj):
pt1 = irit.ceval(crv, irit.FetchRealObject(t1))
pt2 = irit.ceval(crv, irit.FetchRealObject(t2))
n1 = irit.cnormal(crv, irit.FetchRealObject(t1))
n2 = irit.cnormal(crv, irit.FetchRealObject(t2))
ptt1 = (irit.ctlpt(irit.E2, t1, t2) + irit.ctlpt(irit.E2, t1, 0))
irit.color(ptt1, irit.YELLOW)
ptt2 = (irit.ctlpt(irit.E2, t1, t2) + irit.ctlpt(irit.E2, 0, t2))
irit.color(ptt2, irit.CYAN)
n1 = (irit.coerce(
irit.coerce(pt1, irit.POINT_TYPE) + n1 * irit.sc(scl), irit.E2) + pt1)
irit.color(n1, irit.YELLOW)
n2 = (irit.coerce(
irit.coerce(pt2, irit.POINT_TYPE) + n2 * irit.sc(scl), irit.E2) + pt2)
irit.color(n2, irit.CYAN)
irit.view(irit.list(n1, n2, pt1, pt2, ptt1, ptt2, bg_obj), irit.ON)
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 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 snakepiece(clr, xrot, ypos, zpos):
retval = (irit.box((0, 0, (-0.1)), 1, 1.1, 1.1) - irit.box(
(0, (-1), (-2)), 2, 3, 2) * irit.rx(45) * irit.tx((-0.5)))
retval = retval * irit.sc(1.0 / math.sqrt(2)) * irit.rx(
(-225)) * irit.trans(((-1) / (2.0 * math.sqrt(2)), 1, 0.5))
retval = retval * irit.rx(xrot) * irit.ty(ypos) * irit.tz(zpos)
irit.color(retval, clr)
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 canonicalh(f, g, deg, c, ptype):
net = irit.nil()
t = irit.ceval(g, 1)
g2 = g * irit.sc(1 / irit.FetchRealObject(irit.coord(t, 1)))
f2 = irit.cregion(f, 0, irit.FetchRealObject(irit.coord(t, 1)))
f_p = irit.coerce(f2, irit.POWER_TYPE)
tmp = irit.ffsplit(f_p)
i = 1
while (i <= c):
bm = irit.coord(irit.coord(irit.nth(tmp, i), deg), 1)
tmp2 = irit.coerce(irit.nth(tmp, i), irit.BEZIER_TYPE) * irit.sc(
1 / irit.FetchRealObject(bm))
irit.snoc(
irit.coerce(irit.coerce(irit.compose(tmp2, g2), irit.BEZIER_TYPE),
irit.E1), net)
i = i + 1
retval = irit.ffmerge(net, ptype)
return retval
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 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 originalf(f, newf, deg, c, ptype):
net = irit.nil()
f_p = irit.coerce(f, irit.POWER_TYPE)
tmp = irit.ffsplit(f_p)
tmp3 = irit.ffsplit(newf)
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
def computetopoaspectgraph(s, spc):
ag = irit.saspctgrph(s)
irit.color(ag, irit.YELLOW)
irit.adwidth(ag, 3)
sp = irit.spheresrf(1)
irit.color(sp, irit.RED)
s1 = s * irit.tx(0)
irit.color(s1, irit.GREEN)
irit.adwidth(s1, 2)
retval = irit.list(
irit.list(ag, sp, irit.GetAxes()) * irit.sc(0.6) * irit.tx(spc),
irit.list(s1, irit.GetAxes()) * irit.tx((-spc)))
return retval
def uvpos2ln(srf, lnpt, lndir, mindist):
uvpt = irit.srflndst(srf, irit.Fetch3TupleObject(lnpt), lndir, mindist,
0.001, 1e-010)
e3pt = irit.seval(srf, irit.FetchRealObject(irit.coord(uvpt, 0)),
irit.FetchRealObject(irit.coord(uvpt, 1)))
e3nrml = irit.snormal(srf, irit.FetchRealObject(irit.coord(uvpt, 0)),
irit.FetchRealObject(irit.coord(uvpt, 1)))
edge = irit.coerce( irit.ptptln( irit.Fetch3TupleObject(irit.coerce( e3pt, irit.POINT_TYPE )),
irit.Fetch3TupleObject(lnpt),
lndir ),
irit.E3 ) + \
e3pt
nedge = (e3pt +
irit.coerce(irit.coerce(e3pt, irit.POINT_TYPE) - e3nrml, irit.E3))
irit.color(e3pt, irit.MAGENTA)
irit.adwidth(e3pt, 3)
irit.color(edge, irit.CYAN)
irit.color(nedge, irit.GREEN)
line = irit.coerce( lnpt + irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 ) + \
irit.coerce( lnpt - irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 )
irit.color(line, irit.YELLOW)
retval = irit.list(line, e3pt, edge, nedge)
return retval
def 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 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
irit.ctlpt( irit.E3, 80, 0, 75 ) ), irit.list( irit.KV_OPEN ) )
backcrosspts = irit.list(irit.vector(80, 0, 75), irit.vector(80, 0, 45),
irit.vector(0, 0, 45))
heartcross = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, (-10 ) ), \
irit.ctlpt( irit.E3, 3, 0, 0 ), \
irit.ctlpt( irit.E3, 12, 0, 5 ), \
irit.ctlpt( irit.E3, 12, 0, 15 ), \
irit.ctlpt( irit.E3, 3, 0, 15 ), \
irit.ctlpt( irit.E3, 0, 0, 10 ) ), irit.list( irit.KV_OPEN ) ) + irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E3, 0, 0, 10 ), \
irit.ctlpt( irit.E3, (-2 ), 0, 15 ), \
irit.ctlpt( irit.E3, (-13 ), 0, 15 ), \
irit.ctlpt( irit.E3, (-13 ), 0, 5 ), \
irit.ctlpt( irit.E3, (-5 ), 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0, (-10 ) ) ), irit.list( irit.KV_OPEN ) ) ) * irit.sc( 0.5 ) * irit.trans( ( 40, 1, 65 ) )
#
# We generate some colinear vertices here:
#
back = ( irit.extrude( \
irit.poly( \
irit.cnvrtpolytoptlist( \
irit.cnvrtcrvtopolygon( backcross, 50, 0 ) \
) + \
backcrosspts, 0 \
), \
( 0, 2, 0 ), \
3 \
#
import math
import irit
#
#
# Some examples of 3d alpha-sector computations of 3-space freeform curves.
#
# Gershon Elber, October 1998.
#
#
# 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)
c2 = irit.cylin((0, (-length) / 2, 0), (0, length, 0), radius, 3)
c3 = irit.cylin((0, 0, (-length) / 2), (0, 0, length), radius, 3)
irit.attrib(c1, "width", irit.GenRealObject(0.0001))
irit.attrib(c2, "width", irit.GenRealObject(0.0001))
irit.attrib(c3, "width", irit.GenRealObject(0.0001))
c12 = c1 * c2
c123 = c12 * c3
irit.attrib(c123, "width", irit.GenRealObject(0.005))
irit.color(c123, irit.RED)
irit.adwidth(c123, 3)
all = irit.list(c123, c1, c2, c3)
irit.SetViewMatrix(irit.sc(1.1))
irit.viewobj(irit.GetViewMatrix())
tr = 0.4
proj1 = all * irit.trans(((-tr), tr, 0))
proj2 = all * irit.rotx(90) * irit.trans((tr, tr, 0))
proj3 = all * irit.roty(90) * irit.trans(((-tr), (-tr), 0))
proj4 = all * irit.roty(30) * irit.rotx(20) * irit.trans((tr, (-tr), 0))
allproj = irit.list(proj1, proj2, proj3, proj4)
irit.save("cylin3a", allproj)
irit.interact(allproj)
c123a = c123 * irit.roty(30) * irit.rotx(20) * irit.scale((3, 3, 3))
irit.attrib(c123a, "width", irit.GenRealObject(0.015))
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Convex Hull and related computation for freeform curves.
#
# Gershon Elber, February 1996
#
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
pt = irit.teval( tv, x, y, z )
v = math.floor( i/float(usize) )
u = i - v * usize
srf = irit.seditpt( srf, pt, u, v )
i = i + 1
irit.attrib( srf, "color", clr )
retval = srf
return retval
#
# Properly orient the Teapot in the parametric space of the Trivariate
#
prmdomain = irit.box( ( 0, 0, 0 ), 0.5, 1, 1 )
irit.attrib( prmdomain, "transp", irit.GenRealObject(0.8) )
teapot = teapotorig * irit.sc( 0.13 ) * irit.rz( 90 ) * irit.rx( 90 ) * irit.sx( (-1 ) ) * irit.trans( ( 0, 0.5, 0.5 ) )
all = irit.list( prmdomain, teapot ) * irit.rz( 90 ) * irit.ry( 40 ) * irit.rx( 40 )
interact( irit.list( all, irit.GetViewMatrix() ) )
irit.save( "warp1trv", all )
#
# Warp the teapot, one surface at a time, after some surface refinement.
#
warpedteapot = irit.nil( )
i = 1
while ( i <= irit.SizeOf( teapot ) ):
srf = irit.nth( teapot, i )
clr = irit.getattr( srf, "color" )
srf = irit.sreparam( irit.sreparam( srf, irit.COL, 0, 1 ), irit.ROW, 0,\
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Intersection of cone and a cylinder: # Try this one with resolution equal 20 - slower, but much nicer! # # Created by Gershon Elber, Jan. 89 # view_mat1 = irit.GetViewMatrix() * irit.sc(0.2) save_res = irit.GetResolution() irit.SetResolution(8) # ############################################################################ cone1 = irit.con2((0, 0, (-1)), (0, 0, 4), 2, 1, 3) cylin1 = irit.cylin((0, 3, 0), (0, (-6), 2), 0.7, 3) a = (cone1 + cylin1) irit.free(cylin1) irit.free(cone1) irit.interact(irit.list(view_mat1, a)) # # Currently variables can not be introduced in a loop (except the iteration # variable), so we prepare all variables in advance. #
irit.printf(
"rz alignment: length of intersection curve %d, time = %f sec.\n",
irit.list(irit.SizeOf(irit.nth(irit.nth(inter, 1), 1)), tm))
# ############################################################################
s1 = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0.05, 0.2, 0.1 ), \
irit.ctlpt( irit.E3, 0.1, 0.05, 0.2 ) ), irit.list( \
irit.ctlpt( irit.E3, 0.1, (-0.2 ), 0 ), \
irit.ctlpt( irit.E3, 0.15, 0.05, 0.1 ), \
irit.ctlpt( irit.E3, 0.2, (-0.1 ), 0.2 ) ), irit.list( \
irit.ctlpt( irit.E3, 0.2, 0, 0 ), \
irit.ctlpt( irit.E3, 0.25, 0.2, 0.1 ), \
irit.ctlpt( irit.E3, 0.3, 0.05, 0.2 ) ) ) ) * irit.sc( 4 ) * irit.sy( 0.3 )
irit.color(s1, irit.RED)
s2 = s1 * irit.rx(4) * irit.rz(2)
irit.color(s2, irit.BLUE)
testssi(s1, s2, 0.1)
testssi(s1, s2, 0.03)
s1 = s1 * irit.sy(0.1)
s2 = s2 * irit.sy(0.1)
irit.color(s1, irit.RED)
irit.color(s2, irit.BLUE)
testssi(s1, s2, 0.1)
testssi(s1, s2, 0.03)
#
#
# The Blade
#
sec1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-0.525 ), (-0.041 ), 0 ), \
irit.ctlpt( irit.E2, (-0.0935 ), 0.102 ), \
irit.ctlpt( irit.E2, 0.487, 0.14 ), \
irit.ctlpt( irit.E2, 0.882, 0.112 ), \
irit.ctlpt( irit.E2, 0.878, 0.198 ), \
irit.ctlpt( irit.E2, 0.559, 0.403 ), \
irit.ctlpt( irit.E2, (-0.183 ), 0.252 ), \
irit.ctlpt( irit.E2, (-0.525 ), (-0.04 ) ) ), irit.list( irit.KV_OPEN ) ) * irit.tx( (-0.2 ) ) * irit.ty( (-0.2 ) )
sec2 = sec1 * irit.sy(0.5) * irit.sc(1.2) * irit.tz(2.5) * irit.rz(30)
bladeside = irit.ruledsrf(sec1, sec2)
bladetop = irit.ruledsrf(irit.cregion(sec2, 0, 0.5),
(-irit.cregion(sec2, 0.5, 1)))
blademain = irit.list(bladeside, bladetop) * irit.tz(0.2)
irit.free(bladeside)
irit.free(bladetop)
bladefillet = irit.sfromcrvs(
irit.list(sec1 * irit.sc(1.35) * irit.sy(1.5) * irit.tz((-0.1)), sec1,
sec1 * irit.tz(0.2)), 3, irit.KV_OPEN)
irit.free(sec1)
irit.free(sec2)
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),
crv * irit.sc(0.96) * irit.tz(0.2),
crv * irit.sc(0.87) * irit.tz(0.35),
crv * irit.sc(0.7) * irit.tz(0.5)), 3, irit.KV_OPEN)
irit.free(crv)
irit.free(crv2)
tcrvs1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.3, 1.4 ), \
irit.ctlpt( irit.E2, 0.7, 1.4 ), \
irit.ctlpt( irit.E2, 0.7, 2.2 ), \
irit.ctlpt( irit.E2, 0.3, 2.2 ) ), irit.list( irit.KV_PERIODIC ) )
tcrvs2 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1.3, 1.4 ), \
irit.ctlpt( irit.E2, 1.7, 1.4 ), \
irit.ctlpt( irit.E2, 1.7, 2.2 ), \
irit.ctlpt( irit.E2, 1.3, 2.2 ) ), irit.list( irit.KV_PERIODIC ) )
tcrvs3 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, 0 ), \
irit.ctlpt( irit.E2, 1, 0 ), \
strip1 = irit.poly(
irit.list(((-2), (-1.3), 0), (2, (-1.3), 0), irit.point(2, (-1.1), 0),
irit.point((-2), (-1.1), 0)), irit.FALSE)
irit.color(strip1, irit.CYAN)
strip2 = strip1 * irit.ty(2.4)
irit.color(strip2, irit.CYAN)
backgrnd = irit.poly(
irit.list(((-2), (-1.5), 0),
(2, (-1.5), 0), irit.point(2, 1.5, 0), irit.point(
(-2), 1.5, 0)), 0) * irit.tz((-0.01))
irit.color(backgrnd, irit.WHITE)
isflag = irit.list(davidstar * irit.sc(0.7), strip1, strip2, backgrnd)
irit.interact(isflag)
irit.save("isflag", isflag)
irit.free(strip1)
irit.free(strip2)
irit.free(backgrnd)
irit.free(davidstar)
irit.free(isflag)
# ############################################################################
irit.SetResolution(save_res)
#
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)
irit.interact(irit.list(s, s1, s2, s3))
# Case 2
#
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) * irit.sc(0.9)
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(c, irit.RED)
irit.adwidth(c, 3)
irit.interact(irit.list(r1, r2, c))
zerosetsrf = 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, 1)
zerosetsrfe3 = irit.coerce(zerosetsrf, irit.E3) * irit.rotx((-90)) * irit.roty(
retval = irit.nil( )
j = 0
while ( j <= irit.SizeOf( pl ) - 1 ):
irit.snoc( irit.coord( pl, j ), retval )
j = j + 1
irit.snoc( irit.coord( pl, 0 ), retval )
retval = irit.poly( retval, irit.TRUE )
irit.attrib( retval, "dwidth", irit.GenIntObject(3 ))
return retval
def extractgammasrf( tv, t, clr ):
retval = irit.strivar( tv, irit.ROW, t )
irit.color( retval, clr )
return retval
view_mat1 = irit.sc( 1 )
irit.viewobj( view_mat1 )
irit.viewstate( "numisos", 1 )
irit.viewstate( "numisos", 1 )
irit.viewstate( "polyaprx", 1 )
irit.viewstate( "polyaprx", 1 )
irit.viewstate( "polyaprx", 1 )
irit.viewstate( "drawstyle", 1 )
irit.viewstate( "depthcue", 0 )
irit.viewstate( "dsrfpoly", 1 )
# ############################################################################
#
# Polygons:
def antbody():
save_res = irit.GetResolution()
c = irit.pcircle((0, 0, 0), 1)
body = (-irit.sfromcrvs(
irit.list(
c * irit.sc(1e-006) * irit.ty((-0.1)) * irit.tz(0.19),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.19),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.21),
c * irit.sy(0.8) * irit.sc(0.14) * irit.ty((-0.1)) * irit.tz(0.23),
c * irit.sy(0.8) * irit.sc(0.14) * irit.ty((-0.1)) * irit.tz(0.26),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.28),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.29),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.05)) * irit.tz(0.31),
c * irit.sy(0.8) * irit.sc(0.27) * irit.ty(
(-0.05)) * irit.tz(0.41),
c * irit.sy(0.8) * irit.sc(0.19) * irit.ty(
(-0.05)) * irit.tz(0.44),
c * irit.sy(0.8) * irit.sc(0.19) * irit.ty(
(-0.05)) * irit.tz(0.45),
c * irit.sy(0.8) * irit.sc(0.3) * irit.ty(
(-0.035)) * irit.tz(0.47),
c * irit.sy(0.8) * irit.sc(0.32) * irit.ty(
(-0.035)) * irit.tz(0.59),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.035)) * irit.tz(0.62),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.035)) * irit.tz(0.63),
c * irit.sy(0.8) * irit.sc(0.3) * irit.ty((-0.03)) * irit.tz(0.65),
c * irit.sy(0.8) * irit.sc(0.28) * irit.ty(
(-0.03)) * irit.tz(0.76),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.85),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.87),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty((-0.1)) * irit.tz(0.93),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty((-0.1)) * irit.tz(1.03),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(1.1),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(1.12),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty(
(-0.06)) * irit.tz(1.18),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty(
(-0.03)) * irit.tz(1.32),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0)) * irit.tz(1.41),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0)) * irit.tz(1.43),
c * irit.sy(0.8) * irit.sc(0.22) * irit.ty(0.05) * irit.tz(1.5),
c * irit.sy(0.8) * irit.sc(0.2) * irit.ty((-0)) * irit.tz(1.66),
c * irit.sy(0.8) * irit.sc(0.05) * irit.ty(
(-0.22)) * irit.tz(1.85),
c * irit.sy(0.8) * irit.sc(1e-006) * irit.ty(
(-0.22)) * irit.tz(1.86)), 3, irit.KV_OPEN))
irit.SetResolution(15)
eye1 = irit.sphere((0, 0, 0), 0.08) * irit.rx(20) * irit.ry(
(-20)) * irit.trans((0.15, 0.05, 1.59))
eye2 = eye1 * irit.sx((-1))
irit.SetResolution(20)
bodycut = body / eye1 ^ eye2
irit.attrib(bodycut, "rgb", irit.GenStrObject("255,50,50"))
eye1cut = eye1 / body
irit.attrib(eye1cut, "reflection", irit.GenStrObject("0.85"))
irit.attrib(eye1cut, "rgb", irit.GenStrObject("15,15,15"))
eye2cut = eye2 / body
irit.attrib(eye2cut, "reflection", irit.GenStrObject("0.85"))
irit.attrib(eye2cut, "rgb", irit.GenStrObject("15,15,15"))
irit.SetResolution(save_res)
retval = irit.list(bodycut, irit.list(eye1cut, eye2cut))
return retval
