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 evalantipodalptsoncrv(crv):
aps = irit.antipodal(crv, 0.001, (-1e-010))
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)
t1 = irit.coord(ap, 1)
t2 = irit.coord(ap, 2)
pt1 = irit.ceval(crv, irit.FetchRealObject(t1))
pt2 = irit.ceval(crv, irit.FetchRealObject(t2))
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 getbisectpt( crv1, crv2, pt ):
pt1 = irit.ceval( crv1, irit.FetchRealObject(irit.coord( pt, 0 ) ))
pt2 = irit.ceval( crv2, irit.FetchRealObject(irit.coord( pt, 1 ) ))
nrml1 = irit.cnormalplnr( crv1, irit.FetchRealObject(irit.coord( pt, 0 ) ))
nrml2 = irit.cnormalplnr( crv2, irit.FetchRealObject(irit.coord( pt, 1 ) ))
interpts = irit.ptslnln( irit.coerce( pt1, irit.POINT_TYPE ), nrml1, irit.coerce( pt2, irit.POINT_TYPE ), nrml2 )
retval = irit.nth( interpts, 1 )
return retval
def genanimationorthomatchcrvpts(ppl, crv, scl):
pt1 = irit.point(0, 0, 0)
pt2 = irit.point(0, 0, 0)
vec1 = ( irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 0, scl ) )
irit.color(vec1, irit.YELLOW)
vec2 = ( \
irit.ctlpt( irit.E2, 0, 0 ) + \
irit.ctlpt( irit.E2, 0, scl ) )
irit.color(vec2, irit.CYAN)
pos1 = irit.nil()
pos2 = irit.nil()
rot1 = irit.nil()
rot2 = irit.nil()
i = 0
while (i <= irit.SizeOf(ppl) - 1):
pl = irit.coord(ppl, i)
j = 0
while (j <= irit.SizeOf(pl) - 1):
pt = irit.coord(pl, j)
t1 = irit.coord(pt, 0)
t2 = irit.coord(pt, 1)
if (t1 > t2):
irit.snoc(
irit.coerce(irit.ceval(crv, irit.FetchRealObject(t1)),
irit.POINT_TYPE), pos1)
irit.snoc(
irit.coerce(irit.ceval(crv, irit.FetchRealObject(t2)),
irit.POINT_TYPE), pos2)
n1 = irit.cnormal(crv, irit.FetchRealObject(t1))
n2 = irit.cnormal(crv, irit.FetchRealObject(t2))
irit.snoc(
irit.vector(
math.atan2(irit.FetchRealObject(irit.coord(n1, 0)),
irit.FetchRealObject(irit.coord(n1, 1))) *
180 / math.pi, 0, 0), rot1)
irit.snoc(
irit.vector(
math.atan2(irit.FetchRealObject(irit.coord(n2, 0)),
irit.FetchRealObject(irit.coord(n2, 1))) *
180 / math.pi, 0, 0), rot2)
j = j + 1
if (t1 > t2):
irit.snoc(irit.vector(10000, 0, 0), pos1)
irit.snoc(irit.vector(10000, 0, 0), pos2)
irit.snoc(irit.vector(0, 0, 0), rot1)
irit.snoc(irit.vector(0, 0, 0), rot2)
i = i + 1
irit.attrib(pt1, "animation", makerottransanimobj(irit.nil(), pos1))
irit.attrib(pt2, "animation", makerottransanimobj(irit.nil(), pos2))
irit.attrib(vec1, "animation", makerottransanimobj(rot1, pos1))
irit.attrib(vec2, "animation", makerottransanimobj(rot2, pos2))
retval = irit.list(pt1, pt2, vec1, vec2)
return retval
def getbisectcrv( crv1, crv2, cntr ):
ptlist = irit.nil( )
i = 0
while ( i <= irit.SizeOf( cntr ) - 1 ):
pt = irit.coord( cntr, i )
pt1 = irit.ceval( crv1, irit.coord( pt, 0 ) )
pt2 = irit.ceval( crv2, irit.coord( pt, 1 ) )
nrml1 = irit.cnormalplnr( crv1, irit.coord( pt, 0 ) )
nrml2 = irit.cnormalplnr( crv2, irit.coord( pt, 1 ) )
interpts = irit.ptslnln( irit.coerce( pt1, irit.POINT_TYPE ), nrml1, irit.coerce( pt2, irit.POINT_TYPE ), nrml2 )
irit.snoc( irit.nth( interpts, 1 ), ptlist )
i = i + 1
retval = irit.cbspline( 2, ptlist, irit.list( irit.KV_OPEN ) )
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 cnvrtcrvs2ranges( crvs, idx, merge ):
retval = irit.nil( )
if ( merge ):
crvs = mergeverticalbndrycrvs( crvs )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
dm = irit.nth( crvs, i )
pt1 = irit.ceval( dm, 0 )
pt2 = irit.ceval( dm, 1 )
rng = irit.list( irit.coord( pt1, 2 ) ) + irit.list( irit.coord( pt2, 2 ) )
irit.attrib( rng, "index", irit.GenRealObject(idx) )
irit.snoc( rng, retval )
i = i + 1
return retval
def displayposnormal(crv, t1, t2, scl, bg_obj):
pt1 = irit.ceval(crv, irit.FetchRealObject(t1))
pt2 = irit.ceval(crv, irit.FetchRealObject(t2))
n1 = irit.cnormal(crv, irit.FetchRealObject(t1))
n2 = irit.cnormal(crv, irit.FetchRealObject(t2))
ptt1 = (irit.ctlpt(irit.E2, t1, t2) + irit.ctlpt(irit.E2, t1, 0))
irit.color(ptt1, irit.YELLOW)
ptt2 = (irit.ctlpt(irit.E2, t1, t2) + irit.ctlpt(irit.E2, 0, t2))
irit.color(ptt2, irit.CYAN)
n1 = (irit.coerce(
irit.coerce(pt1, irit.POINT_TYPE) + n1 * irit.sc(scl), irit.E2) + pt1)
irit.color(n1, irit.YELLOW)
n2 = (irit.coerce(
irit.coerce(pt2, irit.POINT_TYPE) + n2 * irit.sc(scl), irit.E2) + pt2)
irit.color(n2, irit.CYAN)
irit.view(irit.list(n1, n2, pt1, pt2, ptt1, ptt2, bg_obj), irit.ON)
def crvlength(crv, n):
retval = 0
pd = irit.pdomain(crv)
t1 = irit.nth(pd, 1)
t2 = irit.nth(pd, 2)
dt = (t2 - t1) / n
pt1 = irit.coerce(irit.ceval(crv, irit.FetchRealObject(t1)), irit.E3)
i = 1
while (i <= n):
pt2 = irit.coerce(
irit.ceval(crv,
irit.FetchRealObject(t1) +
irit.FetchRealObject(dt) * i), irit.E3)
retval = retval + distptpt(pt1, pt2)
pt1 = pt2
i = i + 1
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 animbisectcrv( 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.coord( pt, 0 ) )
pt2 = irit.ceval( crv2, irit.coord( pt, 1 ) )
nrml1 = irit.cnormalplnr( crv1, irit.coord( pt, 0 ) )
nrml2 = irit.cnormalplnr( crv2, irit.coord( pt, 1 ) )
interpt = irit.nth( irit.ptslnln( irit.coerce( pt1, irit.POINT_TYPE ), nrml1, irit.coerce( pt2, irit.POINT_TYPE ), nrml2 ), 1 )
if ( irit.ThisObject(interpt) == irit.POINT_TYPE ):
irit.color( pt1, irit.GREEN )
irit.color( pt2, irit.GREEN )
irit.color( interpt, irit.WHITE )
irit.view( irit.list( crv1, crv2, pt1, pt2, data, interpt ), irit.ON )
i = i + 1
def getbisectlines( crv1, crv2, cntr, n, start, end ):
if ( start == (-1 ) ):
start = 0
if ( end == (-1 ) ):
end = irit.SizeOf( cntr ) - 1
retval = irit.nil( )
ii = start
while ( ii <= end ):
i = irit.floor( ii )
pt = irit.coord( cntr, i )
pt1 = irit.ceval( crv1, irit.coord( pt, 0 ) )
pt2 = irit.ceval( crv2, irit.coord( pt, 1 ) )
nrml1 = irit.cnormalplnr( crv1, irit.coord( pt, 0 ) )
nrml2 = irit.cnormalplnr( crv2, irit.coord( pt, 1 ) )
interpts = irit.ptslnln( irit.coerce( pt1, irit.POINT_TYPE ), nrml1, irit.coerce( pt2, irit.POINT_TYPE ), nrml2 )
irit.snoc( irit.coerce( pt1, irit.E2 ) + irit.coerce( irit.nth( interpts, 1 ), irit.E2 ) + irit.coerce( pt2, irit.E2 ), retval )
ii = ii + ( end - start - 1 )/n - 1e-005
irit.color( retval, irit.CYAN )
irit.awidth( retval, 0.0001 )
return retval
def displayobjobjhdres( o1, o2, eps, onesided ):
global glbltransx
hdres = irit.hausdorff( o1, o2, eps, onesided )
dist = irit.nth( hdres, 1 )
param1 = irit.nth( hdres, 2 )
if ( onesided ):
dtype = "one sided "
else:
dtype = "two sided "
if ( irit.SizeOf( param1 ) == 0 ):
pt1 = irit.coerce( o1, irit.E3 )
else:
i = 1
while ( i <= irit.SizeOf( param1 ) ):
t = irit.nth( param1, i )
irit.printf( "%shausdorff distance %f detected at t1 = %f\n", irit.list( dtype, dist, t ) )
i = i + 1
pt1 = irit.ceval( o1, irit.FetchRealObject(t) )
param2 = irit.nth( hdres, 3 )
if ( irit.SizeOf( param2 ) == 0 ):
pt2 = irit.coerce( o2, irit.E3 )
else:
i = 1
while ( i <= irit.SizeOf( param2 ) ):
t = irit.FetchRealObject(irit.nth( param2, i ))
irit.printf( "%shausdorff distance %f detected at t2 = %f\n", irit.list( dtype, dist, t ) )
i = i + 1
pt2 = irit.ceval( o2, t )
irit.color( pt1, irit.MAGENTA )
irit.color( o1, irit.MAGENTA )
irit.color( pt2, irit.YELLOW )
irit.color( o2, irit.YELLOW )
l = ( pt1 + pt2 )
if ( onesided == 0 ):
irit.attrib( l, "dwidth", irit.GenIntObject(3 ))
all = irit.list( o1, o2, pt1, pt2, l )
irit.snoc( all * irit.tx( glbltransx ), glblres )
glbltransx = ( glbltransx + 0.5 )
irit.interact( all )
def lj8samplecurve(crv, n):
ptl = irit.nil()
t0 = irit.nth(irit.pdomain(crv), 1)
t1 = irit.nth(irit.pdomain(crv), 2)
if (n < 2):
n = 2
dt = (t1 - t0) / (n + 0.0001 - 1)
t = t0
while (t <= t1):
pt = irit.ceval(crv, irit.FetchRealObject(t))
irit.snoc(pt, ptl)
t = t + dt
retval = ptl
return retval
def tagcurve(crv, n, len):
tmin = irit.FetchRealObject(irit.coord(irit.pdomain(crv), 1))
tmax = irit.FetchRealObject(irit.coord(irit.pdomain(crv), 2))
dt = (tmax - tmin) / float(n - 1)
retval = irit.nil()
t = tmin
i = 1
while (i <= n):
pt = irit.coerce(irit.ceval(crv, t), irit.POINT_TYPE)
nrml = irit.coerce(irit.cnormal(crv, t), irit.VECTOR_TYPE)
irit.snoc(
irit.coerce(pt - nrml * len, irit.E2) +
irit.coerce(pt + nrml * len, irit.E2), retval)
t = t + dt
i = i + 1
return retval
def interptseval(crvs):
retval = irit.nil()
i = 1
while (i <= irit.SizeOf(crvs)):
crv = irit.nth(crvs, i)
interpts = irit.getattr(crv, "interpts")
j = 1
while (j <= irit.SizeOf(interpts)):
irit.snoc(
irit.ceval(crv, irit.FetchRealObject(irit.nth(interpts, j))),
retval)
j = j + 1
i = i + 1
irit.printf("numer of intersections detected = %d\n",
irit.list(irit.SizeOf(retval)))
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 canonicalh(f, g, deg, c, ptype):
net = irit.nil()
t = irit.ceval(g, 1)
g2 = g * irit.sc(1 / irit.FetchRealObject(irit.coord(t, 1)))
f2 = irit.cregion(f, 0, irit.FetchRealObject(irit.coord(t, 1)))
f_p = irit.coerce(f2, irit.POWER_TYPE)
tmp = irit.ffsplit(f_p)
i = 1
while (i <= c):
bm = irit.coord(irit.coord(irit.nth(tmp, i), deg), 1)
tmp2 = irit.coerce(irit.nth(tmp, i), irit.BEZIER_TYPE) * irit.sc(
1 / irit.FetchRealObject(bm))
irit.snoc(
irit.coerce(irit.coerce(irit.compose(tmp2, g2), irit.BEZIER_TYPE),
irit.E1), net)
i = i + 1
retval = irit.ffmerge(net, ptype)
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 comparecurvaturecrvevals(c):
c = irit.coerce(c, irit.KV_OPEN)
tmin = irit.FetchRealObject(irit.nth(irit.pdomain(c), 1))
tmax = irit.FetchRealObject(irit.nth(irit.pdomain(c), 2))
t = tmin
dt = (tmax - tmin) / 100.0
crvtrcrv = irit.cnrmlcrv(c)
while (t <= tmax):
kn = irit.ceval(crvtrcrv, t)
k1 = math.sqrt(
irit.FetchRealObject(
irit.coerce(kn, irit.VECTOR_TYPE) *
irit.coerce(kn, irit.VECTOR_TYPE)))
k2 = irit.FetchRealObject(irit.ccrvtreval(c, t))
if (abs(k1 - k2) > 1e-05):
irit.printf(
"mismatch in curve curvature evaluation (%.13f vs. %.13f)\n",
irit.list(k1, k2))
t = t + dt
def checktangenteval(c):
dc = irit.cderive(c)
retval = (irit.ctangent(c, 0, 0) == irit.coerce(irit.ceval(
dc, 0), irit.VECTOR_TYPE)) & (irit.ctangent(c, 0.1, 0) == irit.coerce(
irit.ceval(dc, 0.1),
irit.VECTOR_TYPE)) & (irit.ctangent(c, 0.3, 0) == irit.coerce(
irit.ceval(dc, 0.3), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 0.5, 0) == irit.coerce(irit.ceval(
dc, 0.5), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 0.9, 0) == irit.coerce(irit.ceval(
dc, 0.9), irit.VECTOR_TYPE)) & (irit.ctangent(
c, 1, 0) == irit.coerce(
irit.ceval(dc, 1), irit.VECTOR_TYPE))
return retval
def raytraptris(crvs, subeps, numeps):
pts = irit.raytraps(crvs, 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(crvs)):
irit.snoc(
irit.ceval(irit.nth(crvs, j),
irit.FetchRealObject(irit.coord(pt, j))), points)
j = j + 1
irit.snoc(irit.poly(points, 0), retval)
i = i + 1
return retval
#
# Some examples for curves.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E2, (-1 ), 0 ), \
irit.ctlpt( irit.E2, (-1 ), 0.1 ), \
irit.ctlpt( irit.E2, (-0.9 ), (-0.1 ) ), \
irit.ctlpt( irit.E2, 0.9, 0 ) ) )
irit.color( c1, irit.MAGENTA )
pts = irit.ffptdist( c1, 0, 1000 )
e2pts = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pts ) ):
pt = irit.ceval( c1, irit.FetchRealObject(irit.coord( irit.nth( pts, i ), 0 ) ))
irit.snoc( pt, e2pts )
i = i + 10
irit.interact( irit.list( e2pts, c1 ) )
irit.save( "ffptdst1", irit.list( e2pts, c1 ) )
pts = irit.ffptdist( c1, 1, 1000 )
e2pts = irit.nil( )
i = 1
while ( i <= irit.SizeOf( pts ) ):
pt = irit.ceval( c1, irit.FetchRealObject(irit.coord( irit.nth( pts, i ), 0 ) ))
irit.snoc( pt, e2pts )
i = i + 10
irit.interact( irit.list( e2pts, c1 ) )
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()
p = (0, 1, 0)
t1c0 = irit.crvpttan(c0, p, 0.01)
i = 1
while (i <= irit.SizeOf(t1c0)):
irit.viewobj(
irit.ceval(c0, irit.FetchRealObject(irit.nth(t1c0, i))) +
irit.coerce(irit.point(p[0], p[1], p[2]), irit.E3))
i = i + 1
irit.viewobj(irit.list(p, c0))
irit.pause()
irit.viewclear()
p = (1, 1, 0)
t1c1 = irit.crvpttan(c1, p, 0.01)
i = 1
while (i <= irit.SizeOf(t1c1)):
irit.viewobj(
irit.ceval(c1, irit.FetchRealObject(irit.nth(t1c1, i))) +
irit.coerce(irit.point(p[0], p[1], p[2]), irit.E3))
i = i + 1
irit.viewobj(irit.list(p, c1))
# A piecewise linear curve
#
c = irit.cbspline( 2, irit.list( irit.ctlpt( irit.E2, (-0.227 ), 0.243 ), \
irit.ctlpt( irit.E2, (-0.0522 ), 0.203 ), \
irit.ctlpt( irit.E2, (-0.151 ), (-0.0858 ) ), \
irit.ctlpt( irit.E2, (-0.142 ), (-0.219 ) ), \
irit.ctlpt( irit.E2, (-0.00121 ), (-0.288 ) ), \
irit.ctlpt( irit.E2, 0.125, (-0.21 ) ), \
irit.ctlpt( irit.E2, 0.143, (-0.0708 ) ), \
irit.ctlpt( irit.E2, 0.0448, 0.203 ), \
irit.ctlpt( irit.E2, 0.105, 0.216 ), \
irit.ctlpt( irit.E2, 0.218, 0.241 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.sc( 3 )
# d is a piecewise points curve and so is drawn as a control polygon, dp.
d = irit.duality(irit.coerce(c, irit.KV_OPEN))
dp = irit.getctlpolygon(d + irit.ceval(d, 0))
irit.color(dp, irit.YELLOW)
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"))
mov_xyz2 = d * irit.tx(0)
irit.attrib(pt2, "animation", mov_xyz2)
all = irit.list(c, dp, pt1, pt2) * irit.sc(0.5) * irit.tx((-0.2))
irit.interact(all)
irit.ctlpt( irit.E2, 0.17, (-0.13 ) ), \
irit.ctlpt( irit.E2, (-0.03 ), 0.7 ), \
irit.ctlpt( irit.E2, (-0.8 ), 0.7 ), \
irit.ctlpt( irit.E2, (-0.8 ), (-0.7 ) ), \
irit.ctlpt( irit.E2, (-0.03 ), (-0.7 ) ), \
irit.ctlpt( irit.E2, 0.17, 0.13 ), \
irit.ctlpt( irit.E2, 0.7, (-0.6 ) ) ), irit.list( irit.KV_OPEN ) )
irit.color(c, irit.RED)
irit.view(irit.list(irit.GetAxes(), c), irit.ON)
allcntrs = irit.nil()
x = (-0.7)
while (x <= 0.7):
cntrpts = irit.contour(c, irit.plane(1, 0, 0, x))
cntr = irit.ceval( c, irit.FetchRealObject(irit.coord( irit.coord( cntrpts, 0 ), 0 ) )) + \
irit.ceval( c, irit.FetchRealObject(irit.coord( irit.coord( cntrpts, 1 ), 0 ) ))
irit.viewobj(cntr)
irit.milisleep(50)
irit.snoc(cntr * irit.tx(0), allcntrs)
x = x + 0.1
irit.view(irit.list(irit.GetAxes(), c, allcntrs), irit.ON)
irit.save("contour3", irit.list(irit.GetAxes(), x, allcntrs))
irit.free(c)
irit.free(allcntrs)
irit.free(cntrpts)
irit.free(cntr)
# ############################################################################
crv2 = irit.cbspline( 5, irit.list( irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
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))
# Curve point distance.
#
crv1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.5, (-1 ) ), \
irit.ctlpt( irit.E2, (-1.5 ), (-0.5 ) ), \
irit.ctlpt( irit.E2, 1.5, 0 ), \
irit.ctlpt( irit.E2, (-0.5 ), 2 ), \
irit.ctlpt( irit.E2, (-0.5 ), 1 ) ), irit.list( irit.KV_OPEN ) )
irit.color(crv1, irit.GREEN)
irit.attrib(crv1, "width", irit.GenRealObject(0.02))
pt_param = irit.crvptdst(crv1, (0, 0, 0), 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(irit.coerce(pt, irit.VECTOR_TYPE), pt_extrem)
i = i + 1
irit.interact(irit.list(irit.GetAxes(), crv1, pt_extrem))
irit.save("crv1dist", irit.list(irit.GetAxes(), crv1, pt_extrem))
pt_min = irit.ceval(
crv1, irit.FetchRealObject(irit.crvptdst(crv1, (0, 0, 0), 1, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv1, irit.coerce(pt_min, irit.VECTOR_TYPE)))
pt_max = irit.ceval(
crv1, irit.FetchRealObject(irit.crvptdst(crv1, (0, 0, 0), 0, 0.001)))
irit.interact(
irit.list(irit.GetAxes(), crv1, irit.coerce(pt_max, irit.VECTOR_TYPE)))
irit.save(
