def plotfunc3d(minx, maxx, miny, maxy, n, m):
pl = plotfunc3d2poly(minx, maxx, miny, maxy, n, m)
irit.color(pl, irit.YELLOW)
irit.attrib(pl, "width", irit.GenRealObject(0.05))
minz = 1e+006
maxz = (-1e+006)
i = 0
while (i <= irit.SizeOf(pl) - 1):
p = irit.coord(pl, i)
j = 0
while (j <= irit.SizeOf(p) - 1):
v = irit.coord(p, i)
if (irit.FetchRealObject(irit.coord(v, 2)) > maxz):
maxz = irit.FetchRealObject(irit.coord(v, 2))
if (irit.FetchRealObject(irit.coord(v, 2)) < minz):
minz = irit.FetchRealObject(irit.coord(v, 2))
j = j + 1
i = i + 1
ax = (irit.poly(
irit.list((irit.min(minx, 0), 0, 0),
(irit.max(maxx, 0), 0, 0)), 1) + irit.poly(
irit.list((0, irit.min(miny, 0), 0),
(0, irit.max(maxy, 0), 0)), 1) + irit.poly(
irit.list((0, 0, irit.min(minz, 0)),
(0, 0, irit.max(maxz, 0))), 1))
irit.color(ax, irit.RED)
irit.attrib(ax, "width", irit.GenRealObject(0.02))
retval = irit.list(pl, ax)
irit.viewobj(retval)
irit.printf(
"xdomain = [%lf %lf], ydomain = [%lf %lf], zdomain = [%lf %lf]\n",
irit.list(minx, maxx, miny, maxy, minz, maxz))
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 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 gammakernelpolysrfs( pl, maxgamma, extent ):
retval = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pl ) ):
c = irit.coerce( irit.coord( pl, i - 1 ), irit.E2 ) + irit.coerce( irit.coord( pl, i ), irit.E2 )
k1 = irit.crvkernel( c, maxgamma, 0, irit.GenRealObject(extent), 2 )
k2 = irit.crvkernel( c, (-maxgamma ), 0, irit.GenRealObject(extent), 2 )
irit.snoc( irit.list( setrandomcolor( k1 ), setrandomcolor( k2 ) ), retval )
i = i + 1
return retval
def textgeom3daux(ply, wdth, dpth):
retval = irit.nil()
if (irit.ThisObject(ply) == irit.CURVE_TYPE):
retval = irit.extrude((-ply), (0, 0, dpth), 0)
if (irit.ThisObject(ply) == irit.POLY_TYPE):
retval = irit.extrude(
irit.ruledsrf(
irit.offset(ply, irit.GenRealObject(-wdth / 2.0), 0, 0),
irit.offset(ply, irit.GenRealObject(wdth / 2.0), 0, 0)),
(0, 0, dpth), 3)
return retval
def offsetcrvlist( clst, ofst ):
retval = irit.nil( )
i = 1
while ( i <= irit.SizeOf( clst ) ):
irit.snoc( irit.offset( irit.nth( clst, i ), irit.GenRealObject(ofst), 1e-006, 1 ), retval )
i = i + 1
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 treebranch(pt1, pt2, r):
retval = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 1 ),
irit.coerce( pt1, irit.E3 ) + \
irit.coerce( pt2, irit.E3 ),
irit.ctlpt( irit.E2, 0, r ) + \
irit.ctlpt( irit.E2, 1, r * wfactor ), irit.GenRealObject(0), 1 )
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 srflineinter( srf, pt1, pt2, dir, param, numsegs,\
tol ):
pta = irit.srinter(srf, irit.Fetch3TupleObject(pt1), dir, tol)
ptb = irit.srinter(
srf,
irit.Fetch3TupleObject(
ppblend(irit.Fetch3TupleObject(pt1), irit.Fetch3TupleObject(pt2),
2 / 3.0)), dir, tol)
ptc = irit.srinter(
srf,
irit.Fetch3TupleObject(
ppblend(irit.Fetch3TupleObject(pt1), irit.Fetch3TupleObject(pt2),
1 / 3.0)), dir, tol)
ptd = irit.srinter(srf, irit.Fetch3TupleObject(pt2), dir, tol)
crv = irit.bsp2bzr(
irit.cinterp(irit.list(pta, ptb, ptc, ptd), 4, 4,
irit.GenRealObject(param), 0))
crvs = irit.nil()
i = 1
while (i <= numsegs):
c = irit.cregion(crv, (i - 1) / float(numsegs), i / float(numsegs))
irit.color(c, i)
irit.snoc(c, crvs)
i = i + 1
retval = crvs
return retval
def sideunitshelf( w, d, h, legw, legd ):
shelfframe = ( irit.box( ( legd + 0.001, legd - 0.019, h - 0.015 ), w - 2 * legd - 0.002, d - 2 * legd + 0.038, 0.015 ) - irit.box( ( legd + 0.04, legd + 0.03, h - 0.1 ), w - 2 * legd - 0.08, d - 2 * legd - 0.06, h + 0.5 ) - irit.box( ( legd + 0.03, legd + 0.02, h - 0.005 ), w - 2 * legd - 0.05, d - 2 * legd - 0.04, h + 0.5 ) )
irit.attrib( shelfframe, "ptexture", woodtext )
irit.attrib( shelfframe, "rgb", woodclr )
shelfglass = irit.box( ( legd + 0.032, legd + 0.022, h - 0.003 ), w - 2 * legd - 0.064, d - 2 * legd - 0.044, 0.003 )
irit.attrib( shelfglass, "transp", irit.GenRealObject(0.3) )
retval = irit.list( shelfframe, shelfglass )
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 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 animbisectcrv2(crv1, crv2, moredata, cntr, skip):
irit.color(crv1, irit.YELLOW)
irit.color(crv2, irit.YELLOW)
irit.adwidth(crv1, 4)
irit.adwidth(crv2, 4)
sk = 0
i = 0
while (i <= irit.SizeOf(cntr) - 1):
pt = irit.coord(cntr, i)
pt1 = irit.ceval(crv1, irit.FetchRealObject(irit.coord(pt, 0)))
pt2 = irit.ceval(crv2, irit.FetchRealObject(irit.coord(pt, 1)))
nrml1 = cnormalplnr(crv1, irit.FetchRealObject(irit.coord(pt, 0)))
nrml2 = cnormalplnr(crv2, irit.FetchRealObject(irit.coord(pt, 1)))
aaa = irit.ptslnln(
irit.Fetch3TupleObject(irit.coerce(pt1, irit.POINT_TYPE)),
irit.Fetch3TupleObject(nrml1),
irit.Fetch3TupleObject(irit.coerce(pt2, irit.POINT_TYPE)),
irit.Fetch3TupleObject(nrml2))
if (irit.IsNullObject(aaa)):
interpt = irit.GenNullObject()
else:
interpt = irit.nth(aaa, 1)
if (irit.ThisObject(interpt) == irit.POINT_TYPE):
if ((interpt - irit.coerce(pt1, irit.POINT_TYPE)) * nrml1 >
irit.GenRealObject(0)
and (interpt - irit.coerce(pt2, irit.POINT_TYPE)) * nrml2 >
irit.GenRealObject(0)):
sk = sk + 1
if (sk >= skip):
sk = 0
irit.color(pt1, irit.GREEN)
irit.color(pt2, irit.GREEN)
irit.color(interpt, irit.WHITE)
irit.adwidth(interpt, 4)
bisectlns = irit.coerce(pt1, irit.E2) + irit.coerce(
interpt, irit.E2) + irit.coerce(pt2, irit.E2)
irit.color(bisectlns, irit.MAGENTA)
irit.adwidth(bisectlns, 2)
irit.view( irit.list( crv1, crv2, moredata, pt1, pt2, interpt, \
bisectlns ), irit.ON )
i = i + 1
def sideunitwalls( w, d, h, legw, legd ):
backwall = irit.box( ( legd, d - legd - 0.018, 0.2 ), w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( backwall, "ptexture", woodtext )
irit.attrib( backwall, "rgb", woodclr )
leftwall = irit.box( ( legd + 0.001, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
rightwall = irit.box( ( w - legd - 0.003, legd, 0.2 ), 0.002, d - 2 * legd, h - 0.3 )
irit.attrib( leftwall, "transp", irit.GenRealObject(0.3 ))
irit.attrib( rightwall, "transp", irit.GenRealObject(0.3 ))
frontdoorframe = ( irit.box( ( legw + 0.001, 0, 0.201 ), w - 2 * legw - 0.002, 0.015, h - 0.302 ) - irit.box( ( legw + 0.03, (-0.1 ), 0.23 ), w - 2 * legw - 0.062, 0.5, h - 0.362 ) - irit.box( ( legw + 0.02, 0.01, 0.22 ), w - 2 * legw - 0.04, 0.1, h - 0.34 ) )
irit.attrib( frontdoorframe, "ptexture", woodtext )
irit.attrib( frontdoorframe, "rgb", woodclr )
frontdoorglass = irit.box( ( legw + 0.021, 0.011, 0.221 ), w - 2 * legw - 0.042, 0.003, h - 0.342 )
irit.attrib( frontdoorglass, "transp", irit.GenRealObject(0.3) )
frontdoor = irit.list( frontdoorframe, frontdoorglass )
rot_z = ( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, 100 ) )
irit.attrib( frontdoor, "animation", irit.list( irit.tx( (-legw ) ), rot_z, irit.tx( legw ) ) )
retval = irit.list( backwall, leftwall, rightwall, frontdoor )
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 plotfunc2d(minx, maxx, n):
pl = plotfunc2d2poly(minx, maxx, n)
irit.color(pl, irit.YELLOW)
irit.attrib(pl, "width", irit.GenRealObject(0.05))
miny = 1e+006
maxy = -1e+006
i = 0
while (i <= 2):
miny = miny + i
i = i + 1
retval = pl
i = 0
while (i <= irit.SizeOf(pl) - 1):
v = irit.coord(pl, i)
real_val = irit.FetchRealObject(irit.coord(v, 1))
if (real_val > maxy):
maxy = irit.FetchRealObject(irit.coord(v, 1))
if (real_val < miny):
miny = irit.FetchRealObject(irit.coord(v, 1))
i = i + 1
ax = (irit.poly(
irit.list((irit.min(minx, 0), 0, 0),
(irit.max(maxx, 0), 0, 0)), 1) + irit.poly(
irit.list((0, irit.min(miny, 0), 0),
(0, irit.max(maxy, 0), 0)), 1))
irit.color(ax, irit.RED)
irit.attrib(ax, "width", irit.GenRealObject(0.02))
tr = irit.trans(
((-minx + maxx) / 2.0, (-miny + maxy) / 2.0, 0)) * irit.scale(
(2.0 / (maxx - minx), 2.0 / (maxy - miny), 0))
sv = irit.GetViewMatrix()
irit.SetViewMatrix(irit.rotx(0))
retval = irit.list(pl, ax) * tr
irit.viewobj(irit.list(irit.GetViewMatrix(), retval))
irit.printf("xdomain = [%lf %lf], ydomain = [%lf %lf]\n",
irit.list(minx, maxx, miny, maxy))
irit.SetViewMatrix(sv)
return retval
def cnvrtcrvs2ranges( crvs, idx, merge ):
retval = irit.nil( )
if ( merge ):
crvs = mergeverticalbndrycrvs( crvs )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
dm = irit.nth( crvs, i )
pt1 = irit.ceval( dm, 0 )
pt2 = irit.ceval( dm, 1 )
rng = irit.list( irit.coord( pt1, 2 ) ) + irit.list( irit.coord( pt2, 2 ) )
irit.attrib( rng, "index", irit.GenRealObject(idx) )
irit.snoc( rng, retval )
i = i + 1
return retval
def computesphericalcrv(theta1, theta2, phi1, phi2):
ptlist = irit.nil()
t = 0
while (t <= 100):
theta = (theta2 * t + theta1 * (100 - t)) * math.pi / (180 * 100)
phi = (phi2 * t + phi1 * (100 - t)) * math.pi / (180 * 100)
irit.snoc(
irit.point(
math.cos(theta) * math.cos(phi),
math.cos(theta) * math.sin(phi), math.sin(theta)), ptlist)
t = t + 1
retval = irit.cbspline(2, ptlist, irit.list(irit.KV_OPEN))
irit.attrib(retval, "dwidth", irit.GenRealObject(3))
irit.color(retval, irit.RED)
return retval
def computeorthovector(theta1, theta2, phi1, phi2):
theta1d = theta1 * math.pi / 180
theta2d = theta2 * math.pi / 180
phi1d = phi1 * math.pi / 180
phi2d = phi2 * math.pi / 180
pt1 = irit.point(
math.cos(theta1d) * math.cos(phi1d),
math.cos(theta1d) * math.sin(phi1d), math.sin(theta1d))
pt2 = irit.point(
math.cos(theta2d) * math.cos(phi2d),
math.cos(theta2d) * math.sin(phi2d), math.sin(theta2d))
retval = irit.coerce(irit.normalizePt(pt1 ^ pt2), irit.VECTOR_TYPE)
irit.attrib(retval, "dwidth", irit.GenRealObject(3))
irit.color(retval, irit.GREEN)
return retval
def cornerunitwalls( w, h, legw, legd ):
lwall = irit.box( ( legd, 0, 0.2 ), 2 * w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( lwall, "ptexture", woodtext )
irit.attrib( lwall, "rgb", woodclr )
swall = irit.box( ( legd, 0, 0.2 ), w - 2 * legd, 0.002, h - 0.3 )
irit.attrib( swall, "transp", irit.GenRealObject(0.3 ))
arcbar1 = irit.arc( ( w, 0, 0 ), ( w, w, 0 ), ( 2 * w, w, 0 ) )
arcbar2 = irit.offset( arcbar1, irit.GenRealObject(-0.03 ), 0.1, 0 )
arcbar = irit.list( irit.extrude( arcbar1 + (-arcbar2 ) + irit.ctlpt( irit.E3, w, 0, 0 ), ( 0, 0, 0.03 ), 0 ), irit.ruledsrf( arcbar1, arcbar2 ), irit.ruledsrf( arcbar1, arcbar2 ) * irit.tz( 0.03 ) )
rdoorframe = irit.list( irit.box( ( w, 0, 0.2 ), 0.03, 0.03, h - 0.3 ),\
irit.box( ( 2 * w - 0.03, w - 0.03, 0.2 ), 0.03, 0.03, h - 0.3 ),\
arcbar * irit.tz( 0.2 ), arcbar * irit.tz( h - 0.1 - 0.03 ) )
irit.attrib( rdoorframe, "ptexture", woodtext )
irit.attrib( rdoorframe, "rgb", woodclr )
rdoorglass = irit.extrude( irit.offset( arcbar1, irit.GenRealObject(-0.02 ), 0.1, 0 ) + (-irit.offset( arcbar1, irit.GenRealObject(-0.03 ), 0.1, 0 ) ) + \
irit.ctlpt( irit.E3, w - 0.02, 0, 0 ), ( 0, 0, h - 0.3 - 0.04 ), 0 ) * irit.tz( 0.22 )
irit.attrib( rdoorglass, "transp", irit.GenRealObject(0.3 ))
rdoor = irit.list( rdoorframe, rdoorglass )
rot_z = ( \
irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, 130 ) )
irit.attrib( rdoor, "animation", irit.list( irit.tx( (-w ) ), rot_z, irit.tx( w ) ) )
retval = irit.list( lwall * irit.ty( 2 * w ), swall * irit.rz( 90 ) * irit.tx( 2 * w ) * irit.ty( w ), lwall * irit.rz( 90 ), swall, rdoor )
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 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 warppoly(pl, tv):
retval = irit.GenRealObject(0)
i = 0
while (i <= irit.SizeOf(pl) - 1):
p = irit.coord(pl, i)
vlist = irit.nil()
j = 0
while (j <= irit.SizeOf(p) - 1):
v = irit.coord(p, j)
irit.snoc(
irit.coerce(
irit.teval(tv, irit.FetchRealObject(irit.coord(v, 0)),
irit.FetchRealObject(irit.coord(v, 1)),
irit.FetchRealObject(irit.coord(v, 2))),
irit.POINT_TYPE), vlist)
j = j + 1
if (irit.ThisObject(retval) == irit.NUMERIC_TYPE):
retval = irit.poly(vlist, irit.FALSE)
else:
retval = irit.mergepoly(irit.list(irit.poly(vlist, 0), retval))
i = i + 1
irit.cpattr(retval, pl)
return retval
c1 = irit.pcircle((0, 0, 0), 0.3) * irit.tz(2)
c2 = c1 * irit.sc(0.5) * irit.tz((-3))
r2 = irit.ruledsrf(c1, c2) * irit.ry(90)
irit.awidth(r2, 0.007)
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), 50,
0), 1)
irit.color(c, irit.RED)
irit.adwidth(c, 3)
irit.awidth(c, 0.02)
irit.attrib(c, "gray", irit.GenRealObject(0.5))
irit.interact(irit.list(r1, r2, c))
irit.save("rrint5a", 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), 25, 1)
zerosetsrfe3 = irit.coerce(zerosetsrf, irit.E3) * irit.rotx((-90)) * irit.roty(
(-90)) * irit.sz(0.02)
irit.awidth(zerosetsrfe3, 0.007)
zeroset = irit.contour(zerosetsrfe3, irit.plane(0, 0, 1, 1e-005))
irit.color(zeroset, irit.RED)
irit.ctlpt( irit.E2, 0.95, 3.6 ), \
irit.ctlpt( irit.E2, 0.35, 3.6 ), \
irit.ctlpt( irit.E2, 1.3, 0.05 ) ) ) * irit.sy( 0.2 )
crv2b = irit.cbezier( irit.list( \
irit.ctlpt( irit.E1, (-0.4 ) ), \
irit.ctlpt( irit.E2, 0.05, 0.9 ), \
irit.ctlpt( irit.E2, 0.5, 0.7 ), \
irit.ctlpt( irit.E2, 0.35, 0.5 ), \
irit.ctlpt( irit.E2, 1.1, (-0.5 ) ) ) ) * irit.ty( 0.3 ) * irit.sx( 1.5 )
irit.save(
"dist2ff2",
irit.list(testccdistfunc(crv1a, crv2a, irit.nil()),
testccdistfunc(crv1a, crv2a, irit.list(0.5)),
testccdistfunc(crv1b, crv2b, irit.nil()),
testccdistfunc(crv1b, crv2b,
irit.list(irit.GenRealObject(0.5)))))
irit.free(crv1a)
irit.free(crv2a)
irit.free(crv1b)
irit.free(crv2b)
# ############################################################################
crv = irit.cbezier( irit.list( irit.ctlpt( irit.E1, (-0.2 ) ), \
irit.ctlpt( irit.E2, 0.25, 1.2 ), \
irit.ctlpt( irit.E2, 0.75, 0.7 ), \
irit.ctlpt( irit.E2, 1.3, 0.05 ) ) )
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# A cube from a chain of 27 smaller cubes forming a 3 by 3 by 3 set.
#
# Gershon Elber, May 1998
#
ri = irit.iritstate("randominit", irit.GenRealObject(1964))
# 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)
# Created by Gershon Elber, Apr 90
#
t = irit.time(1)
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.scale((0.5, 0.5, 0.5)))
save_res = irit.GetResolution()
#
# Try it with coplanar false for fun.
#
# irit.iritstate( "coplanar", false );
#
psort = irit.iritstate("polysort", irit.GenRealObject(0))
t1 = irit.box(((-2), (-0.35), 0), 4, 0.7, 0.4)
irit.SetResolution(80)
t2 = irit.cylin((0, 0, 0), (0, 0, 0.4), 1.4, 3)
s1 = t1 * t2
irit.free(t1)
irit.free(t2)
irit.view(irit.list(irit.GetViewMatrix(), s1), irit.ON)
irit.SetResolution(40)
t3 = irit.cylin((0, 0, 0), (0, 0, 0.4), 0.9, 3)
s2 = (s1 + t3)
irit.free(t3)
irit.free(s1)
irit.view(s2, irit.ON)
# # Gershon Elber, April 94. # save_mat = irit.GetViewMatrix() save_res = irit.GetResolution() length = 0.7 radius = 0.2 irit.SetResolution(40) c1 = irit.cylin(((-length) / 2, 0, 0), (length, 0, 0), radius, 3) 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
