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 plotfunc3d2poly(minx, maxx, miny, maxy, n, m):
first = 1
x = minx
while (x <= maxx):
lst = irit.nil()
y = miny
while (y <= maxy):
irit.snoc(irit.vector(x, y, plotfn3d(x, y)), lst)
y = y + (maxy - miny) / float(n - 1)
if (first == 1):
retval = irit.poly(lst, irit.TRUE)
first = 0
else:
retval = retval + irit.poly(lst, irit.TRUE)
x = x + (maxx - minx) / float(m - 1)
y = miny
while (y <= maxy):
lst = irit.nil()
x = minx
while (x <= maxx):
irit.snoc(irit.vector(x, y, plotfn3d(x, y)), lst)
x = x + (maxx - minx) / float(n - 1)
retval = retval + irit.poly(lst, irit.TRUE)
y = y + (maxy - miny) / float(m - 1)
return retval
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 raytraptris3d(srfs, subeps, numeps):
pts = irit.raytraps(srfs, 1, subeps, numeps, 1)
retval = irit.nil()
if (irit.SizeOf(pts) > 1):
irit.printf("%d solution(s) found\n", irit.list(irit.SizeOf(pts)))
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.coord(pts, i)
err = irit.getattr(pt, "rngerror")
if (irit.ThisObject(err) == irit.NUMERIC_TYPE):
irit.printf("error = %16.14f\n", irit.list(err))
else:
irit.printf("error is not provided\n", irit.nil())
points = irit.nil()
j = 1
while (j <= irit.SizeOf(srfs)):
irit.snoc(
irit.seval(
irit.nth(srfs, j),
irit.FetchRealObject(irit.coord(pt, 1 + (j - 1) * 2)),
irit.FetchRealObject(irit.coord(pt, 2 + (j - 1) * 2))),
points)
j = j + 1
irit.snoc(irit.poly(points, 0), retval)
i = i + 1
return retval
def plotfunc2d2poly(min, max, n):
lst = irit.nil()
t = min
while (t <= max):
irit.snoc(irit.vector(t, plotfn2d(t), 0), lst)
t = t + (max - min) / float(n - 1)
retval = irit.poly(lst, irit.TRUE)
return retval
def pyramidprisa(n, s):
pts = irit.nil()
i = 0
while (i <= n):
irit.snoc(
irit.point(math.cos(i * 2 * math.pi / n),
math.sin(i * 2 * 3.14159 / n), 0), pts)
i = i + 1
retval = irit.list(irit.poly(pts, 1))
i = 1
while (i <= n):
irit.snoc( irit.poly( irit.list( irit.nth( pts, i ), \
irit.nth( pts, i + 1 ), \
( irit.nth( pts, i ) + irit.nth( pts, i + 1 ) ) * s ), 0 ), retval )
i = i + 1
return retval
def makepolylines(listofctlpts):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(listofctlpts)):
pl = irit.nth(listofctlpts, i)
if (irit.SizeOf(pl) > 1):
irit.snoc(irit.poly(irit.nth(listofctlpts, i), 1), retval)
i = i + 1
return retval
def plgntoplln( pl ):
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 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 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 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
def boundingellipse(pt1, pt2, pt3):
m = irit.map3pt2eql( irit.Fetch3TupleObject(pt1), \
irit.Fetch3TupleObject(pt2), \
irit.Fetch3TupleObject(pt3) )
minv = m ^ (-1)
pt = m * pt1
r = math.sqrt(irit.FetchRealObject(pt * pt))
el = irit.nil()
j = 0
while (j <= 360):
irit.snoc(
irit.point(r * math.cos(j * math.pi / 180),
r * math.sin(j * math.pi / 180), 0) * minv, el)
j = j + 10
retval = irit.poly(el, irit.TRUE)
irit.color(retval, irit.YELLOW)
return retval
def warpsurface(pls, tv):
retval = irit.nil()
i = 0
while (i <= irit.SizeOf(pls) - 1):
pl = irit.coord(pls, i)
v = irit.nil()
j = 0
while (j <= irit.SizeOf(pl) - 1):
vec = irit.coord(pl, j)
x = irit.FetchRealObject(irit.coord(vec, 0))
y = irit.FetchRealObject(irit.coord(vec, 1))
z = irit.FetchRealObject(irit.coord(vec, 2))
vec = irit.coerce(irit.teval(tv, x, y, z), irit.VECTOR_TYPE)
irit.snoc(vec, v)
j = j + 1
irit.snoc(irit.poly(v, 0), retval)
i = i + 1
retval = irit.mergepoly(retval)
return retval
def menugengeometry(menuitems, itemsize, minx, miny, maxx, maxy):
n = irit.SizeOf(menuitems)
retval = irit.nil()
i = 0
while (i <= n - 1):
x1 = minx
x2 = maxx
y1 = miny + (maxy - miny) * i / n
y2 = y1 + (maxy - miny) * 0.8 / n
irit.snoc(
irit.list(
irit.poly(
irit.list((x1, y1, 0), irit.point(x1, y2, 0),
irit.point(x2, y2, 0), irit.point(x2, y1, 0),
irit.point(x1, y1, 0)), 1),
irit.textgeom(irit.FetchStrObject(irit.nth(menuitems, i + 1)),
(itemsize * 0.06, 0, 0), itemsize * 0.06) *
irit.trans((x1 + itemsize * 0.07, (y1 + y2) / 2, 0))), retval)
i = i + 1
return retval
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 \
) - \
irit.extrude( \
irit.cnvrtcrvtopolygon( heartcross, 50, 0 ), \
( 0, (-2 ), 0 ), \
3 \
) \
) * irit.ty( 189 )
irit.attrib(back, "rgb", irit.GenStrObject("244,164,96"))
irit.free(backcrosspts)
irit.free(heartcross)
# 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)
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(
v1 = (0.6, 0, 0.25) v2 = (0.9, 0, 0.25) v3 = (0.9, 0, 0.2) v4 = (0.8, 0, 0.2) v5 = (0.8, 0, (-0.2)) v6 = (0.9, 0, (-0.2)) v7 = (0.9, 0, (-0.25)) v8 = (0.6, 0, (-0.25)) v9 = (0.6, 0, (-0.2)) v10 = (0.7, 0, (-0.2)) v11 = (0.7, 0, 0.2) v12 = (0.6, 0, 0.2) plgcross = irit.poly( irit.list( v1, v2, v3, v4, v5, v6,\ v7, v8, v9, v10, v11, v12 ),\ 0 ) pllcross = irit.poly( irit.list( v1, v2, v3, v4, v5, v6,\ v7, v8, v9, v10, v11, v12,\ v1 ), 1 ) irit.color(pllcross, irit.GREEN) irit.adwidth(pllcross, 5) irit.SetResolution(16) t1 = irit.surfrev2(plgcross, 33, 180) irit.interact(irit.list(pllcross, irit.GetAxes(), t1)) t2 = irit.surfrevaxs(plgcross, (1, 0, 1))
irit.save(
"ffcnvhl1",
irit.list(irit.list(c0, chc0),
irit.list(c1, chc1) * irit.tx(3),
irit.list(c2, chc2) * irit.tx(6)))
# Discrete case works on loops as well:
l = irit.nil()
numpts = 30
i = 0
while (i <= numpts):
irit.snoc(irit.vector(irit.random((-1), 1), irit.random((-1), 1), 0), l)
i = i + 1
p = irit.poly(l, irit.FALSE)
irit.color(p, irit.RED)
irit.adwidth(p, 5)
ch = irit.cnvxhull(p, 0)
irit.color(ch, irit.GREEN)
irit.adwidth(ch, 2)
irit.interact(irit.list(ch, p))
irit.save("ffcnvhl2", irit.list(p, ch))
#
# Tangents to curve through a point.
#
irit.viewclear()
#
#
# Point inclusion tests.
#
# Gershon Elber, Nov 2007
#
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.ctlpt( irit.E1, 1 ) ), irit.list( irit.KV_OPEN ) )
cbsp = irit.compose(crv1, crv2)
irit.free(crv1)
irit.free(crv2)
steps = 8
pt_lst = irit.nil()
i = 0
while (i <= steps - 1):
pt = irit.ceval(
cbsp,
irit.FetchRealObject(irit.nth(irit.pdomain(cbsp), 2)) * i /
(steps - 1))
irit.snoc(pt, pt_lst)
i = i + 1
cpl = irit.poly(pt_lst, irit.TRUE)
irit.color(cpl, irit.GREEN)
irit.SetResolution(0.02)
cbsp2 = cbsp
cpl2 = irit.gpolyline(cbsp2, 2)
irit.color(cpl2, irit.YELLOW)
irit.SetResolution(20)
irit.interact(irit.list(cbsp, cpl2, cpl))
irit.save("gpolyln1", irit.list(cbsp, cpl2, cpl))
# ############################################################################
cbsp = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, (-1 ) ), \
irit.ctlpt( irit.E2, 0.3, 1 ), \
# 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:
#
# c = center of mass of Pi, i = 0,..,3
#
#
save_res = irit.GetResolution()
#
# American plane's marker
#
d = math.pi / 180 * 360 * 2 / 5
ptc = (0, 0, 0)
pt1 = (math.cos(0), math.sin(0), 0)
pt2 = (math.cos(d), math.sin(d), 0)
pt3 = (math.cos(d * 2), math.sin(d * 2), 0)
pt4 = (math.cos(d * 3), math.sin(d * 3), 0)
pt5 = (math.cos(d * 4), math.sin(d * 4), 0)
star = irit.list(irit.poly(irit.list(ptc, pt1, pt2), irit.FALSE),
irit.poly(irit.list(ptc, pt2, pt3), irit.FALSE),
irit.poly(irit.list(ptc, pt3, pt4), irit.FALSE),
irit.poly(irit.list(ptc, pt4, pt5), irit.FALSE),
irit.poly(irit.list(ptc, pt5, pt1), irit.FALSE)) * irit.rz(90)
irit.color(star, irit.WHITE)
irit.SetResolution(80)
circ = irit.circpoly((0, 0, 1), (0, 0, 0), 1) * irit.tz((-0.01))
irit.color(circ, irit.BLUE)
irit.attrib(circ, "rgb", irit.GenStrObject("0,0,8"))
irit.SetResolution(20)
logo1 = irit.list(circ, star)
irit.interact(logo1)
irit.color(handle, irit.MAGENTA)
irit.SetViewMatrix(irit.scale((0.3, 0.3, 0.3)))
save_approx_opt = irit.GetPolyApproxOpt()
irit.SetPolyApproxOpt(1)
irit.SetPolyApproxTol(0.025)
pbody = (-irit.gpolygon(irit.sregion(body, irit.COL, 0.8, 3), 1))
pspout = (-irit.gpolygon(irit.sregion(spout, irit.COL, 0, 1), 1))
phandle = (-irit.gpolygon(handle, 1)) * irit.tx(0.15)
teapotaux = (pbody + pspout + phandle)
basey = 0.025
bodybase = irit.poly(
irit.list(((-2), basey, (-2)), ((-2), basey, 2), (2, basey, 2),
(2, basey, (-2))), irit.FALSE)
teapotaux2 = teapotaux * bodybase
basey2 = 2.3
bodybase2 = irit.poly(
irit.list(((-2), basey2, (-2)), ((-2), basey2, 2), (2, basey2, 2),
(2, basey2, (-2))), irit.FALSE)
teapotaux3 = teapotaux2 * (-bodybase2)
basey3 = 2.22
bodybase3 = irit.poly(
irit.list((2, basey3, (-2)), (2, basey3, 2), (4, basey3, 2),
(4, basey3, (-2))), irit.FALSE)
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_min, irit.VECTOR_TYPE)))
pt_max = irit.ceval(
crv3, irit.FetchRealObject(irit.crvptdst(crv3, (0, 0, 0), 0, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_max, irit.VECTOR_TYPE)))
irit.save(
"crv6dist",
irit.list(irit.GetAxes(), crv3, irit.coerce(pt_max, irit.VECTOR_TYPE)))
#
# Curve line distance.
#
line_pt = irit.point((-1), 1.2, 0)
line_vec = irit.vector(1, (-1), 0)
line_pt2 = line_pt + line_vec * 2
line = irit.poly(irit.list(line_pt, line_pt2), irit.TRUE)
crv1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1.5, (-0.5 ) ), \
irit.ctlpt( irit.E2, 0.5, (-1 ) ), \
irit.ctlpt( irit.E2, (-1.5 ), (-0.5 ) ), \
irit.ctlpt( irit.E2, 2.5, 0 ), \
irit.ctlpt( irit.E2, (-1.5 ), 0.5 ) ), irit.list( irit.KV_OPEN ) )
irit.color(crv1, irit.GREEN)
irit.attrib(crv1, "width", irit.GenRealObject(0.02))
pt_param = irit.crvlndst( crv1, \
irit.Fetch3TupleObject(line_pt), \
irit.Fetch3TupleObject(line_vec), \
0, \
(-0.001 ) )
pt_extrem = irit.nil()
i = 1
irit.free( vtail )
irit.free( engines )
irit.free( tank )
irit.interact( irit.list( irit.GetViewMatrix(), b58 ) )
irit.save( "b58", b58 )
irit.free( b58 )
#
# Make walls for shadows.
#
v1 = ( 0, 0, 0 )
v2 = ( 0, 1, 0 )
v3 = ( 1, 1, 0 )
v4 = ( 1, 0, 0 )
xy_plane = irit.poly( irit.list( v1, v2, v3, v4 ), irit.FALSE )
irit.color( xy_plane, irit.WHITE )
irit.attrib( xy_plane, "rgb", irit.GenStrObject("100,100,100" ))
v1 = ( 0, 0, 0 )
v2 = ( 0, 0, 1 )
v3 = ( 1, 0, 1 )
v4 = ( 1, 0, 0 )
xz_plane = irit.poly( irit.list( v1, v2, v3, v4 ), irit.FALSE )
irit.color( xz_plane, irit.WHITE )
irit.attrib( xz_plane, "rgb", irit.GenStrObject("100,100,100" ))
v1 = ( 0, 0, 0 )
v2 = ( 0, 0, 1 )
v3 = ( 0, 1, 1 )
v4 = ( 0, 1, 0 )
c3 = (createcubicbezier(379, 334, 469, 314, 469, 294) +
createcubicbezier(469, 294, 469, 274, 409, 264) +
createcubicbezier(409, 264, 349, 254, 349, 234) +
createcubicbezier(349, 234, 349, 214, 429, 194) +
createcubicbezier(429, 194, 509, 174, 409, 194) +
createcubicbezier(409, 194, 309, 214, 309, 234) +
createcubicbezier(309, 234, 309, 254, 369, 264) +
createcubicbezier(369, 264, 429, 274, 429, 294) +
createcubicbezier(429, 294, 429, 314, 359, 334) +
createcubicbezier(359, 334, 289, 354, 379, 334))
c3p = irit.cnvrtcrvtopolygon((-c3), 128, 0)
irit.free(c3)
t1 = irit.poly( irit.list( ( 354, 359, 0 ),
( 439, 359, 0 ),
( 379, 479, 0 ),
( 314, 349, 0 ) ), irit.TRUE ) * \
irit.sc( 0.001 )
t2 = irit.offset(t1, irit.GenRealObject(0.0065), 0, 0)
t3 = irit.offset(t1, irit.GenRealObject(-0.0065), 0, 0)
techlist = irit.nil()
i = 0
while (i <= irit.SizeOf(t2) - 1):
irit.snoc(irit.coord(t2, i), techlist)
i = i + 1
i = irit.SizeOf(t3) - 1
while (i >= 0):
irit.snoc(irit.coord(t3, i), techlist)
i = i + (-1)
tech = irit.poly(techlist, irit.FALSE)
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:
#
# ############################################################################
pl = irit.poly( irit.list( ( 1, 0, 0 ), ( 0, (-0.8 ), 0 ), irit.point( (-0.5 ), 0, 0 ) ), irit.FALSE )
ppl = plgntoplln( pl )
irit.interact( irit.list( irit.GetAxes(), ppl, gammakernelpolysrfs( pl, 25, 2 ) * irit.sz( (-1 ) ) ) )
angle = 18
while ( angle < 19.4 ):
irit.printf( "angle = %.2f\n", irit.list( angle ) )
irit.view( irit.list( ppl, gammakernelpolysrfs( pl, angle, 2 ) * irit.sz( (-1 ) ) ), irit.ON )
angle = angle + 0.1
irit.pause( )
# ############################################################################
pl = irit.poly( irit.list( ( 0.9, 0, 0 ), ( 0, (-0.9 ), 0 ), irit.point( (-0.8 ), 0, 0 ), irit.point( (-0.5 ), 0, 0 ), irit.point( 0, 1, 0 ), irit.point( 0.5, 0, 0 ) ), irit.FALSE )
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Manual construction of layout (prisa) of simple polyhedra.
#
save_mat = irit.GetViewMatrix()
square = irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 1, 0 ), ( 1, 1, 0 ), ( 1, 0, 0 ), ( 0, 0, 0 ) ), irit.TRUE )
irit.attrib( square, "width", irit.GenStrObject("0.02" ))
irit.color( square, irit.RED )
rectan = irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 1, 0 ), ( 2, 1, 0 ), ( 2, 0, 0 ), ( 0, 0, 0 ) ), irit.TRUE )
irit.attrib( rectan, "width", irit.GenStrObject("0.02" ))
irit.color( rectan, irit.RED )
triang = irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 1, 0 ), ( 1.5, 0.5, 0 ), ( 0, 0, 0 ) ), irit.TRUE )
irit.attrib( triang, "width", irit.GenStrObject("0.02" ))
irit.color( triang, irit.RED )
irit.SetViewMatrix( irit.scale( ( 0.2, 0.2, 0.2 ) ))
cube_prisa = irit.list( square,
square * irit.trans( ( 1, 0, 0 ) ),
square * irit.trans( ( 2, 0, 0 ) ),
square * irit.trans( ( (-1 ), 0, 0 ) ),
square * irit.trans( ( 0, 1, 0 ) ),
# # Some examples of 2-d bisector computations. # # Gershon Elber, August 1996. # save_res = irit.GetResolution() view_mat3d = irit.GetViewMatrix() view_mat2d = irit.sc( 0.6 ) irit.viewstate( "widthlines", 1 ) pl = irit.list( irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 1, 0 ), ( 1, 1, 0 ), ( 1, 0, 0 ) ), 0 ), irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 1, 0 ), ( 1, 1, 0 ), ( 1, 0, 0 ), ( 0, 0, 0 ) ), 1 ), irit.poly( irit.list( ( 0, 1.2, 0 ), ( 0, 0, 0 ), ( 1.2, 0, 0 ) ), 1 ), irit.poly( irit.list( ( 0, 0, 0 ), ( 0, 0, 0.5 ) ), 1 ) )
irit.snoc(irit.poly(irit.nth(listofctlpts, i), 1), retval)
i = i + 1
return retval
# ############################################################################
#
# A non complete intersection between polyhedra.
#
v1 = (0, 0, 0)
v2 = (1, 0, 0)
v3 = (1, 1, 0)
v4 = (0, 1, 0)
p = irit.poly(irit.list(v1, v2, v3, v4), irit.FALSE)
c = irit.cylin((0.1, 0.5, (-0.5)), (0, 0, 1), 0.3, 3)
#
# Boolean operation will fail here since the intersection is NOT CLOSED.
# One is only able to extract the itersection curves then.
#
# Cntrs = P + C;
#
intrcrv = irit.iritstate("intercrv", irit.GenRealObject(1))
cntrs = (p + c)
irit.attrib(cntrs, "dwidth", irit.GenRealObject(3))
irit.color(cntrs, irit.RED)
irit.interact(irit.list(c, p, cntrs))
