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 )
