def testrun( numcrvs, crvdeg, crvlen, crvsize, seed, subeps,\
numeps, opti ):
ri = irit.iritstate("randominit", irit.GenIntObject(seed))
c = randomcrvs(numcrvs, crvdeg, crvlen, crvsize)
irit.attrprop(c, "color", irit.GenIntObject(14))
irit.view(c, irit.ON)
msc = irit.mscirc(c, irit.list(subeps, numeps))
irit.view(msc, irit.OFF)
irit.pause()
retval = irit.list(msc, c)
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 cntrpolys( pls, zmin, dz, zmax ):
retval = irit.nil( )
intrcrv = irit.iritstate( "intercrv", irit.GenIntObject(1 ))
z = zmin
while ( z <= zmax ):
p = irit.circpoly( ( 0, 0, 1 ), ( 0, 0, z ), 6 )
irit.snoc( pls * p, retval )
z = z + dz
intrcrv = irit.iritstate( "intercrv", intrcrv )
irit.color( retval, irit.YELLOW )
return retval
def mergeverticalbndrycrvs( crvs ):
crvs = crvs * irit.tx( 0 )
retval = irit.nil( )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
c1 = irit.nth( crvs, i )
used = irit.getattr( c1, "used" )
if ( irit.ThisObject( used ) != irit.NUMERIC_TYPE ):
j = i + 1
while ( j <= irit.SizeOf( crvs ) ):
c2 = irit.nth( crvs, j )
used = irit.getattr( c2, "used" )
if ( irit.ThisObject( used ) != irit.NUMERIC_TYPE ):
c1a = mergeverticaltwocrvs( c1, c2 )
if ( c1a != c1 ):
irit.attrib( irit.nref( crvs, j ), "used", irit.GenIntObject(1 ))
c1 = c1a
j = j + 1
irit.snoc( c1 * irit.tx( 0 ), retval )
i = i + 1
return retval
def displayobjobjhdres( o1, o2, eps, onesided ):
global glbltransx
hdres = irit.hausdorff( o1, o2, eps, onesided )
dist = irit.nth( hdres, 1 )
param1 = irit.nth( hdres, 2 )
if ( onesided ):
dtype = "one sided "
else:
dtype = "two sided "
if ( irit.SizeOf( param1 ) == 0 ):
pt1 = irit.coerce( o1, irit.E3 )
else:
i = 1
while ( i <= irit.SizeOf( param1 ) ):
t = irit.nth( param1, i )
irit.printf( "%shausdorff distance %f detected at t1 = %f\n", irit.list( dtype, dist, t ) )
i = i + 1
pt1 = irit.ceval( o1, irit.FetchRealObject(t) )
param2 = irit.nth( hdres, 3 )
if ( irit.SizeOf( param2 ) == 0 ):
pt2 = irit.coerce( o2, irit.E3 )
else:
i = 1
while ( i <= irit.SizeOf( param2 ) ):
t = irit.FetchRealObject(irit.nth( param2, i ))
irit.printf( "%shausdorff distance %f detected at t2 = %f\n", irit.list( dtype, dist, t ) )
i = i + 1
pt2 = irit.ceval( o2, t )
irit.color( pt1, irit.MAGENTA )
irit.color( o1, irit.MAGENTA )
irit.color( pt2, irit.YELLOW )
irit.color( o2, irit.YELLOW )
l = ( pt1 + pt2 )
if ( onesided == 0 ):
irit.attrib( l, "dwidth", irit.GenIntObject(3 ))
all = irit.list( o1, o2, pt1, pt2, l )
irit.snoc( all * irit.tx( glbltransx ), glblres )
glbltransx = ( glbltransx + 0.5 )
irit.interact( all )
irit.attrib( vtail1, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtail1, irit.RED )
if ( do_texture == 1 ):
irit.attrib( vtail2, "texture", texture )
irit.attrib( vtail2, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtail2, irit.RED )
irit.free( c1 )
irit.free( c2 )
irit.free( c3 )
vtailtop = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.1 ), irit.cbezier( irit.list( irit.ctlpt( irit.E3, 10.732, 0, 2.048 ), \
irit.ctlpt( irit.E3, 10.972, 0, 2.048 ), \
irit.ctlpt( irit.E3, 11.212, 0, 2.048 ) ) ), irit.cbezier( irit.list( \
irit.ctlpt( irit.E2, 0, 0.01 ), \
irit.ctlpt( irit.E2, 0.5, 1 ), \
irit.ctlpt( irit.E2, 1, 0.01 ) ) ), irit.GenIntObject(0), 1 )
if ( do_texture == 1 ):
irit.attrib( vtailtop, "texture", texture )
irit.attrib( vtailtop, "rgb", irit.GenStrObject(redcolor) )
irit.color( vtailtop, irit.RED )
vtailpara = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 0.075 ), irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 9.15, 0, 0.6 ), \
irit.ctlpt( irit.E3, 9.5, 0, 0.6 ), \
irit.ctlpt( irit.E3, 9.9, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.7, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.8, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.85, 0, 0.6 ), \
irit.ctlpt( irit.E3, 10.9, 0, 0.6 ) ), irit.list( irit.KV_OPEN ) ), irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E2, 0, 0.01 ), \
irit.ctlpt( irit.E2, 0.01, 1 ), \
irit.ctlpt( irit.E2, 0.5, 1 ), \
#
import math
import irit
#
#
# Some routines to test bezier curves/surfaces.
#
#
# Set display to on to view some results, off to view nothing.
#
display = 1
save_res = irit.GetResolution()
dlevel = irit.iritstate("dumplevel", irit.GenIntObject(255))
if (irit.GetMachine() == irit.MSDOS):
irit.SetResolution(5)
else:
irit.SetResolution(10)
s45 = math.sin(math.pi / 4)
cbzr = irit.list( irit.ctlpt( irit.P2, 1, 1, 0 ), \
irit.ctlpt( irit.P2, s45, s45, s45 ), \
irit.ctlpt( irit.P2, 1, 0, 1 ) )
sbzr = irit.list( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 1 ), \
irit.ctlpt( irit.E3, 0.3, 1, 0 ), \
irit.ctlpt( irit.E3, 0, 2, 1 ) ), irit.list( \
irit.ctlpt( irit.E3, 1.1, 0, 0 ), \
import irit
#
#
# A small demo of the knot removal capabilities in IRIT
#
# Gershon Elber, July 1999
#
pl1 = irit.nil()
x = 0
while (x <= 200):
irit.snoc(irit.point(x / 100.0 - 1, math.sin(x * math.pi / 100), 0), pl1)
x = x + 1
c1 = irit.cinterp(pl1, 3, 50, irit.GenIntObject(irit.PARAM_UNIFORM), 0)
c1r1 = irit.knotremove(c1, 0.001)
irit.color(c1r1, irit.MAGENTA)
irit.adwidth(c1r1, 3)
irit.printf("size of c1 is %d and c1r1 is %d\n",
irit.list(irit.SizeOf(c1), irit.SizeOf(c1r1)))
irit.interact(irit.list(c1r1, c1))
c1r2 = irit.knotremove(c1, 0.01)
irit.color(c1r2, irit.MAGENTA)
irit.adwidth(c1r2, 3)
irit.printf("size of c1 is %d and c1r2 is %d\n",
irit.list(irit.SizeOf(c1), irit.SizeOf(c1r2)))
irit.interact(irit.list(c1r2, c1))
irit.ctlpt( irit.E3, (-1.1 ), 0.2, 0 ), \
irit.ctlpt( irit.E3, (-1.1 ), 0.6, 0 ), \
irit.ctlpt( irit.E3, (-0.7 ), 1.1, 0 ), \
irit.ctlpt( irit.E3, (-0.5 ), 1.3, 0 ), \
irit.ctlpt( irit.E3, 0.5, 1.3, 0 ), \
irit.ctlpt( irit.E3, 0.7, 1.1, 0 ), \
irit.ctlpt( irit.E3, 1.1, 0.6, 0 ), \
irit.ctlpt( irit.E3, 1.1, 0.2, 0 ), \
irit.ctlpt( irit.E3, 1, 0, 0 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.rz( (-90 ) ) * irit.sc( 0.3 )
direc = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1.2 ), 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0.24, 0 ), \
irit.ctlpt( irit.E3, 1.2, 0, 0 ) ), irit.list( irit.KV_OPEN ) )
irit.SetResolution(res)
srf1 = irit.gpolygon((-irit.sweepsrf(irit.coerce(cross, irit.KV_OPEN), direc,
irit.GenIntObject(0))), 1)
irit.free(cross)
irit.free(direc)
irit.SetResolution(res * 5)
cyl1 = irit.cylin((0, 0, (-1)), (0, 0, 2), 1.15, 3)
srf2 = srf1 * cyl1
irit.free(cyl1)
irit.SetResolution(res * 5)
cyl2 = irit.cylin((0, 0.2, (-1)), (0, 0, 2), 0.6, 3)
srf3 = srf1 * cyl2 * irit.sz(4) * irit.sx(0.9) * irit.ty((-0.15))
irit.free(srf1)
irit.free(cyl2)
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.interact(irit.list(a5, b1, b2))
icrv = irit.iritstate("intercrv", icrv)
irit.free(icrv)
irit.save(
"box-box",
irit.list(a1, a2 * irit.tx(10), a3 * irit.tx(20), a4 * irit.tx(30),
a5 * irit.tx(40)))
irit.SetViewMatrix(save_mat)
irit.free(a1)
irit.free(a2)
irit.free(a3)
#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
#
#
# Hausdorff distances between freeforms
#
# Gershon Elber, October 2006.
#
# ############################################################################
ri = irit.iritstate( "randominit", irit.GenIntObject(1960 ))
# Seed-initiate the randomizer,
irit.free( ri )
glblres = irit.nil( )
glbltransx = -5
def displayobjobjhdres( o1, o2, eps, onesided ):
global glbltransx
hdres = irit.hausdorff( o1, o2, eps, onesided )
dist = irit.nth( hdres, 1 )
param1 = irit.nth( hdres, 2 )
if ( onesided ):
dtype = "one sided "
else:
dtype = "two sided "
if ( irit.SizeOf( param1 ) == 0 ):
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 )
# resolution = 20;
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some simple tests for blossom evaluations over Beziers and Bsplines.
#
# Gershon Elber, February 1999
#
echosrc = irit.iritstate("echosource", irit.GenIntObject(0))
dumplvl = irit.iritstate("dumplevel", irit.GenIntObject(256 + 1))
oldeps = irit.iritstate("cmpobjeps", irit.GenRealObject(1e-010))
def printtest(title, ctlstring, reslist):
irit.printf(ctlstring, irit.list(title) + reslist)
# ############################################################################
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, 1.7, 0 ), \
irit.ctlpt( irit.E2, 0.7, 0.7 ), \
irit.ctlpt( irit.E2, 1.7, 0.3 ), \
irit.ctlpt( irit.E2, 1.5, 0.8 ), \
irit.ctlpt( irit.E2, 1.6, 1 ) ) )
printtest(
"bezier test - ", "\n%40s %d %d %d %d %d, %d %d %d %d, %d %d %d\n",
irit.color(maxd, irit.GREEN)
irit.adwidth(maxd, 3)
mind = irit.crvdiamtr(c3, 0.01, (-1e-010), 0)
mind = (irit.ceval(c3, irit.FetchRealObject(irit.coord(mind, 0))) +
irit.ceval(c3, irit.FetchRealObject(irit.coord(mind, 1))))
irit.color(mind, irit.YELLOW)
irit.adwidth(mind, 3)
irit.interact(irit.list(c3, lns, maxd, mind, view_mat1))
k = irit.crvkernel(c3, 0, 0, irit.list(2, 2, 2), 0)
irit.attrib(k, "rgb", irit.GenStrObject("1,1,1"))
irit.interact(irit.list(c3, bg, k * irit.sz(0), view_mat1))
k = irit.crvkernel(c4, 0, 0, irit.GenIntObject(2), 0)
irit.attrib(k, "rgb", irit.GenStrObject("1,1,1"))
irit.interact(irit.list(c4, bg, k * irit.sz(0), view_mat1))
k1 = irit.crvkernel(c4, 5, 0, irit.GenIntObject(2), 0)
irit.attrib(k1, "rgb", irit.GenStrObject("100,1,1"))
k2 = irit.crvkernel(c4, (-5), 0, irit.GenIntObject(2), 0)
irit.attrib(k2, "rgb", irit.GenStrObject("1,100,1"))
irit.interact(irit.list(c4, bg, k1 * irit.sz(0), k2 * irit.sz(0), view_mat1))
irit.attrib(k, "rgb", irit.GenStrObject("0,255,255"))
irit.interact(irit.list(c4, k * irit.sz((-3)), view_mat2))
s = irit.crvkernel(c4, 0, 0, irit.list(0.15, (-0.001)), 1)
irit.attrib(s, "rgb", irit.GenStrObject("255,0,255"))
irit.interact(irit.list(c4, k * irit.sz((-3)), s, view_mat2))
# Some examples of envelope offset
#
# Gershon Elber, August 1996
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.rx( 180 ))
irit.viewobj( irit.GetViewMatrix() )
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.8 ), 0 ), \
irit.ctlpt( irit.E2, (-0.2 ), 1 ), \
irit.ctlpt( irit.E2, 0.2, 0 ), \
irit.ctlpt( irit.E2, 0.8, 0.6 ) ) )
irit.color( c1, irit.YELLOW )
irit.attrib( c1, "dwidth", irit.GenIntObject(4 ))
s1 = irit.cenvoff( c1, 0.5, 0.01 )
irit.color( s1, irit.CYAN )
irit.interact( irit.list( c1, s1 ) )
irit.free( c1 )
irit.free( s1 )
c2 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1, 0 ), \
irit.ctlpt( irit.E2, 1, 1 ), \
irit.ctlpt( irit.E2, 0.3, 1 ), \
irit.ctlpt( irit.E2, 0, (-0.5 ) ), \
irit.ctlpt( irit.E2, (-0.3 ), 1 ), \
irit.ctlpt( irit.E2, (-1 ), 1 ), \
irit.ctlpt( irit.E3, 3.1, 0, 0 ), \
irit.ctlpt( irit.E3, 3.3, 1, 0 ), \
irit.ctlpt( irit.E3, 3, 2, 0 ) ) ) )
tcrv1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.5, 0.25 ), \
irit.ctlpt( irit.E2, 0.8, 0.25 ), \
irit.ctlpt( irit.E2, 0.8, 0.75 ), \
irit.ctlpt( irit.E2, 0.6, 0.75 ), \
irit.ctlpt( irit.E2, 0.6, 0.9 ), \
irit.ctlpt( irit.E2, 0.4, 0.9 ), \
irit.ctlpt( irit.E2, 0.4, 0.75 ), \
irit.ctlpt( irit.E2, 0.2, 0.75 ), \
irit.ctlpt( irit.E2, 0.2, 0.25 ), \
irit.ctlpt( irit.E2, 0.5, 0.25 ) ), irit.list( irit.KV_OPEN ) )
tsrf1 = irit.trimsrf(srf1, tcrv1, 0)
irit.attrib(tsrf1, "resolution", irit.GenIntObject(2))
crv1 = irit.compose(srf1, tcrv1)
irit.free(srf1)
irit.free(tcrv1)
irit.color(crv1, irit.GREEN)
pc = irit.crefine(irit.pcircle(((-1.7), (-1), 1), 0.4), 0, irit.list(1, 2, 3))
srf2 = irit.ruledsrf( irit.ceditpt( irit.ceditpt( pc, irit.ctlpt( irit.E3, (-2.1 ), (-1 ), 1.2 ), 9 ), \
irit.ctlpt( irit.E3, (-1.3 ), (-1 ), 1.2 ), 3 ), pc * irit.tz( 1 ) ) * irit.rotz( (-90 ) ) * irit.trans( ( 2.7, (-0.7 ), 0 ) )
crv2 = irit.csurface(srf2, irit.ROW, 0)
irit.color(crv2, irit.GREEN)
irit.free(pc)
tan1 = irit.symbdiff(
crv1 * irit.scale((0.6, 0.4, 1)) * irit.trans((0.7, 0.6, 0)), crv1)
irit.color(s2, irit.GREEN)
s3 = irit.blhermite(c1, c2, d1, d2, csec2, n)
irit.color(s3, irit.YELLOW)
irit.save("blending1", irit.list(s1, s2, s3))
irit.interact(irit.list(irit.GetAxes(), s1, s2, s3))
#
# Blend on a (polynomial approximation of a) sphere:
#
s = (-irit.surfprev(
irit.cregion(irit.pcircle((0, 0, 0), 1), 0, 2) * irit.rx(90)))
irit.attrprop(s, "u_resolution", irit.GenIntObject(3))
irit.attrprop(s, "v_resolution", irit.GenIntObject(3))
ds = irit.sderive(s, irit.ROW)
c1 = (-irit.csurface(s, irit.ROW, 0.8))
c2 = (-irit.csurface(s, irit.ROW, 1.2))
d1 = (-irit.csurface(ds, irit.ROW, 0.8))
d2 = (-irit.csurface(ds, irit.ROW, 1.2))
s1 = irit.hermite(c1, c2, d1, d2)
irit.color(s1, irit.RED)
n = irit.csurface(s, irit.ROW, 1)
s2 = irit.blhermite(c1, c2, d1, d2, csec1, n)
#
# Some examples of proper piecewise linear sampling in gpolyline.
#
save_res = irit.GetResolution()
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.rotx(0))
irit.viewobj(irit.GetViewMatrix())
irit.SetViewMatrix(save_mat)
irit.viewstate("dblbuffer", 1)
irit.viewstate("depthcue", 1)
dlevel = irit.iritstate("dumplevel", irit.GenIntObject(255))
# Faster product using Bezier decomposition.
iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0))
# ############################################################################
pl2 = irit.nil()
x = 0
while (x <= 5):
irit.snoc(
irit.point(math.cos(x * math.pi / 10), math.sin(x * 3.14159 / 10), 0),
pl2)
x = x + 1
crv1 = irit.cinterp(pl2, 4, 4, irit.GenRealObject(irit.PARAM_UNIFORM), 0)
import math
import irit
#
#
# Minimum Spanning Circle/Cone/Sphere and Convex Hull for polys.
#
# Gershon Elber, February 1996
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.sc(0.5))
irit.viewobj(irit.GetViewMatrix())
irit.SetViewMatrix(save_mat)
ri = irit.iritstate("randominit", irit.GenIntObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
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)
#
# 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)
irit.adwidth(pt2, 3)
t = 0
while (t <= 1):
y2 = y1 + (maxy - miny) * 0.8 / n
if (x > x1 & x < x2 & y > y1 & y < y2):
retval = i + 1
i = i + 1
return retval
#
# Ask all clients to send mouse/cursor events to the server.
#
irit.clntpickcrsr(irit.CLIENTS_ALL)
#
# Ask the server to keep mouse/cursor events to be read view ClntCrsr.
#
crsrkeep = irit.iritstate("cursorkeep", irit.GenIntObject(1))
#
# Some examples of menus... Uses Button 1 (left button).
#
quit = 0
xyplane = irit.plane(0, 0, 1, 0)
crv = irit.circle((0, 0, 0), 1) * irit.sx(0.5) * irit.rx(40) * irit.rz(44)
irit.color(crv, irit.RED)
srf = irit.swpcircsrf(irit.circle((0, 0, 0), 0.7), 0.2, 0)
irit.color(srf, irit.GREEN)
menu = menugengeometry( irit.list( "quit", "draw crv", "draw srf", "draw all", "ctl mesh" ), 0.7,\
0.5, 0.5, 0.95, 0.95 )
irit.color(menu, irit.WHITE)
irit.view(irit.list(menu, crv, srf), irit.ON)
# Handle only button 1 down events:
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Display the Gamma-Kernel surfaces. gershon Elber, September 2003.
#
ri = irit.iritstate( "randominit", irit.GenIntObject(1964 ))
# Seed-initiate the randomizer,
irit.free( ri )
def cntrpolys( pls, zmin, dz, zmax ):
retval = irit.nil( )
intrcrv = irit.iritstate( "intercrv", irit.GenIntObject(1 ))
z = zmin
while ( z <= zmax ):
p = irit.circpoly( ( 0, 0, 1 ), ( 0, 0, z ), 6 )
irit.snoc( pls * p, retval )
z = z + dz
intrcrv = irit.iritstate( "intercrv", intrcrv )
irit.color( retval, irit.YELLOW )
return retval
def setrandomcolor( obj ):
irit.attrib( obj, "rgb", irit.GenStrObject(str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) )) + "," + str(int( irit.random( 100, 255 ) ) )))
retval = obj
return retval
import math
import irit
#
#
# Simple knots.
#
# Gershon Elber, 1997
#
cross = irit.pcircle((0, 0, 0), 0.1)
crv1 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1 ), 0.9, 0 ), \
irit.ctlpt( irit.E3, 1, 0.9, 0 ), \
irit.ctlpt( irit.E3, 1, (-0.9 ), 0 ), \
irit.ctlpt( irit.E3, (-1 ), (-0.9 ), 0 ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN )
srf1 = irit.swpsclsrf(cross, crv1, irit.GenIntObject(1), irit.vector(0, 0, 1),
2)
irit.attrib(srf1, "color", irit.GenIntObject(4))
crv2 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-1.3 ), 0, 0.75 ), \
irit.ctlpt( irit.E3, 1.3, 0, 0.75 ), \
irit.ctlpt( irit.E3, 1.3, 0, (-0.75 ) ), \
irit.ctlpt( irit.E3, (-1.3 ), 0, (-0.75 ) ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN )
srf2 = irit.swpsclsrf(cross, crv2, irit.GenIntObject(1), irit.vector(0, 1, 0),
2)
irit.attrib(srf2, "color", irit.GenIntObject(2))
crv3 = irit.coerce( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0.5, 1.1 ), \
irit.ctlpt( irit.E3, 0, 0.5, (-1.1 ) ), \
irit.ctlpt( irit.E3, 0, (-0.5 ), (-1.1 ) ), \
irit.ctlpt( irit.E3, 0, (-0.5 ), 1.1 ) ), irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN )
#
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 ))
# ###########################################################################
locally = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.62705, (-0.418086 ) ), \
irit.ctlpt( irit.E2, 0.593439, (-0.416962 ) ), \
irit.ctlpt( irit.E2, 0.414706, (-0.366445 ) ), \
irit.ctlpt( irit.E2, 0.362948, (-0.332803 ) ), \
irit.ctlpt( irit.E2, 0.33727, (-0.293801 ) ), \
irit.ctlpt( irit.E2, 0.288731, (-0.146024 ) ), \
irit.ctlpt( irit.E2, 0.292251, (-0.0630604 ) ), \
irit.ctlpt( irit.E2, 0.326431, (-0.0942595 ) ), \
irit.ctlpt( irit.E2, 0.379121, (-0.513736 ) ), \
irit.ctlpt( irit.E2, 0.324176, (-0.348901 ) ), \
irit.ctlpt( irit.E2, 0.247253, (-0.337912 ) ), \
irit.ctlpt( irit.E2, 0.285714, (-0.32967 ) ), \
irit.ctlpt( irit.E2, 0.339394, (-0.378232 ) ), \
#This is an IRIT script and as such requires both math and irit import: # import math import irit # # # An example of the cosine shader - setting the cosine exponent for irender. # s = irit.spheresrf(0.2) * irit.rx(90) s1 = s * irit.trans(((-0.5), 0.3, 0)) irit.attrib(s1, "srf_cosine", irit.GenIntObject(1)) s2 = s * irit.trans((0, 0.3, 0)) irit.attrib(s2, "srf_cosine", irit.GenIntObject(4)) s3 = s * irit.trans((0.5, 0.3, 0)) irit.attrib(s3, "srf_cosine", irit.GenIntObject(16)) s4 = s * irit.trans((-0.5, -0.3, 0)) irit.attrib(s4, "srf_cosine", irit.GenIntObject(32)) s5 = s * irit.trans((0, (-0.3), 0)) irit.attrib(s5, "srf_cosine", irit.GenIntObject(128)) s6 = s * irit.trans((0.5, (-0.3), 0)) irit.attrib(s6, "srf_cosine", irit.GenIntObject(256)) allspheres = irit.list(s1, s2, s3, s4, s5, s6)
