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