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 evalantipodalptsonsrf( srf ):
aps = irit.antipodal( srf, 0.001, (-1e-012 ) )
irit.printf( "%d antipodal points detected\n", irit.list( irit.SizeOf( aps ) ) )
retval = irit.nil( )
diam = 0
i = 1
while ( i <= irit.SizeOf( aps ) ):
ap = irit.nth( aps, i )
u1 = irit.coord( ap, 1 )
v1 = irit.coord( ap, 2 )
u2 = irit.coord( ap, 3 )
v2 = irit.coord( ap, 4 )
pt1 = irit.seval( srf, irit.FetchRealObject(u1), irit.FetchRealObject(v1) )
pt2 = irit.seval( srf, irit.FetchRealObject(u2), irit.FetchRealObject(v2) )
if ( irit.dstptpt( irit.coerce( pt1, irit.POINT_TYPE ),
irit.coerce( pt2, irit.POINT_TYPE ) ) > diam ):
diam = irit.dstptpt( irit.coerce( pt1, irit.POINT_TYPE ),
irit.coerce( pt2, irit.POINT_TYPE ) )
diamline = pt1 + pt2
irit.snoc( irit.list( pt1 + pt2, pt1 * irit.tx( 0 ), pt2 * irit.tx( 0 ) ), retval )
i = i + 1
irit.color( retval, irit.YELLOW )
irit.color( diamline, irit.CYAN )
irit.adwidth( diamline, 3 )
irit.snoc( irit.list( diamline ), retval )
return retval
def displayobjobjmdres(o1, o2, eps):
global glbltransx
mdres = irit.mindist2ff(o1, o2, eps)
dist = irit.nth(mdres, 1)
param1 = irit.nth(mdres, 2)
param2 = irit.nth(mdres, 3)
if (irit.SizeOf(param1) == 0):
pt1 = irit.coerce(o1, irit.E3)
else:
prm = irit.nth(param1, 1)
if (irit.ThisObject(prm) == irit.NUMERIC_TYPE):
i = 1
while (i <= irit.SizeOf(param1)):
t = irit.nth(param1, i)
irit.printf("min distance %f detected at t1 = %f\n",
irit.list(dist, t))
i = i + 1
pt1 = irit.ceval(o1, irit.FetchRealObject(t))
else:
i = 1
while (i <= irit.SizeOf(param1)):
uv = irit.nth(param1, i)
irit.printf("min distance %f detected at uv1 = %f %f\n",
irit.list(dist, irit.nth(uv, 1), irit.nth(uv, 2)))
i = i + 1
pt1 = irit.seval(
o1, irit.FetchRealObject(irit.nth(irit.nth(param1, 1), 1)),
irit.FetchRealObject(irit.nth(irit.nth(param1, 1), 2)))
if (irit.SizeOf(param2) == 0):
pt2 = irit.coerce(o2, irit.E3)
else:
prm = irit.nth(param2, 1)
if (irit.ThisObject(prm) == irit.NUMERIC_TYPE):
i = 1
while (i <= irit.SizeOf(param2)):
t = irit.nth(param2, i)
irit.printf("min distance %f detected at t2 = %f\n",
irit.list(dist, t))
i = i + 1
pt2 = irit.ceval(o2, irit.FetchRealObject(t))
else:
i = 1
while (i <= irit.SizeOf(param2)):
uv = irit.nth(param2, i)
irit.printf("min distance %f detected at uv2 = %f %f\n",
irit.list(dist, irit.nth(uv, 1), irit.nth(uv, 2)))
i = i + 1
pt2 = irit.seval(
o2, irit.FetchRealObject(irit.nth(irit.nth(param2, 1), 1)),
irit.FetchRealObject(irit.nth(irit.nth(param2, 1), 2)))
irit.color(pt1, irit.MAGENTA)
irit.color(o1, irit.MAGENTA)
irit.color(pt2, irit.YELLOW)
irit.color(o2, irit.YELLOW)
l = (pt1 + pt2)
all = irit.list(o1, o2, pt1, pt2, l)
irit.snoc(all * irit.tx(glbltransx), glblres)
glbltransx = (glbltransx + 0.5)
irit.interact(all)
def evaloneflecnodalpts(srf, pts):
if (irit.ThisObject(pts) == irit.CTLPT_TYPE):
retval = irit.seval(srf, irit.FetchRealObject(irit.coord(pts, 1)),
irit.FetchRealObject(irit.coord(pts, 2)))
irit.color(retval, irit.BLUE)
else:
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
irit.snoc(
irit.seval(srf, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))), retval)
i = i + 1
return retval
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 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 evaluvtoe3(srf, uvs, clr):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(uvs)):
uv = irit.nth(uvs, i)
irit.snoc(
irit.seval(srf, irit.FetchRealObject(irit.coord(uv, 1)),
irit.FetchRealObject(irit.coord(uv, 2))), retval)
i = i + 1
irit.color(retval, clr)
return retval
def evaltritangency(srfs, pts):
retval = irit.nil()
if (irit.ThisObject(srfs) == irit.SURFACE_TYPE):
srf1 = srfs
srf2 = srfs
srf3 = srfs
else:
srf1 = irit.nth(srfs, 1)
srf2 = irit.nth(srfs, 2)
srf3 = irit.nth(srfs, 3)
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
irit.snoc(
irit.seval(srf1, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))) +
irit.seval(srf2, irit.FetchRealObject(irit.coord(pt, 3)),
irit.FetchRealObject(irit.coord(pt, 4))), retval)
irit.snoc(
irit.seval(srf1, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))) +
irit.seval(srf3, irit.FetchRealObject(irit.coord(pt, 5)),
irit.FetchRealObject(irit.coord(pt, 6))), retval)
irit.snoc(
irit.seval(srf2, irit.FetchRealObject(irit.coord(pt, 3)),
irit.FetchRealObject(irit.coord(pt, 4))) +
irit.seval(srf3, irit.FetchRealObject(irit.coord(pt, 5)),
irit.FetchRealObject(irit.coord(pt, 6))), retval)
i = i + 1
return retval
def positionasymptotes(srf, u, v):
retval = irit.nil()
p = irit.seval(srf, u, v)
k = irit.sasympeval(srf, u, v, 1)
i = 1
while (i <= irit.SizeOf(k)):
irit.snoc(
p + irit.coerce(
irit.coerce(p, irit.POINT_TYPE) + irit.nth(k, i), irit.E3),
retval)
i = i + 1
irit.adwidth(retval, 2)
irit.color(retval, irit.GREEN)
return retval
def evaloneflecnodalvecs(srf, pts, size):
retval = irit.nil()
dusrf = irit.sderive(srf, irit.COL)
dvsrf = irit.sderive(srf, irit.ROW)
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
vec = irit.coerce( irit.seval( dusrf,
irit.FetchRealObject(irit.coord( pt, 1 )),
irit.FetchRealObject(irit.coord( pt, 2 )) ), irit.VECTOR_TYPE ) * \
irit.coord( pt, 3 ) + \
irit.coerce( irit.seval( dvsrf,
irit.FetchRealObject(irit.coord( pt, 1 )),
irit.FetchRealObject(irit.coord( pt, 2 )) ), irit.VECTOR_TYPE ) * \
irit.coord( pt, 4 )
vec = irit.normalizeVec(vec) * size
pt = irit.seval(srf, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2)))
irit.snoc(
pt + irit.coerce(irit.coerce(pt, irit.POINT_TYPE) + vec, irit.E3),
retval)
i = i + 1
return retval
def evaltoeuclidean(srf, paramumb):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(paramumb)):
umb = irit.nth(paramumb, i)
crvtr = irit.scrvtreval(srf, irit.FetchRealObject(irit.coord(umb, 0)),
irit.FetchRealObject(irit.coord(umb, 1)), 1)
irit.printf(
"principal curvatures at (u, v) = (%f, %f) equal %.9f and %.9f\n",
irit.list(irit.coord(umb, 0), irit.coord(umb, 1),
irit.nth(crvtr, 1), irit.nth(crvtr, 3)))
irit.snoc(
irit.seval(srf, irit.FetchRealObject(irit.coord(umb, 0)),
irit.FetchRealObject(irit.coord(umb, 1))), retval)
i = i + 1
irit.color(retval, irit.YELLOW)
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 silandsilinfl(s, v):
sil = irit.silhouette(s, v, 1)
irit.color(sil, irit.YELLOW)
pts = irit.ssilinfl(s, v, 0.01, (-1e-010))
e3pts = irit.nil()
i = 1
while (i <= irit.SizeOf(pts)):
p = irit.nth(pts, i)
irit.snoc(
irit.coerce(
irit.seval(s, irit.FetchRealObject(irit.coord(p, 0)),
irit.FetchRealObject(irit.coord(p, 1))), irit.E3),
e3pts)
i = i + 1
irit.color(e3pts, irit.CYAN)
irit.printf("detected %d silhouette high order contact points.\n",
irit.list(irit.SizeOf(e3pts)))
view_mat_sil = viewmatfromviewdir(v)
retval = irit.list(e3pts, sil, view_mat_sil)
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
irit.ctlpt( irit.E3, 0.4, 0, 0.1 ), \
irit.ctlpt( irit.E3, (-0.5 ), 1, 0 ) ), irit.list( \
irit.ctlpt( irit.E3, 0, (-0.7 ), 0.1 ), \
irit.ctlpt( irit.E3, 0, 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0.7, (-0.2 ) ) ), irit.list( \
irit.ctlpt( irit.E3, 0.5, (-1 ), 0.1 ), \
irit.ctlpt( irit.E3, (-0.4 ), 0, 0 ), \
irit.ctlpt( irit.E3, 0.5, 1, (-0.2 ) ) ) ) )
irit.color( s1, irit.MAGENTA )
pts = irit.ffptdist( s1, 0, 1000 )
e3pts = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pts ) ):
prmpt = irit.nth( pts, i )
pt = irit.seval( s1, irit.FetchRealObject(irit.coord( prmpt, 0 )), irit.FetchRealObject(irit.coord( prmpt, 1 ) ))
irit.snoc( pt, e3pts )
i = i + 1
irit.interact( irit.list( e3pts, s1 ) )
irit.save( "ffptdst5", irit.list( e3pts, s1 ) )
pts = irit.ffptdist( s1, 1, 1000 )
e3pts = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pts ) ):
prmpt = irit.nth( pts, i )
pt = irit.seval( s1, irit.FetchRealObject(irit.coord( prmpt, 0 )), irit.FetchRealObject(irit.coord( prmpt, 1 ) ))
irit.snoc( pt, e3pts )
i = i + 1
irit.interact( irit.list( e3pts, s1 ) )
irit.viewstate("dsrfmesh", 1)
irit.interact(irit.list(irit.GetAxes(), s, dus, dvs))
irit.viewstate("dsrfmesh", 0)
ns = irit.snrmlsrf(s) * irit.scale((0.3, 0.3, 0.3))
irit.color(ns, irit.GREEN)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), s, ns))
# Compute the normal at the center of the surface, in three ways.
irit.save(
"nrml1srf",
irit.list(
irit.GetAxes(), s, ns, dus, dvs,
irit.coerce(irit.seval(dus, 0.5, 0.5), irit.VECTOR_TYPE)
^ irit.coerce(irit.seval(dvs, 0.5, 0.5), irit.VECTOR_TYPE),
irit.coerce(irit.seval(ns, 0.5, 0.5), irit.VECTOR_TYPE),
irit.snormal(s, 0.5, 0.5)))
#
# A (portion of) sphere (rational surface).
#
halfcirc = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 0, 0, 1 ), \
irit.ctlpt( irit.P3, s45, (-s45 ), 0, s45 ), \
irit.ctlpt( irit.P3, 1, (-1 ), 0, 0 ), \
irit.ctlpt( irit.P3, s45, (-s45 ), 0, (-s45 ) ), \
irit.ctlpt( irit.P3, 1, 0, 0, (-1 ) ) ), irit.list( 0, 0, 0, 1, 1, 2,\
2, 2 ) )
irit.color(halfcirc, irit.WHITE)
irit.free(cbo)
sbo = irit.offset(sb, irit.GenRealObject(0.2), 0.1, 0)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), sb, sbo))
irit.free(sbo)
#
# Surface and Curve evaluation.
#
irit.save(
"bspline2",
irit.list(irit.ceval(cb, 0), irit.ceval(cb, 0.1), irit.ceval(cb, 0.3),
irit.ceval(cb, 0.5), irit.ceval(cb, 0.9), irit.ceval(cb, 1),
irit.seval(sb, 1, 3), irit.seval(sb, 1.1, 3),
irit.seval(sb, 1.3, 3), irit.seval(sb, 1.5, 3.5),
irit.seval(sb, 1.9, 3.1), irit.seval(sb, 1, 4),
irit.seval(sb, 1.5, 4)))
#
#
# Surface and Curve tangents.
#
irit.save(
"bspline3",
irit.list(irit.ctangent(cb, 0, 1), irit.ctangent(cb, 0.1, 1),
irit.ctangent(cb, 0.3, 1), irit.ctangent(cb, 0.5, 1),
irit.ctangent(cb, 0.9, 1), irit.ctangent(cb, 1, 1),
irit.stangent(sb, irit.ROW, 1, 3, 1),
irit.list(0, 1))) == irit.blossom(
s1,
irit.list(irit.list(2, 1),
irit.list(1, 0))),
irit.blossom(s1, irit.list(irit.list(4, 5),
irit.list(0, 1))) == irit.blossom(
s1,
irit.list(irit.list(5, 4),
irit.list(1, 0))),
irit.blossom(s1, irit.list(irit.list(3, 2),
irit.list(1, 1))) == irit.blossom(
s1,
irit.list(irit.list(2, 3),
irit.list(1, 1))),
irit.blossom(s1, irit.list(irit.list(3.5, 3.5),
irit.list(0, 0))) == irit.seval(s1, 3.5, 0),
irit.blossom(s1,
irit.list(irit.list(1.1, 1.1),
irit.list(0.5,
0.5))) == irit.seval(s1, 1.1, 0.5),
irit.blossom(s1, irit.list(irit.list(4.7, 4.7),
irit.list(1, 1))) == irit.seval(s1, 4.7, 1),
irit.blossom(s1, irit.list(irit.list(3, 3),
irit.list(0.7,
0.7))) == irit.seval(s1, 3, 0.7),
irit.blossom(s1, irit.list(irit.list(0.3, 0.3),
irit.list(0, 0))) == irit.seval(s1, 0.3,
0)))
# ############################################################################
# 10-13. Two different intersection curves that are very close to each other.
# Intersection between two biquadratic Bezier saddle like surfaces.
# In the last example of this sequence, the surfaces are tangent at
# 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)
printtest("coerce",
irit.meval(irit.coerce(mv1, irit.KV_OPEN), irit.list(0, 0, 0)),
irit.meval(mv1, irit.list(0, 0, 0)))
printtest("coerce",
irit.meval(irit.coerce(mv1, irit.KV_OPEN), irit.list(1, 1, 1)),
irit.meval(mv1, irit.list(1, 1, 1)))
printtest("pdomain", irit.pdomain(mc), irit.pdomain(c))
printtest("pdomain", irit.pdomain(ms), irit.pdomain(s))
printtest("pdomain", irit.pdomain(mt), irit.pdomain(t))
printtest("meval", irit.meval(mc, irit.list(0.3)), irit.ceval(c, 0.3))
printtest("meval", irit.meval(mc, irit.list(0.65)), irit.ceval(c, 0.65))
printtest("meval", irit.meval(ms, irit.list(0.3, 0.7)),
irit.seval(s, 0.3, 0.7))
printtest("meval", irit.meval(ms, irit.list(0.65, 0.21)),
irit.seval(s, 0.65, 0.21))
printtest("meval", irit.meval(ms3, irit.list(0.65, 0.21)),
irit.seval(s3, 0.65, 0.21))
printtest("meval", irit.meval(mt, irit.list(0.123, 0.456, 0.789)),
irit.teval(t, 0.123, 0.456, 0.789))
printtest("meval", irit.meval(mt, irit.list(0.321, 0.987, 0.654)),
irit.teval(t, 0.321, 0.987, 0.654))
printtest("mfrommv", irit.csurface(s, irit.COL, 0.22),
irit.coerce(irit.mfrommv(ms, 0, 0.22), irit.CURVE_TYPE))
printtest("mfrommv", irit.csurface(s, irit.ROW, 0.672),
irit.coerce(irit.mfrommv(ms, 1, 0.672), irit.CURVE_TYPE))
printtest("mfrommv", irit.csurface(s3, irit.ROW, 0.872),
irit.coerce(irit.mfrommv(ms3, 1, 0.872), irit.CURVE_TYPE))
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), cb, cbo))
sbo = irit.offset(sb, irit.GenRealObject(0.2), 0.1, 0)
if (display == 1):
irit.interact(irit.list(irit.GetAxes(), sb, sbo))
#
# Surface and Curve evaluation.
#
irit.save(
"bezier2",
irit.list(irit.ceval(cb, 0), irit.ceval(cb, 0.1), irit.ceval(cb, 0.3),
irit.ceval(cb, 0.5), irit.ceval(cb, 0.9), irit.ceval(cb, 1),
irit.seval(sb, 0, 0), irit.seval(sb, 0.1, 0),
irit.seval(sb, 0.3, 0), irit.seval(sb, 0.5, 0.5),
irit.seval(sb, 0.9, 0.1), irit.seval(sb, 1, 1)))
#
# Surface and Curve tangents.
#
irit.save(
"bezier3",
irit.list(irit.ctangent(cb, 0, 1), irit.ctangent(cb, 0.1, 1),
irit.ctangent(cb, 0.3, 1), irit.ctangent(cb, 0.5, 1),
irit.ctangent(cb, 0.9, 1), irit.ctangent(cb, 1, 1),
irit.stangent(sb, irit.ROW, 0, 0, 1),
irit.stangent(sb, irit.COL, 0.1, 0, 1),
irit.stangent(sb, irit.ROW, 0.3, 0, 1),
irit.ctlpt( irit.E3, (-1 ), 1, 0 ), \
irit.ctlpt( irit.E3, 1, (-1 ), 0 ) + \
irit.ctlpt( irit.E3, 1, 1, 0 ) )
irit.color(pln, irit.RED)
pts = irit.saccess(pln, irit.GenRealObject(0), psphere, irit.GenRealObject(0),
0.1, 1e-005)
spts = irit.nil()
sptserr = irit.nil()
i = 1
while (i <= irit.SizeOf(pts)):
pt = irit.nth(pts, i)
err = irit.FetchRealObject(irit.getattr(pt, "rngerror"))
if (err > 1e-005):
irit.snoc(irit.seval(pln, irit.coord(pt, 1), irit.coord(pt, 2)),
sptserr)
else:
irit.snoc(
irit.seval(pln, irit.FetchRealObject(irit.coord(pt, 1)),
irit.FetchRealObject(irit.coord(pt, 2))), spts)
i = i + 1
irit.color(spts, irit.GREEN)
irit.color(sptserr, irit.RED)
all = irit.list(psphere, pln, spts, sptserr)
irit.save("saccess1", all)
irit.interact(all)
pts = irit.saccess(pln, irit.GenRealObject(0), psphere, irit.GenRealObject(0),
0.1, 1e-005)
irit.color(tv2s1, irit.RED)
tv2s2 = irit.strivar(tv2, irit.ROW, 0.5)
irit.color(tv2s2, irit.GREEN)
tv2s3 = irit.strivar(tv2, irit.DEPTH, 0.6)
irit.color(tv2s3, irit.CYAN)
save_res = irit.GetResolution()
irit.SetResolution(2)
tv2poly = irit.gpolyline(tv2, 0)
irit.SetResolution(save_res)
irit.interact(irit.list(tv2poly, tv2s1, tv2s2, tv2s3))
irit.save(
"trivar5",
irit.list(tv2poly, tv2s1, tv2s2, tv2s3, irit.teval(tv1, 0.77, 0.375, 0.31),
irit.teval(tv2, 0.4, 0.5, 0.6), irit.seval(tv1s1, 0.375, 0.31),
irit.seval(tv1s2, 0.77, 0.31), irit.seval(tv1s3, 0.77, 0.375),
irit.seval(tv2s1, 0.5, 0.6), irit.seval(tv2s2, 0.4, 0.6),
irit.seval(tv2s3, 0.4, 0.5)))
irit.free(tv1s1)
irit.free(tv1s2)
irit.free(tv1s3)
irit.free(tv2s1)
irit.free(tv2s2)
irit.free(tv2s3)
#
# Subdivision
#
s1 = subdivtodepth(tsrf3a, 4, irit.vector(0, 0.04, 0), irit.vector(0.02, 0, 0))
irit.interact(s1)
s2 = subdivtodepth(tsrf3a, 8, irit.vector(0, 0.01, 0),
irit.vector(0.005, 0, 0))
irit.interact(s2)
irit.save("trimsrf6", irit.list(s1, s2))
offtsrf3a = irit.offset(tsrf3a, irit.GenRealObject(0.3), 1, 0)
irit.interact(irit.list(offtsrf3a, tsrf3a))
irit.save(
"trimsrf7",
irit.list(offtsrf3a, tsrf3a, irit.seval(tsrf1a, 0.5, 0.5),
irit.stangent(tsrf1a, irit.ROW, 0.5, 0.5, 1),
irit.stangent(tsrf1a, irit.COL, 0.5, 0.5, 1),
irit.snormal(tsrf1a, 0.5, 0.5), irit.seval(tsrf3a, 0.5, 0.5),
irit.stangent(tsrf3a, irit.ROW, 0.5, 0.5, 1),
irit.stangent(tsrf3a, irit.COL, 0.5, 0.5, 1),
irit.snormal(tsrf3a, 0.5, 0.5)))
irit.interact(irit.strimsrf(tsrf1a))
irit.interact(irit.ctrimsrf(tsrf1a, 1))
irit.interact(irit.ctrimsrf(tsrf3a, 0))
irit.save(
"trimsrf8",
irit.list(irit.pdomain(tsrf1a), irit.pdomain(tsrf3b),
irit.strimsrf(tsrf1a), irit.ctrimsrf(tsrf1a, 1)))
all1 = irit.list(srf1, uvpos2pt(srf1, irit.point(0.2, (-0.1), 0.8), 1),
uvpos2pt(srf1, irit.point(0.1, 0, (-0.1)), 1),
uvpos2pt(srf1, irit.point((-0.2), (-0.4), 0.4), 1),
uvpos2pt(srf1, irit.point(0.6, 0.2, 0.3), 1))
irit.interact(all1)
all2 = irit.list(srf1, uvpos2pt(srf1, irit.point(0.2, (-0.1), 0.8), 0),
uvpos2pt(srf1, irit.point(0.1, 0, (-0.1)), 0),
uvpos2pt(srf1, irit.point((-0.2), (-0.4), 0.4), 0),
uvpos2pt(srf1, irit.point(0.6, 0.2, 0.3), 0))
irit.interact(all2)
irit.save("srf2dist", irit.list(all1, all2))
all1 = irit.list(srf1, uvpos2pt(srf1, irit.seval(srf1, 0.2, 0.3), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.3, 0.1), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.4, 0.2), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.5, 0.8), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.8, 0.9), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.1, 0.1), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.9, 0.9), 1),
uvpos2pt(srf1, irit.seval(srf1, 0.01, 0.99), 1))
irit.interact(all1)
irit.save("srf3dist", all1)
# ############################################################################
crv = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, 1.7, (-1.7 ) ), \
irit.ctlpt( irit.E2, 1.3, 1.4 ), \
