def positioncurvature(srf, u, v): eps = 1e-012 c = irit.circle((0, 0, 0), 1) k = irit.scrvtreval(srf, u, v, 1) r1 = irit.max( irit.min(1.0 / (irit.FetchRealObject(irit.nth(k, 1)) + eps), 1000), (-1000)) r2 = irit.max( irit.min(1.0 / (irit.FetchRealObject(irit.nth(k, 3)) + eps), 1000), (-1000)) v1 = irit.nth(k, 2) v2 = irit.nth(k, 4) p = irit.seval(srf, u, v) n = irit.snormal(srf, u, v) d1 = v1 ^ n d2 = v2 ^ n c1 = c * \ irit.sc( r1 ) * \ irit.rotz2v( irit.Fetch3TupleObject(d1) ) * \ irit.trans( irit.Fetch3TupleObject(irit.coerce( p, irit.VECTOR_TYPE ) + n * r1 )) c2 = c * \ irit.sc( r2 ) * \ irit.rotz2v( irit.Fetch3TupleObject(d2) ) * \ irit.trans( irit.Fetch3TupleObject(irit.coerce( p, irit.VECTOR_TYPE ) + n * r2) ) retval = irit.list( p, c1, c2, p + irit.coerce(irit.coerce(p, irit.POINT_TYPE) + v1, irit.E3), p + irit.coerce(irit.coerce(p, irit.POINT_TYPE) + v2, irit.E3), positionasymptotes(srf, u, v)) irit.adwidth(retval, 2) irit.color(retval, irit.YELLOW) return retval
def subdivtodepth(tsrf, dpth, vu, vv): if (dpth <= 0): retval = tsrf else: if (dpth / 2.0 != math.floor(dpth / 2.0)): v = vu * (2 ^ (dpth - 1)) umin = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 1)) umax = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 2)) tsrfs = irit.sdivide(tsrf, irit.COL, umin * 0.4999 + umax * 0.5001) else: v = vv * (2 ^ (dpth - 1)) vmin = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 3)) vmax = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 4)) tsrfs = irit.sdivide(tsrf, irit.ROW, vmin * 0.4999 + vmax * 0.5001) if (irit.SizeOf(tsrfs) == 2): retval = irit.list( subdivtodepth( irit.nth( tsrfs, 1 ) * \ irit.trans( irit.Fetch3TupleObject(-v) ), dpth - 1, vu, vv ), subdivtodepth( irit.nth( tsrfs, 2 ) * \ irit.trans( irit.Fetch3TupleObject(v) ), dpth - 1, vu, vv ) ) else: retval = subdivtodepth(irit.nth(tsrfs, 1), dpth - 1, vu, vv) return retval
def animbisectcrv2( crv1, crv2, data, cntr ): irit.color( crv1, irit.YELLOW ) irit.color( crv2, irit.YELLOW ) irit.adwidth( crv1, 4 ) irit.adwidth( crv2, 4 ) i = 0 while ( i <= irit.SizeOf( cntr ) - 1 ): pt = irit.coord( cntr, i ) pt1 = irit.ceval( crv1, irit.FetchRealObject(irit.coord( pt, 0 ) )) pt2 = irit.ceval( crv2, irit.FetchRealObject(irit.coord( pt, 1 ) )) nrml1 = cnormalplnr( crv1, irit.coord( pt, 0 ) ) nrml2 = cnormalplnr( crv2, irit.coord( pt, 1 ) ) aaa = irit.ptslnln( irit.Fetch3TupleObject(irit.coerce( pt1, irit.POINT_TYPE )), irit.Fetch3TupleObject(nrml1), irit.Fetch3TupleObject(irit.coerce( pt2, irit.POINT_TYPE )), irit.Fetch3TupleObject(nrml2 )) if (irit.IsNullObject(aaa)): interpt = irit.GenNullObject(); else: interpt = irit.nth( aaa, 1 ) if ( irit.ThisObject(interpt) == irit.POINT_TYPE ): irit.color( pt1, irit.GREEN ) irit.color( pt2, irit.GREEN ) irit.color( interpt, irit.WHITE ) bisectlns = irit.coerce( pt1, irit.E2 ) + irit.coerce( interpt, irit.E2 ) + irit.coerce( pt2, irit.E2 ) irit.color( bisectlns, irit.MAGENTA ) if ( irit.FetchRealObject(irit.coord( interpt, 1 )) < 10 and \ irit.FetchRealObject(irit.coord( interpt, 1 )) > (-10 ) and \ irit.FetchRealObject(irit.coord( interpt, 2 )) < 10 and \ irit.FetchRealObject(irit.coord( interpt, 2 )) > (-10 ) ): irit.view( irit.list( crv1, crv2, data, pt1, pt2, interpt, \ bisectlns ), irit.ON ) i = i + 1
def dominos(path, scl, piecetimestep): retval = irit.nil() animtime = 0 dominopiece = irit.box( (-0.01, -0.006, 0), 0.02, 0.006, 0.05) * irit.sc(scl) rot_x = irit.cbezier( irit.list( irit.ctlpt( irit.E1, 0 ), \ irit.ctlpt( irit.E1, 80 ) ) ) crvdomain = irit.pdomain(path) t = irit.FetchRealObject(irit.nth(crvdomain, 1)) dpath = irit.cderive(path) while (t < irit.FetchRealObject(irit.nth(crvdomain, 2))): d = irit.Fetch3TupleObject( irit.coerce(irit.ceval(dpath, t), irit.POINT_TYPE)) dlen = math.sqrt(DotProd(d, d)) rot_x = irit.creparam(rot_x, animtime, animtime + piecetimestep) irit.attrib(dominopiece, "animation", irit.list(rot_x)) irit.setname(irit.getattr(dominopiece, "animation"), 0, "rot_x") dp = dominopiece * irit.rz( -math.atan2(d[0], d[1]) * 180 / math.pi) * irit.trans( irit.Fetch3TupleObject( irit.coerce(irit.ceval(path, t), irit.VECTOR_TYPE))) irit.snoc(dp, retval) t = t + 0.04 * scl / dlen animtime = animtime + piecetimestep * 0.6 return retval
def srflineinter( srf, pt1, pt2, dir, param, numsegs,\ tol ): pta = irit.srinter(srf, irit.Fetch3TupleObject(pt1), dir, tol) ptb = irit.srinter( srf, irit.Fetch3TupleObject( ppblend(irit.Fetch3TupleObject(pt1), irit.Fetch3TupleObject(pt2), 2 / 3.0)), dir, tol) ptc = irit.srinter( srf, irit.Fetch3TupleObject( ppblend(irit.Fetch3TupleObject(pt1), irit.Fetch3TupleObject(pt2), 1 / 3.0)), dir, tol) ptd = irit.srinter(srf, irit.Fetch3TupleObject(pt2), dir, tol) crv = irit.bsp2bzr( irit.cinterp(irit.list(pta, ptb, ptc, ptd), 4, 4, irit.GenRealObject(param), 0)) crvs = irit.nil() i = 1 while (i <= numsegs): c = irit.cregion(crv, (i - 1) / float(numsegs), i / float(numsegs)) irit.color(c, i) irit.snoc(c, crvs) i = i + 1 retval = crvs return retval
def buildvisibilitymap( c, step, highlightangle ): retval = irit.nil( ) i = 0 while ( i <= 360 ): dir = irit.point( math.cos( i * math.pi/180 ), math.sin( i * 3.14159/180 ), 0 ) crvs = irit.cvisible( c, irit.Fetch3TupleObject(dir), 1e-005 ) crvdmn = cnvrtcrvs2domains( crvs, i ) if ( highlightangle == i ): irit.attrib( crvdmn, "width", irit.GenRealObject(0.01 )) irit.attrib( crvdmn, "gray", irit.GenRealObject(0 )) irit.attrib( crvdmn, "rgb", irit.GenStrObject("255, 255, 128" )) irit.adwidth( crvdmn, 3 ) highcrvdmn = crvdmn * irit.sx( 1/360.0 ) irit.attrib( crvs, "width", irit.GenRealObject(0.03 )) irit.adwidth( crvs, 3 ) irit.attrib( crvs, "rgb", irit.GenStrObject("255, 255, 128" )) irit.snoc( crvs, retval ) else: irit.attrib( crvdmn, "width", 0.01 ) irit.attrib( crvdmn, "gray", 0.5 ) irit.attrib( crvdmn, "rgb", "128, 128, 255" ) irit.snoc( crvdmn * irit.sx( 1/360 ), retval ) i = i + step retval = ( retval + irit.list( highcrvdmn ) ) 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 buildvisibilitymap( c, step ): retval = irit.nil( ) i = 0 while ( i <= 360 ): dir = irit.point( math.cos( i * math.pi/180 ), math.sin( i * 3.14159/180 ), 0 ) crvs = irit.cvisible( c, irit.Fetch3TupleObject(dir), 1e-005 ) irit.snoc( cnvrtcrvs2domains( crvs, i ) * irit.sx( 1/360.0 ), retval ) i = i + step return retval
def rigidmotionpos(cnew, c): t = irit.FetchRealObject(irit.nth(irit.pdomain(c), 1)) pos = irit.coerce(irit.ceval(c, t), irit.VECTOR_TYPE) tn = irit.ctangent(c, t, 1) retval = cnew * \ irit.rz( math.atan2( irit.FetchRealObject(irit.coord( tn, 1 )), irit.FetchRealObject(irit.coord( tn, 0 )) ) * \ 180/math.pi ) * \ irit.trans( irit.Fetch3TupleObject(pos) ) return retval
def uvpos2ln(srf, lnpt, lndir, mindist): uvpt = irit.srflndst(srf, irit.Fetch3TupleObject(lnpt), lndir, mindist, 0.001, 1e-010) e3pt = irit.seval(srf, irit.FetchRealObject(irit.coord(uvpt, 0)), irit.FetchRealObject(irit.coord(uvpt, 1))) e3nrml = irit.snormal(srf, irit.FetchRealObject(irit.coord(uvpt, 0)), irit.FetchRealObject(irit.coord(uvpt, 1))) edge = irit.coerce( irit.ptptln( irit.Fetch3TupleObject(irit.coerce( e3pt, irit.POINT_TYPE )), irit.Fetch3TupleObject(lnpt), lndir ), irit.E3 ) + \ e3pt nedge = (e3pt + irit.coerce(irit.coerce(e3pt, irit.POINT_TYPE) - e3nrml, irit.E3)) irit.color(e3pt, irit.MAGENTA) irit.adwidth(e3pt, 3) irit.color(edge, irit.CYAN) irit.color(nedge, irit.GREEN) line = irit.coerce( lnpt + irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 ) + \ irit.coerce( lnpt - irit.vector(lndir[0], lndir[1], lndir[2]) * irit.sc( 2 ), irit.E3 ) irit.color(line, irit.YELLOW) retval = irit.list(line, e3pt, edge, nedge) return retval
def displayptscrctan2crvs(pts, r, c1, c2): retval = irit.nil() circ = irit.circle((0, 0, 0), r) i = 1 while (i <= irit.SizeOf(pts)): pt = irit.coord(pts, i) prms = irit.getattr(pt, "params") ptc1 = irit.ceval(c1, irit.FetchRealObject(irit.coord(prms, 0))) ptc2 = irit.ceval(c2, irit.FetchRealObject(irit.coord(prms, 1))) irit.snoc( irit.list( irit.coerce( pt, irit.E2 ) + ptc1, \ irit.coerce( pt, irit.E2 ) + ptc2, \ circ * irit.trans( irit.Fetch3TupleObject(irit.coerce( pt, irit.VECTOR_TYPE )) ) ), retval ) i = i + 1 return retval
def uvpos2pt(srf, pt, mindist): pt = irit.coerce(pt, irit.POINT_TYPE) uvpt = irit.srfptdst(srf, irit.Fetch3TupleObject(pt), mindist, 0.001, 1e-010) e3pt = irit.seval(srf, irit.FetchRealObject(irit.coord(uvpt, 0)), irit.FetchRealObject(irit.coord(uvpt, 1))) e3nrml = irit.snormal(srf, irit.FetchRealObject(irit.coord(uvpt, 0)), irit.FetchRealObject(irit.coord(uvpt, 1))) edge = (irit.coerce(pt, irit.E3) + e3pt) nedge = (e3pt + irit.coerce(irit.coerce(e3pt, irit.POINT_TYPE) - e3nrml, irit.E3)) irit.color(e3pt, irit.MAGENTA) irit.adwidth(e3pt, 3) irit.color(pt, irit.YELLOW) irit.color(edge, irit.CYAN) irit.color(nedge, irit.GREEN) retval = irit.list(e3pt, pt, edge, nedge) return retval
def extractcrvregion( crv, t1, t2, idx ): if ( irit.FetchRealObject(t1) < 0 ): retval = irit.cregion( crv, irit.FetchRealObject(t1) + 1, 1 ) + irit.cregion( crv, 0, irit.FetchRealObject(t2) ) else: retval = irit.cregion( crv, irit.FetchRealObject(t1), irit.FetchRealObject(t2) ) retval = irit.creparam( retval, 0, 1 ) tn = irit.vector( 1, 0, 0 ) * irit.rz( irit.FetchRealObject( idx ) ) retval = irit.list( retval * irit.trans( irit.Fetch3TupleObject( tn * irit.sc( 0.15 ) ) ), irit.arrow3d( irit.coerce( irit.ceval( retval, 0.5 ), 3 ), tn, 0.35, 0.01, 0.1, 0.02 ) ) irit.attrib( retval, "width", irit.GenRealObject( irit.random( 0.007, 0.01 ) ) ) irit.attrib( retval, "gray", irit.GenRealObject( irit.random( 0.2, 0.8 ) ) ) irit.attrib( retval, "rgb", irit.GenStrObject( str(int(irit.random( 100, 255 ) ) ) + "," + str(int(irit.random( 100, 255 ) ) ) + "," + str(int(irit.random( 100, 255 ) ) ) ) ) return retval
def buildoffsetvisibilitymap( c, step, ofst ): retval = irit.nil( ) co = irit.offset( c, irit.GenRealObject(ofst), 1e-006, 1 ) tmin = irit.nth( irit.pdomain( co ), 1 ) tmax = irit.nth( irit.pdomain( co ), 2 ) t = tmin while ( t <= tmax ): pt = irit.coerce( irit.ceval( co, irit.FetchRealObject(t) ), irit.POINT_TYPE ) * \ irit.tz( 1 ) crvs = irit.cvisible( c, irit.Fetch3TupleObject(pt) , 1e-005 ) crvdmn = cnvrtcrvs2domains( crvs, t ) irit.attrib( crvdmn, "width", irit.GenRealObject(0.01) ) irit.attrib( crvdmn, "gray", irit.GenRealObject(0.5) ) irit.attrib( crvdmn, "rgb", irit.GenStrObject("128, 128, 255" )) irit.snoc( crvdmn, retval ) t = t + step return retval
def skel2dcolor( prim1, prim2, prim3, eps, mzerotols, drawall, fname ): equapt = irit.skel2dint( prim1, prim2, prim3, 100, eps, 300, mzerotols ) if ( irit.SizeOf( equapt ) > 1 ): irit.printf( "%d solutions detected\n", irit.list( irit.SizeOf( equapt ) ) ) irit.color( equapt, irit.WHITE ) irit.adwidth( prim1, 2 ) irit.adwidth( prim2, 2 ) irit.adwidth( prim3, 2 ) tans = irit.nil( ) edges = irit.nil( ) circs = irit.nil( ) i = 1 while ( i <= irit.SizeOf( equapt ) ): e = irit.nth( equapt, i ) clrs = getrandomcolors( ) clr = irit.nth( clrs, 1 ) dclr = irit.nth( clrs, 2 ) d = irit.getattr( e, "prim1pos" ) irit.snoc( d, tans ) irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim1pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges ) irit.snoc( irit.getattr( e, "prim2pos" ), tans ) irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim2pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges ) irit.snoc( irit.getattr( e, "prim3pos" ), tans ) irit.snoc( setcolor( irit.coerce( irit.getattr( e, "prim3pos" ), irit.E2 ) + irit.coerce( e, irit.E2 ), dclr ), edges ) irit.snoc( setcolor( irit.pcircle( irit.Fetch3TupleObject(irit.coerce( e, irit.VECTOR_TYPE )), irit.dstptpt( d, e ) ), 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 )
# ############################################################################# # # 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.interact( irit.list( view_mat0, pl1, pts ) ) irit.save( "pt_inpl1", irit.list( irit.GetViewMatrix(), pl1, pts ) ) irit.free( pl1 ) # ############################################################################# # # Point inclusion in a curve:
# 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 while (i <= irit.SizeOf(pt_param)): pt = irit.ceval(crv1, irit.FetchRealObject(irit.nth(pt_param, i))) irit.snoc(pt, pt_extrem) i = i + 1 crv1a = irit.cbspline( 4, 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.ctlpt( irit.E2, 0.325, 0.502 ), \ irit.ctlpt( irit.E2, 0.0699, 0.656 ), \ irit.ctlpt( irit.E2, (-0.137 ), 0.5 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.tx( (-0.1 ) ) * irit.ty( (-0.2 ) ) * irit.sc( 3 ) irit.adwidth(c, 2) d = irit.duality(irit.coerce(c, irit.KV_OPEN)) irit.color(d, irit.YELLOW) irit.adwidth(d, 2) irit.interact(irit.list(c, d, irit.GetAxes())) bg_obj = irit.list(c, d, irit.GetAxes()) t = 0 while (t <= 1): pc = irit.circle( irit.Fetch3TupleObject(irit.coerce(irit.ceval(c, t), irit.VECTOR_TYPE)), 0.1) irit.viewobj(pc) pd = irit.circle( irit.Fetch3TupleObject(irit.coerce(irit.ceval(d, t), irit.VECTOR_TYPE)), 0.1) irit.color(pd, irit.YELLOW) irit.view(irit.list(pc, pd, bg_obj), irit.ON) t = t + 0.002 pt1 = irit.sphere((0, 0, 0), 0.15) irit.attrib(pt1, "rgb", irit.GenStrObject("255,128,0")) mov_xyz1 = c * irit.tx(0) irit.attrib(pt1, "animation", mov_xyz1) pt2 = pt1 irit.attrib(pt2, "rgb", irit.GenStrObject("255,128,128"))
irit.adwidth(irit.point(pt[0], pt[1], pt[2]), 3) irit.color(irit.point(pt[0], pt[1], pt[2]), irit.YELLOW) bisectsrf = irit.sbisector(s1, pt) irit.color(bisectsrf, irit.GREEN) irit.interact(irit.list(s1, pt, bisectsrf)) irit.save("bisectr7", irit.list(s1, pt, bisectsrf)) z = 1 while (z >= (-1)): pt = irit.point(0, 0, z) irit.adwidth(pt, 3) irit.color(pt, irit.YELLOW) bisectsrf = irit.sbisector(s1, irit.Fetch3TupleObject(pt)) irit.color(bisectsrf, irit.GREEN) irit.view(irit.list(s1, pt, bisectsrf), irit.ON) z = z + (-0.01) irit.pause() # ############################################################################ # # A sphere--sphere/sphere-pt bisector # s = irit.spheresrf(1) irit.color(s, irit.RED) s1 = irit.sregion( irit.sregion( s, irit.ROW, 0.5, 1.5 ), irit.COL, 2.5,\ 3.5 )
# ############################################################################ b = irit.box(((-1), (-1), (-1)), 2, 2, 2) irit.color(b, irit.YELLOW) irit.view(irit.list(b, irit.GetViewMatrix()), irit.ON) irit.pause() # # Truncation along vertices. # pl1 = (-irit.poly( irit.list(irit.vector((-10), (-10), 1.8), irit.vector( (-10), 10, 1.8), irit.vector(10, 10, 1.8), irit.vector( 10, (-10), 1.8)), 0)) * irit.rotz2v( irit.Fetch3TupleObject(irit.vector(1, 1, 1) * math.sqrt(3))) irit.color(pl1, irit.GREEN) a = (-0.04) while (a >= (-0.5)): p = pl1 * irit.trans((a, a, a)) bt1 = b - p - p * irit.roty(90) - p * irit.roty(180) - p * irit.roty( 270) - p * irit.rotx(90) - p * irit.rotx(90) * irit.roty( 90) - p * irit.rotx(90) * irit.roty(180) - p * irit.rotx( 90) * irit.roty(270) irit.color(bt1, irit.YELLOW) irit.view(irit.list(bt1), irit.ON) a = a + (-0.02) pl1 = (-irit.poly( irit.list(irit.vector((-10), (-10), 1.4), irit.vector(
# the center point, s1( 0.5, 0.5 ) = s2( 0.5, 0.5 ) ~= (1.175, 1.13, 1.49 ) # s1 = irit.sbezier( irit.list( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 1.6 ), \ irit.ctlpt( irit.E3, 0.3, 1.1, 0.4 ), \ irit.ctlpt( irit.E3, 0, 2.2, 1.5 ) ), irit.list( \ irit.ctlpt( irit.E3, 1.1, 0.2, 3 ), \ irit.ctlpt( irit.E3, 1.3, 1, 1.4 ), \ irit.ctlpt( irit.E3, 1, 2.2, 2.7 ) ), irit.list( \ irit.ctlpt( irit.E3, 2.1, 0.1, 1.4 ), \ irit.ctlpt( irit.E3, 2.3, 1.3, 0.2 ), \ irit.ctlpt( irit.E3, 2, 2.2, 1.2 ) ) ) ) p = irit.seval(s1, 0.5, 0.5) s2a = s1 * \ irit.trans( irit.Fetch3TupleObject(-irit.coerce( p, 4 ) ) ) * \ irit.scale( ( 1.2, 1.1, (-0.5 ) ) ) * \ irit.rotz( 15 ) * \ irit.trans( ( irit.FetchRealObject(irit.coord( p, 1 )), irit.FetchRealObject(irit.coord( p, 2 )), irit.FetchRealObject(irit.coord( p, 3 )) + 0.1 ) ) irit.color(s1, irit.RED) irit.color(s2a, irit.GREEN) i = testinter(s1, s2a) all = irit.list(s1, s2a, i) irit.interact(all) irit.save("ssi10", all)
irit.coord(cntr, 1) * (m10 + m01)) / nrml e = (irit.GenRealObject(-2) * m11 * irit.coord(cntr, 1) - irit.coord(cntr, 0) * (m10 + m01)) / nrml f = ((-a) * irit.sqr(irit.coord(pt1, 0)) + b * irit.coord(pt1, 0) * irit.coord(pt1, 1) + c * irit.sqr(irit.coord(pt1, 1)) + d * irit.coord(pt1, 0) + e * irit.coord(pt1, 1)) conic = irit.conicsec(irit.list(a, b, c, d, e, f), 0, irit.OFF, irit.OFF) if (irit.IsNullObject(conic)): conic = irit.GenRealObject(0) irit.color(conic, irit.MAGENTA) ell = boundingellipse(pt1, pt2, pt3) irit.color(ell, irit.YELLOW) irit.adwidth(ell, 2) ell2 = irit.conicsec( irit.ellipse3pt( irit.Fetch3TupleObject(pt1), \ irit.Fetch3TupleObject(pt2), \ irit.Fetch3TupleObject(pt3), \ 0.02 ), 0, 0,\ 0 ) irit.color(ell2, irit.CYAN) irit.adwidth(ell2, 3) all = irit.list( irit.GetAxes(), ell2, ell, conic, pt1, pt2,\ pt3, pl ) irit.view(all, irit.ON) irit.milisleep(200) i = i + 1 irit.save("ellips2", all) # ############################################################################
j = 1 while ( j <= irit.SizeOf( crvs ) ): c = irit.coerce( irit.nth( crvs, j ), irit.KV_OPEN ) irit.attrib( c, "rgb", irit.GenStrObject("0,255,128") ) irit.attrib( c, "gray", irit.GenRealObject(0.5) ) irit.awidth( c, 0.02 ) co = irit.offset( c, irit.GenRealObject(ofst), 0.001, 1 ) dms = buildoffsetvisibilitymap( c, step, ofst ) irit.attrib( dms, "rgb", irit.GenStrObject("128, 128, 255" )) views = computeviews( c, dms, "" ) viewptcurves = irit.nil( ) i = 1 while ( i <= irit.SizeOf( views ) ): t = irit.FetchRealObject(irit.nth( views, i ) * step) pt = irit.coerce( irit.ceval( co, t ), irit.POINT_TYPE ) * irit.tz( 1 ) v = offsetcrvlist( irit.cvisible( c, irit.Fetch3TupleObject(pt), 0.0001 ), 1/100.0 + i/130 ) irit.attrib( v, "dash", irit.nth( dashlist, i ) ) irit.awidth( v, 0.009 ) rgb = randrgb( ) pt = pt * irit.sz( 0.01 ) irit.attrib( v, "rgb", irit.GenStrObject(rgb )) irit.attrib( pt, "rgb", irit.GenStrObject(rgb )) irit.snoc( pt, viewptcurves ) irit.snoc( v, viewptcurves ) i = i + 1 irit.interact( irit.list( c, viewptcurves ) ) irit.save( "art" + str(j) + "glry", irit.list( c, viewptcurves ) ) j = j + 1 # ############################################################################
c * irit.sx(0.65) * irit.sy(0.75) * irit.tz(0.7), c * irit.sc(1.7) * irit.tz(1.1), c * irit.tz(1.5)), 3, irit.KV_OPEN) irit.color(s, irit.YELLOW) irit.SetResolution(70) silhs = irit.nil() # Loop with step one for slower, more complete result. # printf( "Processing vector %d\\n", list( i ) ): i = 1 while (i <= irit.SizeOf(sphdirs)): irit.snoc( irit.silhouette( s, irit.Fetch3TupleObject( irit.coerce(irit.nth(sphdirs, i), irit.VECTOR_TYPE)), 1), silhs) i = i + 2 irit.interact(irit.list(s, silhs)) irit.save("silh1", irit.list(s, silhs)) irit.free(c) irit.free(s) irit.free(silhs) irit.free(sphdirs) # ############################################################################ s = irit.torussrf(1, 0.3) irit.color(s, irit.MAGENTA)
# pt = irit.point(0, 0.35, 0) irit.color(pt, irit.CYAN) # # Modifying the curve. # a = 0 while (a >= (-1)): crv = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-0.8 ), (-0.6 ) ), \ irit.ctlpt( irit.E2, (-0.3 ), (-0.2 ) ), \ irit.ctlpt( irit.E2, 0, a ), \ irit.ctlpt( irit.E2, 0.8, (-0.6 ) ) ) ) irit.color(crv, irit.YELLOW) orth = irit.orthotomc(crv, irit.Fetch3TupleObject(pt), 2) irit.color(orth, irit.GREEN) irit.view(irit.list(orth, crv, pt) * irit.tx(0.5), irit.ON) a = a + (-0.01) # # Modifying K. # a = 2 while (a >= (-1)): orth = irit.orthotomc(crv, irit.Fetch3TupleObject(pt), a) irit.color(orth, irit.GREEN) irit.view(irit.list(orth, crv, pt) * irit.tx(0.5), irit.ON) a = a + (-0.01) irit.save("orthtmc1", irit.list(orth, crv, pt))
# ############################################################################ # # Prism's puzzle. # eps = 0.025 an = 71 ca = math.cos(an * math.pi / 180) sa = math.sin(an * math.pi / 180) vec1 = irit.vector(1, 0, 0) vec2 = irit.vector((-ca), sa, 0) vec3 = irit.coerce( irit.normalizeVec(irit.normalizeVec(vec1 + vec2) + irit.vector(0, 0, 1.4)) * 0.5, irit.VECTOR_TYPE) prism1 = irit.gbox((0, 0, 0), irit.Fetch3TupleObject(vec1), irit.Fetch3TupleObject(vec2), irit.Fetch3TupleObject(vec3)) rvec = vec2 ^ vec3 prism2 = prism1 * \ irit.rotvec( irit.Fetch3TupleObject(rvec), \ 180 * math.acos( irit.FetchRealObject(irit.normalizeVec( vec2 ) * irit.normalizeVec( vec3 )) )/ math.pi ) * \ irit.trans( irit.Fetch3TupleObject(-vec2 ) ) * \ irit.rotvec( irit.Fetch3TupleObject(vec2), (-60 ) ) * \ irit.trans( irit.Fetch3TupleObject((-vec1 ) + irit.normalizeVec( vec1 + vec2 )*0.6 + irit.vector( 0, 0, 0.81 )) ) item1 = prism1 ^ prism2 irit.color(item1, irit.RED) prism2a = prism2 * \
ed4 = irit.edge3d((-1), 0, 1, 1, 2, (-1)) irit.interact(irit.list(irit.GetAxes(), ed1, ed2, ed3, ed4)) # printf( "%d) v3 = %19.16vf :: ", list( i, v3- v3*m ) ): i = 0 while (i <= 9): v1 = irit.vector(irit.random((-1), 1), irit.random((-1), 1), irit.random((-1), 1)) v1 = irit.normalizeVec(v1) v2 = irit.vector(irit.random((-1), 1), irit.random((-1), 1), irit.random((-1), 1)) v2 = irit.normalizeVec(v2) v3 = v1 ^ v2 v3 = irit.normalizeVec(v3) m = irit.rotv2v(irit.Fetch3TupleObject(v1), irit.Fetch3TupleObject(v2)) #irit.printf( "%d) v1 = %7.4vf v2 = %7.4vf :: ", irit.list( i, v1, v2 ) ) print str(i) + \ ") v1 = " + \ str(irit.Fetch3TupleObject(v1)) + \ ") v2 = " + \ str(irit.Fetch3TupleObject(v2)) if (v1 * m != v2 or v2 * (m ^ (-1)) != v1 or v3 != v3 * m): print "errror\n" else: print "ok\n" i = i + 1 irit.save( "macros1",
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) bisect = irit.sbisector(s1, irit.Fetch3TupleObject(pt)) irit.color(bisect, irit.CYAN) irit.save("sbisect1", irit.list(s1, pt, bisect)) irit.interact(irit.list(s1, pt, bisect)) z = 1 while (z >= (-1)): pt = irit.point(0, 0, z) irit.adwidth(pt, 3) irit.color(pt, irit.YELLOW) bisect = irit.sbisector(s1, irit.Fetch3TupleObject(pt)) irit.color(bisect, irit.CYAN) irit.view(irit.list(s1, pt, bisect), irit.ON) z = z + (-0.01)
irit.color( c6, irit.GREEN ) crvs = irit.list( c1, c2, c3, c4, c5, c6 ) # ############################################################################ res = irit.nil( ) i = 1 while ( i <= irit.SizeOf( crvs ) ): c = irit.nth( crvs, i ) a = 0 while ( a <= 360 ): dir = irit.vector( math.cos( a * math.pi/180 ), math.sin( a * math.pi/180 ), 0 ) vc = irit.cvisible( c, irit.Fetch3TupleObject(dir), 1e-005 ) irit.adwidth( vc, 3 ) irit.color( vc, irit.YELLOW ) if ( a == 80 or a == 160 or a == 240 or a == 20 ): irit.snoc( irit.list( irit.coerce( dir, irit.E2 ) + irit.ctlpt( irit.E2, 0, 0 ), vc, c ) * irit.ty( i * 1.6 ) * irit.tx( ( a - 200 )/40.0 ), res ) irit.view( irit.list( dir, vc, c ), irit.ON ) a = a + 20 i = i + 1 res = res * irit.sc( 0.2 ) * \ irit.ty( (-1.15 ) ) * irit.rz( 90 ) * irit.ty( 0.4 ) irit.save( "cvisib1", res )