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:
#
# ############################################################################
pl = irit.poly( irit.list( ( 1, 0, 0 ), ( 0, (-0.8 ), 0 ), irit.point( (-0.5 ), 0, 0 ) ), irit.FALSE )
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):
retval = irit.nil()
else:
t = (tmin + tmax) / 2
irit.viewclear()
p = (1, 1, 0)
t1c1 = irit.crvpttan(c1, p, 0.01)
i = 1
while (i <= irit.SizeOf(t1c1)):
irit.viewobj(
irit.ceval(c1, irit.FetchRealObject(irit.nth(t1c1, i))) +
irit.coerce(irit.point(p[0], p[1], p[2]), irit.E3))
i = i + 1
irit.viewobj(irit.list(p, c1))
irit.pause()
irit.viewclear()
p = (0, 1, 0)
t1c2 = irit.crvpttan(c2, p, 0.01)
irit.viewstate("polyaprx", 1)
i = 1
while (i <= irit.SizeOf(t1c2)):
irit.viewobj(
irit.ceval(c2, irit.FetchRealObject(irit.nth(t1c2, i))) +
irit.coerce(irit.point(p[0], p[1], p[2]), irit.E3))
i = i + 1
irit.viewobj(irit.list(p, c2))
irit.pause()
irit.viewstate("polyaprx", 0)
#
# Tangents to a curve at two different locations.
#
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some duality tests, Gershon Elber 2002
#
# Faster product using Bezier decomposition.
iprod = irit.iritstate("bspprodmethod", irit.GenIntObject(0))
view_mat1 = irit.sc(0.5)
irit.viewobj(view_mat1)
irit.viewstate("pllnaprx", 1)
irit.viewstate("pllnaprx", 1)
#
# An ellipse like curve
#
c = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.6 ), (-0.3 ), 0 ), \
irit.ctlpt( irit.E2, 0.6, (-0.3 ) ), \
irit.ctlpt( irit.E2, 0.6, 0.3 ), \
irit.ctlpt( irit.E2, (-0.6 ), 0.3 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.sc( 2 )
d = irit.duality(irit.coerce(c, irit.KV_OPEN))
irit.color(d, irit.YELLOW)
irit.interact(irit.list(c, d))
import irit
#
#
# 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)
irit.view(irit.list(ucrvtrxyz, vcrvtrxyz), irit.OFF)
irit.save("scrvtr2", irit.list(ucrvtrxyz, vcrvtrxyz))
irit.pause()
# ############################################################################
cross = ( irit.ctlpt( irit.E3, 0.2, 0, 1 ) + \
irit.ctlpt( irit.E3, 1, 0, 1 ) + \
irit.ctlpt( irit.E3, 0.2, 0, 0 ) )
con = irit.surfprev(cross)
irit.view(irit.list(con, irit.GetAxes()), irit.ON)
irit.viewstate("polyaprx", 0)
irit.viewstate("polyaprx", 0)
irit.viewstate("numisos", 0)
irit.viewstate("numisos", 0)
ucrvtrzxy = irit.scrvtr(con, irit.P3, irit.ROW)
vcrvtrzxy = irit.scrvtr(con, irit.P3, irit.COL)
ucrvtrxyz = ucrvtrzxy * irit.rotx((-90)) * irit.roty((-90)) * irit.scale(
(1, 1, 1))
vcrvtrxyz = vcrvtrzxy * irit.rotx((-90)) * irit.roty((-90)) * irit.scale(
(1, 1, 0.1))
irit.color(ucrvtrxyz, irit.RED)
irit.color(vcrvtrxyz, irit.MAGENTA)
irit.view(irit.list(ucrvtrxyz, vcrvtrxyz), irit.OFF)
import irit # # # 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 ),
irit.attrib(s2, "gray", irit.GenRealObject(0.35))
irit.awidth(s2, 0.012)
all1 = irit.list(s1, s2, c1)
irit.interact(all1)
irit.save("crv1dcmp", all1)
#
# Try to decompose
#
c1h = canonicalh(c1, r1, 3, 2, irit.E2)
c2h = canonicalh(c1, r2, 3, 2, irit.E2)
d1 = irit.decompose(c1h)
dc1 = originalf(c1, irit.nth(d1, 1), 3, 2, irit.E2)
irit.viewstate("dsrfmesh", 1)
irit.interact(irit.list(c1, dc1 * irit.tz(1), c1a * irit.tz((-1))))
d2 = irit.decompose(c2h)
dc2 = originalf(c1, irit.nth(d2, 1), 3, 2, irit.E2)
irit.interact(irit.list(c1, dc2 * irit.tz(1), c2a * irit.tz((-1))))
irit.viewstate("dsrfmesh", 0)
s1d = irit.sfromcrvs(
irit.list(dc1 * irit.ty(1) * irit.tz(3),
dc1 * irit.ty((-1)) * irit.tz(2), dc1 * irit.tz(1), dc1), 4,
irit.KV_OPEN)
irit.attrib(s1d, "gray", irit.GenRealObject(0.2))
irit.awidth(s1d, 0.012)
cb = irit.cbezier(cbzr) * irit.scale((0.7, 1.4, 1))
irit.color(cb, irit.RED)
sb = irit.sbezier(sbzr)
irit.color(sb, irit.RED)
irit.save(
"bezier1",
irit.list(irit.fforder(cb), irit.ffmsize(cb), irit.ffctlpts(cb),
irit.fforder(sb), irit.ffmsize(sb), irit.ffctlpts(sb)))
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), cb, sb))
irit.viewstate("dsrfmesh", 1)
irit.pause()
irit.viewstate("dsrfmesh", 0)
irit.pause()
#
# Curve refinement (note the returned curve is a bspline curve).
#
cb_ref = irit.crefine(cb, 0, irit.list(0.25, 0.5, 0.75))
irit.color(cb_ref, irit.YELLOW)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), cb, cb_ref))
#
# Curve subdivision.
#
#
# 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 ))
# ###########################################################################
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 ) ), \
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)
irit.adwidth(pt, 3)
irit.color(pt, irit.YELLOW)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some tests for the PRISA (planar layout) code.
#
save_res = irit.GetResolution()
save_mat = irit.GetViewMatrix()
samppercrv = 64
irit.viewobj(irit.GetViewMatrix())
irit.viewstate("numisos", 0)
irit.viewstate("numisos", 0)
def layouthandleonetrimmed(trmsrf, highlighttrim):
srf = irit.strimsrf(trmsrf)
if (highlighttrim):
irit.color(srf, irit.BLUE)
irit.color(trmsrf, irit.YELLOW)
irit.awidth(srf, 0.0001)
irit.awidth(trmsrf, 0.01)
else:
irit.color(srf, irit.YELLOW)
irit.color(trmsrf, irit.BLUE)
irit.awidth(srf, 0.01)
irit.awidth(trmsrf, 0.0001)
#
# Computing the kernel and diameter of a freeform simple closed curve.
#
save_res = irit.GetResolution()
irit.SetResolution(70)
bg = irit.poly(
irit.list(irit.point((-3), (-3), (-1)), irit.point((-3), 3, (-1)),
irit.point(3, 3, (-1)), irit.point(3, (-3), (-1))), irit.FALSE)
irit.color(bg, irit.YELLOW)
view_mat1 = irit.tx(0)
irit.view(irit.list(view_mat1), irit.ON)
view_mat2 = irit.GetViewMatrix() * irit.sc(0.5) * irit.ty(0.5)
irit.viewstate("depthcue", 0)
irit.viewstate("drawstyle", 1)
irit.viewstate("polyaprx", 1)
# ############################################################################
c4 = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.6 ), (-0.3 ), 0 ), \
irit.ctlpt( irit.E2, 0.6, (-0.3 ) ), \
irit.ctlpt( irit.E2, 0.6, 0.3 ), \
irit.ctlpt( irit.E2, (-0.6 ), 0.3 ) ), irit.list( irit.KV_PERIODIC ) )
k = irit.crvkernel(c4, 0, 0, irit.list(3, 3, 3), 0)
irit.attrib(k, "rgb", irit.GenStrObject("1,1,1"))
irit.interact(irit.list(c4, bg, k * irit.sz(0), view_mat1))
irit.attrib(k, "rgb", irit.GenStrObject("0,255,255"))
#
# A simple example of curve morphing.
#
# Gershon Elber, July 1994.
#
#
# Sets the viewing direction on the display device.
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix( irit.rotx( 0 ))
irit.viewobj( irit.GetViewMatrix() )
irit.SetViewMatrix( save_mat)
irit.viewstate( "widthlines", 1 )
irit.viewstate( "pllnaprx", 1 )
irit.viewstate( "pllnaprx", 1 )
#
# Animation speed. The lower this number, the faster the animations will be,
# skipping more frames.
#
speed = 1
# ###########################################################################
wave1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0.2, 0, 0 ), \
irit.ctlpt( irit.E3, 0.25, 0, 0 ), \
irit.ctlpt( irit.E3, 0.25, 0.5, 0 ), \
irit.ctlpt( irit.E3, 0.3, 0.5, 0 ), \
irit.ctlpt( irit.E2, 0.85, 0 ) ), irit.list( irit.KV_OPEN ) )
c = ((-c) + c * irit.sx((-1)))
srfeight = irit.surfprev(c * irit.ry(90))
irit.color(srfeight, irit.YELLOW)
irit.awidth(srfeight, 0.001)
sparabs = computeparaboliclines(srfeight)
irit.interact(irit.list(srfeight, sparabs))
#
# View the aspect graph with silhouettes...
#
saspect = computetopoaspectgraph(srfeight, 0.9)
irit.viewstate("polyaprx", 1)
irit.viewstate("polyaprx", 1)
irit.viewstate("numisos", 0)
irit.viewstate("numisos", 0)
irit.viewstate("numisos", 0)
irit.viewstate("numisos", 0)
irit.viewstate("lowresratio", 1)
irit.viewstate("lowresratio", 1)
irit.viewstate("dsrfsilh", 1)
irit.interact(saspect)
irit.save("aspct1gr", saspect)
irit.viewstate("dsrfsilh", 0)
irit.viewstate("polyaprx", 0)
irit.SizeOf(menu), 0.5, 0.5,
0.95, 0.95)
irit.printf(
"menu (%f %f) %f\n",
irit.list(irit.coord(xypos, 0), irit.coord(xypos, 1),
menuindex))
if (menuindex == 1):
quit = 1
if (menuindex == 2):
irit.view(irit.list(menu, crv), irit.ON)
if (menuindex == 3):
irit.view(irit.list(menu, srf), irit.ON)
if (menuindex == 4):
irit.view(irit.list(menu, crv, srf), irit.ON)
if (menuindex == 5):
irit.viewstate("dsrfmesh", (-1))
#
# A function to find the closest control point of Crv to the given location
# and update of that point to be the specified location.
#
def updateclosestctlpt(crv, pos):
n = irit.SizeOf(crv)
mindist = 1e+006
retval = minindex = 0
i = 0
while (i <= n - 1):
pt = irit.coerce(irit.coord(crv, i), irit.POINT_TYPE)
if (irit.dstptpt(pt, pos) < mindist):
