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):