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
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Examples for trimming offsets with the TOFFSET command.
#
# Gershon ELber, Nov 2002
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.sc( 0.4 ) * irit.ty( (-0.8 ) ))
irit.viewobj( irit.GetViewMatrix() )
# Faster product using Bezier Decomposition
oldip = irit.iritstate( "bspprodmethod", irit.GenRealObject(0) )
irit.viewstate( "pllnaprx", 1 )
irit.viewstate( "pllnaprx", 1 )
# ############################################################################
c0 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, (-1 ), 3 ), \
irit.ctlpt( irit.E2, (-0.3 ), 0 ), \
irit.ctlpt( irit.E2, 0.3, 0 ), \
irit.ctlpt( irit.E2, 1, 3 ) ), irit.list( irit.KV_OPEN ) )
irit.view( c0, irit.ON )
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Examples of constructing uniform point distributions on freeforms.
#
# Gershon Elber, August 1996.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.rotx( 0 ))
irit.viewobj( irit.GetViewMatrix() )
#
# Some examples for curves.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-1 ), 0 ), \
irit.ctlpt( irit.E2, (-1 ), 0.1 ), \
irit.ctlpt( irit.E2, (-0.9 ), (-0.1 ) ), \
irit.ctlpt( irit.E2, 0.9, 0 ) ) )
irit.color( c1, irit.MAGENTA )
pts = irit.ffptdist( c1, 0, 1000 )
e2pts = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pts ) ):
#
import math
import irit
#
#
# This solid was taken from: Geometric Modeling,
# by Michael E. Mortenson page 441, figure 10.9
#
# 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)
#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
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# More examples of animated 3d bisector computations of 3-space crv and pt.
#
# Gershon Elber, August 1996.
#
speed = 5
filecount = 1000
irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.4))
irit.viewobj(irit.GetViewMatrix())
irit.viewstate("depthcue", 0)
def polesfree(srf, dpth, tmin, tmax):
retval = irit.nil()
return retval
def polesfree(srf, dpth, tmin, tmax):
if (irit.ffpoles(srf) == 0):
retval = irit.list(srf)
else:
if (dpth <= 0):
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 ) ),
square * irit.trans( ( 0, (-1 ), 0 ) ) )
irit.interact( irit.list( irit.GetViewMatrix(), cube_prisa ) )
irit.save( "cubepris", cube_prisa )
irit.free( cube_prisa )
box_prisa = irit.list( rectan, square * irit.trans( ( 2, 0, 0 ) ), square * irit.trans( ( (-1 ), 0, 0 ) ), rectan * irit.trans( ( 0, 1, 0 ) ), rectan * irit.trans( ( 0, 2, 0 ) ), rectan * irit.trans( ( 0, (-1 ), 0 ) ) )
irit.interact( irit.list( irit.GetViewMatrix(), box_prisa ) )
irit.save( "box_pris", box_prisa )
irit.free( box_prisa )
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
irit.SetViewMatrix(
irit.rotx((-90)) * irit.roty(135) * irit.rotx((-30)) * irit.scale(
(0.2, 0.2, 0.2)) * irit.trans((0, (-0.5), 0)))
tree1 = virttree2(irit.point(0, 0, 0), irit.vector(0, 0, 1), 0.3, 4, 7)
irit.interact(irit.list(irit.GetViewMatrix(), tree1))
irit.free(tree1)
tree2 = virttree3(irit.point(0, 0, 0), irit.vector(0, 0, 1), 0.5, 3, 5)
irit.interact(tree2)
irit.free(tree2)
def forest3(n, m, blevel, level):
retval = irit.nil()
i = 0
while (i <= n):
# import math import irit # # # Routines to test the boolean operations among geometric objects: # # Intersection between a box and a cylinder - make a hole in the box # b = irit.box( ( (-3 ), (-2 ), (-1 ) ), 6, 4, 2 ) c = irit.cylin( ( 0, 0, (-4 ) ), ( 0, 0, 8 ), 1, 3 ) save_view = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * irit.scale( ( 0.1, 0.1, 0.1 ) )) a1 = ( b + c ) irit.interact( irit.list( irit.GetViewMatrix(), a1 ) ) a2 = b * c irit.interact( a2 ) a3 = ( b - c ) irit.interact( a3 ) c = ( irit.con2( ( 0, 0, 0 ), ( 0, 0, 28 ), 17, 12, 3 ) - irit.con2( ( 0, 0, (-1 ) ), ( 0, 0, 30 ), 14, 9, 3 ) ) a4 = ( c - irit.box( ( (-50 ), (-50 ), (-1 ) ), 100, 100, 28 ) ) irit.save( "closloop", irit.list( a1, a2, a3, a4 ) )
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some examples of using reflection lines.
#
# Gershon Elber, October 1999
#
save_res = irit.GetResolution()
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.rx(2) * irit.ry(2) * irit.sc(0.5))
irit.viewobj(irit.GetViewMatrix())
irit.SetViewMatrix(save_mat)
# ############################################################################
s = irit.ruledsrf( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ) + \
irit.ctlpt( irit.E3, 1, (-1 ), 0 ), \
irit.ctlpt( irit.E3, (-1 ), 1, 0 ) + \
irit.ctlpt( irit.E3, 1, 1, 0 ) ) * irit.rx( 90 )
s = irit.sraise(irit.sraise(s, irit.ROW, 3), irit.COL, 3)
s = (-irit.seditpt(s, irit.ctlpt(irit.E3, 0, 1, 0), 1, 1))
irit.color(s, irit.MAGENTA)
reflectlns = irit.nil()
if (irit.ThisObject(txt) == irit.LIST_TYPE):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(txt)):
irit.snoc(textgeom3d(irit.nth(txt, i), wdth, dpth), retval)
i = i + 1
else:
retval = textgeom3daux(txt, wdth, dpth)
return retval
txtu = irit.textgeom("ABCDEFGHIJKLMNOPQRSTUVWXYZ", (0.02, 0, 0), 0.1)
txtl = irit.textgeom("a bcdefghijklmnopqrstuvwxyz", (0.02, 0, 0), 0.1)
txtn = irit.textgeom("0 1 2 34567890#$&*()+-=;:/?.,", (0.02, 0, 0), 0.1)
irit.SetViewMatrix(irit.sc(0.8) * irit.tx((-0.9)))
all = irit.list(txtu, txtl * irit.ty((-0.2)), txtn * irit.ty((-0.4)))
irit.interact(irit.list(irit.GetViewMatrix(), all))
irit.save("textgm1", irit.list(irit.GetViewMatrix(), all))
txtu3d = textgeom3d(txtu, 0.01, 0.1)
txtl3d = textgeom3d(txtl, 0.01, 0.1)
txtn3d = textgeom3d(txtn, 0.01, 0.1)
all = irit.convex(
irit.list(txtu3d, txtl3d * irit.ty((-0.2)), txtn3d * irit.ty((-0.4))))
irit.interact(irit.list(irit.GetViewMatrix(), all))
irit.save("textgm2", irit.list(irit.GetViewMatrix(), all))
irit.free(txtu)
irit.free(txtl)
irit.free(txtn)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# This is the DtoP custom designed Gearbox 'EndPlate'
# Designed by Andy Bray <*****@*****.**> 1992
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.GetViewMatrix() *
irit.scale( ( 0.13, 0.13, 0.13 ) ))
save_res = irit.GetResolution()
cplnr = irit.iritstate( "coplanar", irit.GenIntObject(1) )
# Try 'irit.iritstate("coplanar", false);'
box1 = irit.box( ( 0, 0, 1 ), 7.8, 10.4, 1.6 )
# If the line below is uncommented, then the file fails at the first operation
# most other resolutions work without problem. This could be because
# coincidentally something approximates colinear when it is not, but in that
# case a resultion of 50 or 20 might do it, and do not.
# resolution = 10;
hole1 = irit.cylin( ( 1, 1, 2.601 ), ( 0, 0, (-1.6015 ) ), 0.3, 3 )
solid1 = ( box1 - hole1 )
irit.free( hole1 )
irit.free( box1 )
irit.view( irit.list( irit.GetViewMatrix(), solid1 ), irit.ON )
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# A modern cup.
#
# Gershon Elber, November 1995
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.rotx( (-90 ) ) * irit.tx( (-0.5 ) ) * irit.ty( (-1 ) ) * irit.sc( 0.8 ))
irit.viewobj( irit.GetViewMatrix() )
ptlist = irit.nil( )
i = 0
while ( i <= 7 ):
irit.snoc( irit.point( math.cos( i * 2 * math.pi/8 ), math.sin( i * 2 * 3.14159/8 ), 0 ), ptlist )
i = i + 1
c1 = irit.coerce( irit.cbspline( 3, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.rz( (-22.5 ) )
c2 = irit.coerce( irit.cbspline( 2, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.sc( 1.1 )
irit.free( ptlist )
minsize = 0.01
body = irit.sfromcrvs( irit.list( c2 * irit.sc( minsize ) * irit.tz( 0.05 ), c2 * irit.sc( 0.7 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.8 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.9 ), c2, c2 * irit.tz( 2 ), c2 * irit.tz( 2.2 ), c1 * irit.tz( 2.2 ), c1 * irit.tz( 2 ), c1 * irit.tz( 0.4 ), c1 * irit.sc( 0.5 ) * irit.tz( 0.2 ), c1 * irit.sc( minsize ) * irit.tz( 0.2 ) ), 3, irit.KV_OPEN )
irit.free( c1 )
irit.free( c2 )
1, 2, 2, 2, 3, 3,\ 3, 4, 4, 4, 4 ) ) ) cap = irit.sreparam( irit.sregion( cap, irit.COL, 0.0005, 2 ), irit.COL, 0,\ 2 ) echosrc = irit.iritstate( "echosource", echosrc ) irit.free( echosrc ) irit.color( body, irit.RED ) irit.color( cap, irit.GREEN ) irit.color( spout, irit.BLUE ) irit.color( handle, irit.MAGENTA ) irit.SetViewMatrix( irit.scale( ( 0.3, 0.3, 0.3 ) )) teapot = irit.list( body, spout, handle, cap ) # interact( list( view_mat, Teapot ) ); irit.save( "teapot", teapot ) tea1 = teapot * irit.tx( 7 ) tea2 = teapot * irit.tx( 7 ) * irit.tz( 5 ) tea3 = teapot * irit.tz( 5 ) irit.SetViewMatrix( irit.scale( ( 0.15, 0.15, 0.15 ) ) * irit.rx( 50 ) * irit.ry( 40 ) * irit.tx( (-0.7 ) ) * irit.ty( 0.2 )) irit.interact( irit.list( irit.GetViewMatrix(), teapot, tea1, tea2, tea3 ) ) irit.free( tea1 ) irit.free( tea2 ) irit.free( tea3 )
#
#
# Yet another simple 3D mechanical object. This one whas taken from
# PC MAGAZINE volume 8 number 2, January 31, 1989, page 34. This was example
# that was implemented under AutoCAD ver 10, and it looked nice so I tried
# it... It took me about an hour to complete.
#
# Created by Gershon Elber, Mar 89
#
save_mat = irit.GetViewMatrix()
save_res = irit.GetResolution()
irit.SetResolution(16)
irit.SetViewMatrix(irit.GetViewMatrix() * irit.trans((0.4, (-0.1), 0)))
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
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 )
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.sc( 0.8 ))
irit.viewobj( irit.GetViewMatrix() )
# ############################################################################
i = 0
while ( i <= 20 ):
pt1 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
pt2 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
pt3 = irit.point( irit.random( (-0.5 ), 0.5 ), irit.random( (-0.5 ), 0.5 ), 0 )
skel2dcolor( pt1, pt2, pt3, 0.01, irit.list( 0.01, (-1e-010 ) ), 1, "" )
irit.milisleep( delay )
i = i + 1
skel2dcolor( pt1, pt2, pt3, 0.01, irit.list( 0.01, (-1e-010 ) ), 1, "skel2d1" )
irit.pause( )
irit.SetResolution(30)
#
# Computing self intersection by a Boolean operation with itself - Parametric.
#
dummy = irit.iritstate("intercrv", irit.GenRealObject(1))
uvbool = irit.iritstate("uvboolean", irit.GenRealObject(1))
s1inter = (s1 + s1)
irit.color(s1inter, irit.RED)
irit.attrib(s1inter, "dwidth", irit.GenRealObject(3))
paramdomain = irit.poly(irit.list((0, 0, 0), (0, 1, 0), (2, 1, 0), (2, 0, 0)),
irit.FALSE)
irit.color(paramdomain, irit.GREEN)
irit.SetViewMatrix(irit.tx((-1)) * irit.sc(0.6))
irit.interact(irit.list(irit.GetViewMatrix(), paramdomain, s1inter))
#
# Computing self intersection by a Boolean operation with itself - Euclidean.
#
dummy = irit.iritstate("intercrv", irit.GenRealObject(1))
dummy = irit.iritstate("uvboolean", irit.GenRealObject(0))
s1inter = (s1 + s1)
irit.color(s1inter, irit.RED)
irit.attrib(s1inter, "dwidth", irit.GenRealObject(5))
irit.SetViewMatrix(save_mat * irit.sc(0.7) * irit.ty((-0.3)))
irit.interact(irit.list(irit.GetViewMatrix(), s1, s1inter))
irit.save("selfint1", irit.list(s1, s1inter))
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # Extrusion example of the IRIT letters created manually: # # Created by Gershon Elber, Mar 89 # save_mat = irit.GetViewMatrix() save_res = irit.GetResolution() irit.SetViewMatrix(irit.GetViewMatrix() * irit.scale(((-1), 1, 1))) v1 = (0, 0, 0) # The I letter v2 = (0.3, 0, 0) v3 = (0.3, 0.1, 0) v4 = (0.2, 0.1, 0) v5 = (0.2, 0.5, 0) v6 = (0.3, 0.5, 0) v7 = (0.3, 0.6, 0) v8 = (0, 0.6, 0) v9 = (0, 0.5, 0) v10 = (0.1, 0.5, 0) v11 = (0.1, 0.1, 0) v12 = (0, 0.1, 0)
irit.ctlpt( irit.E3, 0.4, 2.4, 0 ), \
irit.ctlpt( irit.E3, 1.3, 2.4, 0 ), \
irit.ctlpt( irit.E3, 1.3, 2.25, 0 ) ) ), irit.list( irit.list( 0, 0, 0, 0, 1, 1,\
1, 2, 2, 2, 2 ), irit.list( 0, 0, 0, 0, 1, 1,\
1, 2, 2, 2, 3, 3,\
3, 4, 4, 4, 4 ) ) )
echosrc = irit.iritstate("echosource", echosrc)
irit.free(echosrc)
irit.color(body, irit.RED)
irit.color(cap, irit.GREEN)
irit.color(spout, irit.BLUE)
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)
irit.free(mov_xyz)
mov_xyz = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, 0, 0, 3 ), \
irit.ctlpt( irit.E3, 1, (-1 ), 3 ), \
irit.ctlpt( irit.E3, 0.5, (-0.5 ), 0.5 ), \
irit.ctlpt( irit.E3, 0, 0, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
irit.attrib(grp2, "animation", irit.list(rot_y, rot_z, rot_x, mov_xyz, scl))
irit.free(mov_xyz)
irit.free(rot_x)
irit.free(rot_y)
irit.free(rot_z)
all = irit.list(grp1, grp2)
irit.SetViewMatrix(irit.sc(0.2) * irit.rotx(40) * irit.roty(30))
irit.interact(irit.list(all, irit.GetViewMatrix()))
irit.save("puz1anim", all)
irit.free(itemaux1)
irit.free(itemaux2)
irit.free(diagpoly)
# ############################################################################
scl = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 5 ), \
irit.ctlpt( irit.E1, 5 ), \
irit.ctlpt( irit.E1, 2 ), \
irit.ctlpt( irit.E1, 2 ), \
irit.ctlpt( irit.E1, 5 ), \
import irit # # # Simple molecule - 8 atoms connected as a cube. # t = irit.time( 1 ) save_res = irit.GetResolution() save_view = irit.GetViewMatrix() irit.SetViewMatrix( irit.GetViewMatrix() * \ irit.scale( ( 0.6, 0.6, 0.6 ) ) * \ irit.rotx( 20 ) * \ irit.roty( 45 ) * \ irit.trans( ( (-0.3 ), 0.2, 0 ) )) irit.SetResolution( 16) s1 = irit.sphere( ( 0, 0, 0 ), 0.2 ) s2 = irit.sphere( ( 1, 0, 0 ), 0.2 ) irit.SetResolution( 8) c1 = irit.cylin( ( 0, 0, 0 ), ( 1, 0, 0 ), 0.05, 3 ) irit.view( irit.list( irit.GetViewMatrix(), s1, s2, c1 ), irit.ON ) b1 = ( (s1 ^ s2) + c1 ) irit.free( s1 ) irit.free( s2 )
import math import irit # # # A simple example of curve morphing. # # Gershon Elber, March 1996. # # # Sets the viewing direction on the display device. # save_mat = irit.GetViewMatrix() irit.SetViewMatrix( irit.roty( 180 )) irit.viewobj( irit.GetViewMatrix() ) irit.SetViewMatrix( save_mat) irit.viewstate( "polyaprx", 1 ) irit.viewstate( "widthlines", 1 ) # # Animation speed. The lower this number, the faster the animations will be, # skipping more frames. # speed = 0.25 echosrc = irit.iritstate( "echosource", irit.GenIntObject(0 )) # ###########################################################################
#
import math
import irit
#
#
# Yet another simple 3D mechanical object.
#
# Created by Gershon Elber, Sep 89
#
save_mat = irit.GetViewMatrix()
save_res = irit.GetResolution()
irit.SetResolution(16)
irit.SetViewMatrix(irit.GetViewMatrix() * irit.trans(
(0, (-0.3), 0)) * irit.scale((0.8, 0.8, 0.8)))
b1 = irit.box(((-0.6), (-0.3), 0), 1.2, 0.6, 0.6)
c1 = irit.cylin((0, (-0.25), 0.59), (0, 0.5, 0), 0.55, 3)
s1 = (b1 + c1)
irit.color(s1, irit.YELLOW)
irit.free(b1)
irit.free(c1)
irit.view(irit.list(irit.GetViewMatrix(), s1), irit.ON)
b2 = irit.box(((-0.4), (-0.4), (-0.1)), 0.8, 0.8, 0.35)
irit.view(b2, irit.OFF)
s2 = (s1 - b2)
irit.free(s1)
irit.free(b2)
irit.color(s2, irit.YELLOW)
irit.view(s2, irit.ON)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some examples of 3d bisector computations between surfaces and points.
#
# Gershon Elber, February 1997.
#
save_res = irit.GetResolution()
irit.SetResolution(60)
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.rotz(35) * irit.rotx((-60)) * irit.sc(0.3))
irit.viewobj(irit.GetViewMatrix())
irit.viewstate("depthcue", 1)
irit.viewstate("widthlines", 1)
# ############################################################################
#
# A bilinear surface: sphere--plane bisector
#
s1 = irit.ruledsrf( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ) + \
irit.ctlpt( irit.E3, 1, (-1 ), 0 ), \
irit.ctlpt( irit.E3, (-1 ), 1, 0 ) + \
irit.ctlpt( irit.E3, 1, 1, 0 ) )
irit.color(s1, irit.RED)
pt = irit.point(0, 0, 1)
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))
#
import math
import irit
#
#
# Some examples of voronoi cell of freeform curves.
#
# M. Ramanathan, January 2005.
#
#
# Set states.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.sc(1))
irit.viewobj(irit.GetViewMatrix())
# Faster product using Bezier decomposition
iprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0))
# ############################################################################
#
# Example 0 - Two simple open curves
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.441758 ), (-0.503296 ) ), \
irit.ctlpt( irit.E2, 0.560439, (-0.516483 ) ) ) ) * irit.ty( 0.3 )
c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 0.608924, (-0.358027 ) ), \
irit.ctlpt( irit.E2, 0.164947, (-0.371462 ) ), \
#
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)
#
# A model of the B58 Bomber.
#
#
# Gershon Elber, October 1991.
#
if ( irit.GetMachine() == irit.MSDOS ):
irit.SetResolution(8)
else:
irit.SetResolution(10)
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.trans( ( 5, 2, 0 ) ) * irit.scale( ( 0.15, 0.15, 0.15 ) ) )
#
# Set up for colored or wood texture version. set do_texture to 1 for
# wood version, otherwise color version. Note locally (in irit) it will
# always be displayed in colors.
#
do_texture = 0
if ( do_texture == 1 ):
woodcolor = "244,164,96"
texture = "wood,1"
redcolor = woodcolor
graycolor = woodcolor
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Intersection of two boxes:
#
# Created by Gershon Elber, Jan. 89
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(save_mat * irit.scale((0.15, 0.15, 0.15)))
b1 = irit.box(((-3), (-2), (-1)), 6, 4, 2)
b2 = irit.box(((-4), (-3), (-2)), 2, 2, 4)
a1 = (b2 + b1)
irit.interact(irit.list(irit.GetViewMatrix(), a1))
a2 = b2 * b1
irit.interact(a2)
a3 = (b2 - b1)
irit.interact(a3)
a4 = (b1 - b2)
irit.interact(a4)
icrv = irit.iritstate("intercrv", irit.GenIntObject(1))
a5 = b2 * b1
irit.free(m1)
irit.free(c1)
irit.view(m2, irit.ON)
c2 = irit.circle((0.55, 0, 0), 0.12)
c2 = irit.extrude(c2, ((-0.2), 0, 0.2), 0)
c2 = c2 * irit.circpoly((0, 0, 1), (0.55, 0, 0.05), 0.25)
c3 = irit.circle(((-0.55), 0, 0), 0.12)
c3 = irit.extrude(c3, (0.2, 0, 0.2), 0)
c3 = c3 * irit.circpoly((0, 0, 1), ((-0.55), 0, 0.05), 0.25)
c2 = putrgbonvertices(c2, irit.GenStrObject("255,0,255"))
c3 = putrgbonvertices(c3, irit.GenStrObject("255,128,128"))
irit.view(irit.list(c2, c3), irit.OFF)
m3 = (m2 - c2 - c3)
irit.free(m2)
irit.free(c2)
irit.free(c3)
final = irit.convex(m3)
irit.free(m3)
irit.printf("total time = %f\n", irit.list(irit.time(0)))
# In Seconds
irit.interact(final)
irit.save("solid3", final)
irit.free(final)
irit.SetResolution(save_res)
irit.SetViewMatrix(save_mat)
