def linetancirccirc(x0, y0, r0, x1, y1, r1):
circs = irit.list(irit.circle((x0, y0, 0), r0), irit.circle((x1, y1, 0),
r1))
irit.color(circs, irit.RED)
retval = (circs + linetancirccircaux(x0, y0, r0, x1, y1, r1) +
linetancirccircaux(x0, y0, r0, x1, y1, (-r1)) +
linetancirccircaux(x0, y0, (-r0), x1, y1, (-r1)) +
linetancirccircaux(x0, y0, (-r0), x1, y1, r1))
return retval
def treebranch(pt1, pt2, r):
retval = irit.swpsclsrf( irit.circle( ( 0, 0, 0 ), 1 ),
irit.coerce( pt1, irit.E3 ) + \
irit.coerce( pt2, irit.E3 ),
irit.ctlpt( irit.E2, 0, r ) + \
irit.ctlpt( irit.E2, 1, r * wfactor ), irit.GenRealObject(0), 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 drawcircs(pls):
retval = irit.nil()
i = 0
while (i <= irit.SizeOf(pls) - 1):
v = irit.coord(pls, i)
irit.snoc(
colorcirc(
irit.circle((irit.FetchRealObject(irit.coord(
v, 0)), irit.FetchRealObject(irit.coord(v, 1)), (-1)),
irit.FetchRealObject(irit.coord(v, 2))),
irit.FetchRealObject(irit.coord(v, 2)) > 0), retval)
i = i + 1
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
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
c = irit.circle((0, 0, 0), 2)
comparecurvaturecrvevals(c)
comparecurvaturecrvevals(irit.creparam(c, 0, 1000))
comparecurvaturecrvevals(irit.creparam(c, 0, 0.001))
c = irit.pcircle((0, 0, 0), 0.5)
comparecurvaturecrvevals(c)
comparecurvaturecrvevals(irit.creparam(c, 0, 1000))
comparecurvaturecrvevals(irit.creparam(c, 0, 0.001))
c = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.168 ), 0.794, 0 ), \
irit.ctlpt( irit.E2, (-0.118 ), 0.637 ), \
irit.ctlpt( irit.E2, 0.071, 0.771 ), \
irit.ctlpt( irit.E2, 0.237, 0.691 ), \
irit.ctlpt( irit.E2, (-0.091 ), 0.452 ), \
irit.ctlpt( irit.E2, 0.134, 0.039 ), \
(basexymin, basexymin, 16), (16, basexymin, 16)), irit.FALSE)
irit.color(wall1, irit.WHITE)
irit.attrib(wall1, "rgb", irit.GenStrObject("255,255,255"))
irit.color(wall2, irit.WHITE)
irit.attrib(wall2, "rgb", irit.GenStrObject("255,255,255"))
backgrd = irit.list(base, wall1, wall2)
irit.free(base)
irit.free(wall1)
irit.free(wall2)
# ############################################################################
# First Morphing Sequence. #
# ############################################################################
srf1 = irit.ruledsrf(irit.circle((0, 0, baselvl + 0.01), 1),
irit.circle((0, 0, baselvl + 0.01), 0.01))
irit.color(srf1, irit.YELLOW)
bcross = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, (-0.71 ) ), \
irit.ctlpt( irit.E3, 0.2, 0, (-0.72 ) ), \
irit.ctlpt( irit.E3, 0.25, 0, (-0.7 ) ), \
irit.ctlpt( irit.E3, 0.25, 0, (-0.1 ) ), \
irit.ctlpt( irit.E3, 0.2, 0, (-0.05 ) ), \
irit.ctlpt( irit.E3, 0.15, 0, 0 ), \
irit.ctlpt( irit.E3, 0.1, 0, 0.6 ), \
irit.ctlpt( irit.E3, 0.11, 0, 0.61 ), \
irit.ctlpt( irit.E3, 0.12, 0, 0.61 ), \
irit.ctlpt( irit.E3, 0.12, 0, 0.65 ), \
irit.ctlpt( irit.E3, 0.09, 0, 0.65 ), \
irit.ctlpt( irit.E3, 0.07, 0, 0.64 ), \
else:
woodcolor = "244,164,96"
texture = "wood,1"
redcolor = "255,0,0"
graycolor = "70,70,70"
whitecolor = "255,255,255"
blackcolor = "10,10,10"
#
# First Lets create the fuselage.
#
#
# Front part of the fuselage:
#
c1 = irit.circle( ( 0, 0, 0 ), 0.01 ) * irit.roty( 90 ) * irit.trans( ( (-1 ), 0, 0.1 ) )
irit.color( c1, irit.GREEN )
c2 = irit.circle( ( 0, 0, 0 ), 0.025 ) * irit.roty( 90 ) * irit.trans( ( 0, 0, 0.1 ) )
irit.color( c2, irit.GREEN )
c3 = irit.circle( ( 0, 0, 0 ), 0.03 ) * irit.roty( 90 ) * irit.trans( ( 0.1, 0, 0.1 ) )
irit.color( c3, irit.GREEN )
c4 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0.4, 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, 0.283 ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, 0.4 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), 0.283 ), \
irit.ctlpt( irit.P3, 1, 2.5, (-0.4 ), 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ) ), irit.list( 0, 0, 0, 1, 1, 2,\
2, 3, 3, 4, 4, 4 ) ) * irit.trans( ( (-1.5 ), 0, 0 ) )
m1 = (b1 - b2)
irit.free(b1)
irit.free(b2)
irit.interact(irit.list(irit.GetViewMatrix(), m1))
c1 = irit.sphere((0, 0, 0.2), 0.18)
c1 = putrgbonvertices(c1, irit.GenStrObject("0,255,255"))
irit.view(c1, irit.OFF)
m2 = (m1 - c1)
irit.free(m1)
irit.free(c1)
irit.view(m2, irit.ON)
c2 = irit.circle((0.55, 0, 0), 0.12)
c2 = irit.extrude(c2, ((-0.2), 0, 0.2), 0)
c2 = c2 * irit.circpoly((0, 0, 1), (0.55, 0, 0.05), 0.25)
c3 = irit.circle(((-0.55), 0, 0), 0.12)
c3 = irit.extrude(c3, (0.2, 0, 0.2), 0)
c3 = c3 * irit.circpoly((0, 0, 1), ((-0.55), 0, 0.05), 0.25)
c2 = putrgbonvertices(c2, irit.GenStrObject("255,0,255"))
c3 = putrgbonvertices(c3, irit.GenStrObject("255,128,128"))
irit.view(irit.list(c2, c3), irit.OFF)
m3 = (m2 - c2 - c3)
irit.free(m2)
irit.free(c2)
irit.free(c3)
final = irit.convex(m3)
irit.free(m3)
"asect3d5",
irit.list(c1, c2, irit.calphasector(irit.list(c2, c1), 0.1),
irit.calphasector(irit.list(c2, c1), 0.7),
irit.calphasector(irit.list(c2, c1), 1)))
irit.pause()
# ############################################################################
#
# A quadratic Bezier and a (exact rational) ellipse.
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-2 ), 0, (-1 ) ), \
irit.ctlpt( irit.E3, (-3 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-2 ), 0, 1 ) ) )
c2 = irit.circle((0, 0, 0), 1) * irit.sy(2)
c2 = irit.coerce(c2, irit.E3)
irit.color(c1, irit.RED)
irit.adwidth(c1, 3)
irit.color(c2, irit.RED)
irit.adwidth(c2, 3)
t = 0
while (t <= 1):
bisectsrf = irit.calphasector(irit.list(c1, c2), t)
irit.color(bisectsrf, irit.GREEN)
irit.view(irit.list(c1, c2, bisectsrf), irit.ON)
t = t + 0.2
irit.save(
m1 = irit.coerce(irit.mvexplicit(2, "a^2 + b^2 - 1"), irit.BEZIER_TYPE)
m1 = irit.mregion( irit.mregion( m1, 0, (-3 ), 3 ), 1, (-3 ),\
3 )
# (A+1)^2 + B^2 = 1
m2 = irit.coerce(irit.mvexplicit(2, "a^2 + 2 * a + 1 + b^2 - 1"),
irit.BEZIER_TYPE)
m2 = irit.mregion( irit.mregion( m2, 0, (-3 ), 3 ), 1, (-3 ),\
3 )
z = irit.mzero(irit.list(m1, m2), 0.001, 1e-010) * irit.sc(6) * irit.tx(
(-3)) * irit.ty((-3))
irit.color(z, irit.YELLOW)
irit.interact(
irit.list(irit.circle((0, 0, 0), 1), irit.circle(
((-1), 0, 0), 1), z) * irit.sc(0.6))
# ############################################################################# A^2 + B^2 = 1
m1 = irit.coerce(irit.mvexplicit(2, "a^2 + b^2 - 1"), irit.BEZIER_TYPE)
m1 = irit.mregion( irit.mregion( m1, 0, (-3 ), 3 ), 1, (-3 ),\
3 )
# 4A^2 + B^2/4 = 1
m2 = irit.coerce(irit.mvexplicit(2, "4 * a^2 + b^2 / 4 - 1"), irit.BEZIER_TYPE)
m2 = irit.mregion( irit.mregion( m2, 0, (-3 ), 3 ), 1, (-3 ),\
3 )
z = irit.mzero(irit.list(m1, m2), 0.01, 1e-006) * irit.sc(6) * irit.tx(
(-3)) * irit.ty((-3))
irit.color(z, irit.YELLOW)
#
import math
import irit
#
#
# Combination of a square, triangle, and a circle
#
# Gershon Elber, Feb 2009.
#
#
# The Sqriancle
#
c = irit.circle((0, 0, 0), 1)
stc = irit.ruledsrf(c, c * irit.tz(2) * irit.sx(0.0001))
irit.attrib(stc, "rgb", irit.GenStrObject("255, 200, 200"))
stcisos = irit.getisocurvetubes(stc, 8, 4, 0.03)
irit.attrib(stcisos, "rgb", irit.GenStrObject("25, 20, 200"))
irit.attrib(stcisos, "specilar", irit.GenRealObject(2))
irit.view(irit.list(stc, stcisos), irit.ON)
irit.save("sqriacle", irit.list(stc, stcisos))
irit.pause()
irit.free(c)
irit.free(stc)
irit.free(stcisos)
irit.color( q3, irit.MAGENTA ) irit.printf( "%d cubic segements\n", irit.list( irit.SizeOf( q3 ) ) ) q4 = irit.cubiccrvs( crv, 0.1, (-1 ) ) irit.color( q4, irit.GREEN ) irit.printf( "%d cubic segements\n", irit.list( irit.SizeOf( q4 ) ) ) all = irit.list( crv, q1 * irit.tz( 0.1 ), q2 * irit.tz( 0.2 ), q3 * irit.tz( 0.3 ), q4 * irit.tz( 0.4 ) ) irit.interact( all ) irit.save( "pp6apprx", all ) # ################################ crv = irit.craise( irit.circle( ( 0, 0, 0 ), 0.9 ), 12 ) irit.color( crv, irit.WHITE ) irit.attrib( crv, "width", irit.GenRealObject(0.02 )) q1 = irit.quadcrvs( crv, 0.02, (-1 ) ) irit.color( q1, irit.YELLOW ) irit.printf( "%d quadratic segements\n", irit.list( irit.SizeOf( q1 ) ) ) q2 = irit.quadcrvs( crv, 0.1, (-1 ) ) irit.color( q2, irit.CYAN ) irit.printf( "%d quadratic segements\n", irit.list( irit.SizeOf( q2 ) ) ) q3 = irit.cubiccrvs( crv, 0.02, (-1 ) ) irit.color( q3, irit.MAGENTA ) irit.printf( "%d cubic segements\n", irit.list( irit.SizeOf( q3 ) ) )
irit.color( chaircoverbot, irit.YELLOW )
irit.attrib( chaircoverbot, "texture", irit.GenStrObject("wood" ))
irit.attrib( chaircoverbot, "rgb", irit.GenStrObject("244,164,96" ))
irit.free( chaircover2 )
irit.free( chaircover2a )
irit.free( chaircover2b )
chair = irit.list( chaircovermain, chaircoverbot, chaircovertop )
irit.free( chaircovermain )
irit.free( chaircoverbot )
irit.free( chaircovertop )
#
# Carousel
#
carouseltube = irit.sweepsrf( irit.circle( ( 0, 0, 0 ), 0.01 ), irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 1, 0, 0.2 ), \
irit.ctlpt( irit.E3, 1, 0, 0.02 ), \
irit.ctlpt( irit.E3, 1, 0, 0 ), \
irit.ctlpt( irit.E3, 0.98, 0, 0 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0 ), \
irit.ctlpt( irit.E3, 0, 0, 0.2 ), \
irit.ctlpt( irit.E3, (-0.5 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-0.98 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-1 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-1 ), 0, 0.02 ), \
irit.ctlpt( irit.E3, (-1 ), 0, 0.2 ) ), irit.list( irit.KV_OPEN ) ), irit.GenRealObject(0) )
irit.color( carouseltube, irit.RED )
irit.attrib( carouseltube, "reflect", irit.GenRealObject(0.9 ))
carouselrod1 = irit.list( carouseltube, chairbase * irit.scale( ( 0.35, 0.35, 0.35 ) ) * irit.trans( ( (-0.93 ), 0, 0.03 ) ), chairbase * irit.roty( 90 ) * irit.scale( ( 0.35, 0.35, 0.35 ) ) * irit.trans( ( (-0.98 ), 0, 0.25 ) ), chairbase * irit.scale( ( 0.35, 0.35, 0.35 ) ) * irit.trans( ( (-0.93 ), 0, 0.03 ) ) * irit.rotz( 180 ), chairbase * irit.roty( 90 ) * irit.scale( ( 0.35, 0.35, 0.35 ) ) * irit.trans( ( (-0.98 ), 0, 0.25 ) ) * irit.rotz( 180 ) )
carouselrod2 = carouselrod1 * irit.rotz( 45 )
# Set states.
#
# Faster product using Bezier decomposition.
intrpprod = irit.iritstate("bspprodmethod", irit.GenRealObject(0))
echosrc = irit.iritstate("echosource", irit.GenRealObject(0))
def printtest(title, res, val):
aaa = int(irit.FetchRealObject(irit.nth(res, 1)) == val)
print title + " test - " + str(aaa)
#
# Line
#
line = irit.circle((0.1, 0.7, 3), math.pi)
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0)
line = ( irit.ctlpt( irit.E3, (-2 ), 10, (-5 ) ) + \
irit.ctlpt( irit.E3, 1, (-2 ), 3 ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1)
line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 1, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 1)
line = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 1, (-2 ) ), \
irit.ctlpt( irit.E3, 1, 2, (-2 ) ), \
irit.ctlpt( irit.E3, 4, 1, (-2 ) ) ) )
printtest("line", irit.isgeom(line, irit.GEOM_LINEAR, 1e-010), 0)
#
#
# Some examples of Algebraic sum, including of swung surfaces.
#
# Gershon ELber, May 1998
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.GetViewMatrix() * irit.sc(0.35))
irit.viewobj(irit.GetViewMatrix())
#
# A circle and a line
#
circ = irit.circle((0, 0, 0), 0.7)
c2 = ( irit.ctlpt( irit.E3, (-0.2 ), (-0.5 ), (-1.5 ) ) + \
irit.ctlpt( irit.E3, 0.2, 0.5, 1.5 ) )
irit.color(circ, irit.MAGENTA)
irit.adwidth(circ, 3)
irit.color(c2, irit.GREEN)
irit.adwidth(c2, 3)
as1 = irit.algsum(circ, c2)
irit.color(as1, irit.YELLOW)
irit.interact(irit.list(as1, circ, c2))
as1 = irit.algsum(c2, circ)
irit.color(as1, irit.YELLOW)
irit.interact(irit.list(as1, circ, c2))
irit.color(polytrs, irit.RED)
irit.interact(irit.list(trs, polytrs))
scalecrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.05, 0.25 ), \
irit.ctlpt( irit.E2, 0.1, 0 ), \
irit.ctlpt( irit.E2, 0.2, 0.5 ), \
irit.ctlpt( irit.E2, 0.3, 0 ), \
irit.ctlpt( irit.E2, 0.4, 0.5 ), \
irit.ctlpt( irit.E2, 0.5, 0 ), \
irit.ctlpt( irit.E2, 0.6, 0.5 ), \
irit.ctlpt( irit.E2, 0.7, 0 ), \
irit.ctlpt( irit.E2, 0.8, 0.5 ), \
irit.ctlpt( irit.E2, 0.85, 0.25 ) ), irit.list( irit.KV_OPEN ) )
irit.color(scalecrv, irit.GREEN)
scltrs = irit.swpcircsrf(irit.circle((0, 0, 0), 1), scalecrv, 2)
irit.interact(scltrs)
ctlpts = irit.getctlpoints(scalecrv, 0)
ctlvecs = irit.getctlpoints(scalecrv, 1)
ctlpoly = irit.getctlpolygon(scalecrv)
irit.interact(irit.list(scalecrv, ctlpts, ctlpoly))
irit.interact(irit.list(scalecrv, ctlvecs, ctlpoly))
irit.save("macros2", irit.list(trs, polytrs, ctlpts, ctlvecs, ctlpoly))
scalepoly = irit.cnvrtcrvtopolygon(scalecrv, 50, 1)
irit.color(scalepoly, irit.RED)
irit.interact(irit.list(scalepoly, scalecrv))
ctlpts = irit.getctlmeshpts(trs, 0)
sb1 = irit.sbezier(spts)
sb2 = irit.sbspline(
3, 3, spts, irit.list(irit.list(irit.KV_OPEN), irit.list(irit.KV_OPEN)))
irit.free(spts)
#
# Constructor using TrimSrf
#
tcrv1 = irit.cbspline( 2, irit.list( irit.ctlpt( irit.E2, 0.3, 0.3 ), \
irit.ctlpt( irit.E2, 0.7, 0.3 ), \
irit.ctlpt( irit.E2, 0.7, 0.7 ), \
irit.ctlpt( irit.E2, 0.3, 0.7 ), \
irit.ctlpt( irit.E2, 0.3, 0.3 ) ), irit.list( irit.KV_OPEN ) )
tcrv2 = irit.circle((0.5, 0.5, 0), 0.25)
tcrv3 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.3, 0.3 ), \
irit.ctlpt( irit.E2, 0.7, 0.3 ), \
irit.ctlpt( irit.E2, 0.7, 0.7 ), \
irit.ctlpt( irit.E2, 0.3, 0.7 ) ), irit.list( irit.KV_PERIODIC ) )
tsrf1a = irit.trimsrf(sb1, tcrv1, 0)
irit.color(tsrf1a, irit.CYAN)
irit.interact(tsrf1a)
tsrf1b = irit.trimsrf(sb1, tcrv1, 1) * irit.tz(0.1)
irit.color(tsrf1b, irit.GREEN)
irit.interact(tsrf1b)
tsrf1mesh = irit.list(irit.ffmesh(tsrf1a), irit.ffmesh(tsrf1b))
irit.color(tsrf1mesh, irit.YELLOW)
wgl_prisa = irit.prisa(wglass, samppercrv, 0.1, irit.COL, (0, 0.25, 0), 0)
irit.interact(irit.list(view_mat2d, wgl_prisa))
irit.save("prisa2", irit.list(view_mat2d, wgl_prisa))
irit.free(cross)
irit.free(wglass)
irit.free(wgl_prisa)
irit.free(view_mat2d)
irit.free(view_mat3d)
# ############################################################################
#
# Layout (prisa) Fuselage of b58 model.
#
c1 = irit.circle((0, 0, 0), 0.01) * irit.roty(90) * irit.trans(((-1), 0, 0.1))
c2 = irit.circle((0, 0, 0), 0.025) * irit.roty(90) * irit.trans((0, 0, 0.1))
c3 = irit.circle((0, 0, 0), 0.03) * irit.roty(90) * irit.trans((0.1, 0, 0.1))
c4 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0.4, 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, 0.283 ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, 0.4 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), 0.283 ), \
irit.ctlpt( irit.P3, 1, 2.5, (-0.4 ), 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ) ), irit.list( 0, 0, 0, 1, 1, 2,\
2, 3, 3, 4, 4, 4 ) ) * irit.trans( ( (-1.5 ), 0, 0 ) )
c5 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0.4, 0 ), \
s1 * irit.sc(2) * irit.ry(180) * irit.trans((2, 0, 0)))
irit.color(srfs, irit.RED)
irit.free(s1)
ts1 = irit.tfromsrfs(srfs, 3, irit.KV_FLOAT)
irit.color(ts1, irit.GREEN)
ts2 = irit.tfromsrfs(srfs, 5, irit.KV_OPEN)
irit.color(ts2, irit.YELLOW)
ts3 = irit.tfromsrfs(srfs, 5, irit.KV_PERIODIC)
irit.color(ts3, irit.MAGENTA)
irit.interact(irit.list(srfs, ts1, ts2, ts3))
s2 = irit.ruledsrf(irit.circle((0, 0, 0), 1), irit.circle((0, 0, 0), 0.7))
srfs = irit.list(s2,
s2 * irit.sc(0.5) * irit.tz(0.4), s2 * irit.tz(0.8),
s2 * irit.sc(0.5) * irit.tz(1.2))
irit.color(srfs, irit.RED)
irit.free(s2)
ts1 = irit.tfromsrfs(srfs, 3, irit.KV_FLOAT)
irit.color(ts1, irit.GREEN)
ts2 = irit.tfromsrfs(srfs, 5, irit.KV_OPEN)
irit.color(ts2, irit.YELLOW)
ts3 = irit.tfromsrfs(srfs, 5, irit.KV_PERIODIC)
irit.color(ts3, irit.MAGENTA)
#
c = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, (-0.6 ), (-0.3 ), 0 ), \
irit.ctlpt( irit.E2, 0.6, (-0.3 ) ), \
irit.ctlpt( irit.E2, 0.6, 0.3 ), \
irit.ctlpt( irit.E2, (-0.6 ), 0.3 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.sc( 2 )
d = irit.duality(irit.coerce(c, irit.KV_OPEN))
irit.color(d, irit.YELLOW)
irit.interact(irit.list(c, d))
#
# An exact circle
#
c = irit.circle((0, 0, 0), 1.1)
d = irit.duality(irit.coerce(c, irit.KV_OPEN))
irit.color(d, irit.YELLOW)
irit.interact(irit.list(c, d, irit.GetAxes()))
c1 = irit.pcircle((0, 0, 0), 1.1)
d1 = irit.duality(irit.coerce(c1, irit.KV_OPEN))
irit.color(d1, irit.YELLOW)
irit.interact(irit.list(c, d, c1, d1, irit.GetAxes()))
#
# A piecewise linear curve
#
c = irit.cbspline( 2, irit.list( irit.ctlpt( irit.E2, (-0.227 ), 0.243 ), \
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# A model of a light mill.
#
# Gershon Elber, Dec 1998.
#
circ = irit.cregion(
irit.circle((0, 0, 0), 0.6) * irit.rz(90) * irit.rx(90) * irit.tz(2.1),
0.1, 1.9)
bodysec = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-0.5 ), 0, 0 ), \
irit.ctlpt( irit.E3, (-0.5 ), 0, 0.01 ), \
irit.ctlpt( irit.E3, (-0.1 ), 0, 0.05 ), \
irit.ctlpt( irit.E3, (-0.03 ), 0, 0.3 ), \
irit.ctlpt( irit.E3, (-0.03 ), 0, 0.75 ), \
irit.ctlpt( irit.E3, (-0.1 ), 0, 1 ), \
irit.ctlpt( irit.E3, (-0.1 ), 0, 1.1 ), \
irit.ctlpt( irit.E3, (-0.03 ), 0, 1.2 ), \
irit.ctlpt( irit.E3, (-0.03 ), 0, 1.3 ), \
irit.ctlpt( irit.E3, (-0.04 ), 0, 1.31 ), \
irit.ctlpt( irit.E3, (-0.08 ), 0, 1.32 ), \
irit.ctlpt( irit.E3, (-0.09 ), 0, 1.4 ), \
irit.ctlpt( irit.E3, (-0.08 ), 0, 1.5 ) ), irit.list( irit.KV_OPEN ) ) + (-circ ) + irit.cbspline( 3, irit.list( \
irit.ctlpt( irit.E3, (-0.07 ), 0, 2.7 ), \
irit.ctlpt( irit.E3, (-0.07 ), 0, 2.8 ), \
#
# An object that has three projections of a cross, circle and a square.
#
w = 0.4
cross = ( irit.ctlpt( irit.E3, 1, 0, 0 ) + \
irit.ctlpt( irit.E3, 1, w, 0 ) + \
irit.ctlpt( irit.E3, w, w, 0 ) + \
irit.ctlpt( irit.E3, w, 1, 0 ) + \
irit.ctlpt( irit.E3, 0, 1, 0 ) )
cross = (cross + cross * irit.rz(90) + cross * irit.rz(180) +
cross * irit.rz(270))
s1 = irit.extrude(cross * irit.tz((-2)), (0, 0, 4), 0)
irit.free(cross)
s2 = irit.extrude(irit.circle((0, 0, 0), 0.999) * irit.tz((-2)),
(0, 0, 4), 0) * irit.rx(90)
s = s1 * s2
irit.free(s1)
irit.free(s2)
irit.view(irit.list(irit.GetAxes(), s), irit.ON)
irit.save("crosplug", s)
irit.pause()
irit.free(s)
def snaket( t ):
p = irit.point( 0, 0, 0 )
ct = irit.cbspline( 3, irit.list( p * \
ctx( 0 + t, 1.5 ) * \
irit.ty( 0.22 ),
p * \
ctx( 0 + t, 1.5 ) * \
irit.ty( 0.22 ),
p * \
ctx( 0.3 + t, 1.5 ) * \
irit.ty( 0.17 ) * \
irit.tz( 0.3 ),
p * \
ctx( 2 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 2 ),
p * \
ctx( 4 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 4 ),
p * \
ctx( 6 + t, 1.5 ) * \
irit.ty( (-0.06 ) ) * \
irit.tz( 6 ),
p * \
ctx( 8 + t, 2.5 ) * \
irit.ty( (-0.065 ) ) * \
irit.tz( 8 ),
p * \
ctx( 10 + t, 2.5 ) * \
irit.ty( (-0.07 ) ) * \
irit.tz( 10 ),
p * \
ctx( 12 + t, 2.5 ) * \
irit.ty( (-0.075 ) ) * \
irit.tz( 12 ),
p * \
ctx( 14 + t, 1.5 ) * \
irit.ty( (-0.08 ) ) * \
irit.tz( 14 ),
p * \
ctx( 16 + t, 1.5 ) * \
irit.ty( (-0.09 ) ) * \
irit.tz( 16 ),
p * \
ctx( 18 + t, 1.5 ) *
irit.ty( (-0.1 ) ) *
irit.tz( 18 ),
p * \
irit.ty( (-0.1 ) ) * \
irit.tz( 20 ),
p * \
irit.ty( (-0.1 ) ) * \
irit.tz( 21 ) ),
irit.list( irit.KV_OPEN ) )
c = irit.circle( ( 0, 0, 0 ), 0.36 ) * irit.rz( (-90 ) )
scalecrv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, 0.001 ), \
irit.ctlpt( irit.E2, 0.1, 0.1 ), \
irit.ctlpt( irit.E2, 0.2, 0.4 ), \
irit.ctlpt( irit.E2, 0.3, 0.7 ), \
irit.ctlpt( irit.E2, 0.4, 0.8 ), \
irit.ctlpt( irit.E2, 0.5, 0.9 ), \
irit.ctlpt( irit.E2, 0.6, 0.95 ), \
irit.ctlpt( irit.E2, 0.7, 1 ), \
irit.ctlpt( irit.E2, 0.8, 1 ) ), irit.list( irit.KV_OPEN ) )
s1 = irit.swpsclsrf( c, ct, scalecrv, irit.vector( 0, 1, 0 ), 1 )
irit.attrib( s1, "ptexture", irit.GenStrObject("snake2.gif,1,30" ))
s2 = irit.sfromcrvs( irit.list( c * \
irit.ty( (-0.1 ) ) * \
irit.tz( 21 ),
c * \
irit.ty( (-0.1 ) ) * \
irit.tz( 22 ),
c * \
irit.ty( (-0.14 ) ) * \
irit.sx( 2.2 ) * \
irit.sy( 1.2 ) * \
irit.tz( 23 ),
c * \
irit.ty( (-0.14 ) ) * \
irit.sx( 2.2 ) * \
irit.sy( 1.2 ) * \
irit.tz( 24 ),
c * \
irit.sy( 0.9 ) * \
irit.ty( (-0.1 ) ) * \
irit.sx( 1.2 ) * \
irit.tz( 25 ),
c * \
irit.ty( (-0.1 ) ) * \
irit.sc( 0.001 ) * \
irit.tz( 25 ) ),
3,
irit.KV_OPEN )
irit.attrib( s2, "ptexture", irit.GenStrObject("snake2.gif,1,5" ))
eyes = irit.list( irit.sphere( ( 0.42, (-0.35 ), 24.5 ), 0.1 ), irit.sphere( ( (-0.42 ), (-0.35 ), 24.5 ), 0.1 ) )
irit.color( eyes, irit.BLACK )
retval = irit.list( s1, s2, eyes ) * irit.rx( (-90 ) ) * irit.tz( 0.261 )
return retval
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
doms = dominos(irit.circle((0, 0, 0), 1), 1.5, 0.1)
irit.view(irit.list(irit.GetAxes(), doms), irit.ON)
irit.pause()
irit.save("dominos", doms)
irit.free(doms)
#
# Set a global variable in a function.
#
dumvar = irit.rotx(10)
def modaxes():
dumvar = (1, 2, 3)
retval = dumvar
return retval
irit.save( "functn3", irit.list( crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 30 )/2, \
crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 100 )/2, \
crvlength( irit.circle( ( 0, 0, 0 ), 1 ), 300 )/2, \
dumvar,\
modaxes(), \
dumvar ) )
irit.free(dumvar)
#
# Make sure operator overloading is still valid inside a function:
#
def add(x, y):
retval = (x + y)
return retval
#
# 2D pocketing: rounded pockets with holes
#
pocket4a = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, 0.065, 0.582 ), \
irit.ctlpt( irit.E2, 0.672, 0.546 ), \
irit.ctlpt( irit.E2, 0.901, 0.213 ), \
irit.ctlpt( irit.E2, 0.735, (-0.371 ) ), \
irit.ctlpt( irit.E2, 0.267, (-0.645 ) ), \
irit.ctlpt( irit.E2, (-0.33 ), (-0.542 ) ), \
irit.ctlpt( irit.E2, (-0.137 ), (-0.106 ) ), \
irit.ctlpt( irit.E2, 0.29, (-0.133 ) ), \
irit.ctlpt( irit.E2, 0.555, (-0.088 ) ), \
irit.ctlpt( irit.E2, 0.569, 0.182 ), \
irit.ctlpt( irit.E2, (-0.029 ), 0.29 ) ), irit.list( irit.KV_PERIODIC ) ) * irit.tx( (-0.2 ) )
pocket4b = irit.circle((0, 0, 0), 1)
pocket4c = (-irit.circle(((-0.55), 0.15, 0), 0.2))
pocket4 = irit.list(pocket4a, pocket4b, pocket4c)
pocket4 = irit.coerce(pocket4, irit.KV_OPEN)
irit.color(pocket4, irit.RED)
tpath = irit.ncpcktpath( pocket4, (-0.08 ), (-0.1 ), 0.05, 0.5, 0,\
1 )
irit.attrib(tpath, "ncretractzlevel", irit.GenRealObject(1))
irit.attrib(tpath, "ncmaxxybridgegap", irit.GenRealObject(0.2))
# Polygons with holes -first must be outer loop.
pocket4pl = irit.mergepoly(
irit.list(irit.cnvrtcrvtopolygon(pocket4b, 150, 0),
irit.cnvrtcrvtopolygon(pocket4a, 150, 0),
irit.color(irit.nref(arcs, i), irit.YELLOW)
else:
irit.color(irit.nref(arcs, i), irit.MAGENTA)
i = i + 1
irit.printf("%d arcs were used in this approximation\n",
irit.list(irit.SizeOf(arcs)))
irit.color(crv, irit.CYAN)
irit.interact(irit.list(irit.GetAxes(), crv, arcs))
irit.viewstate("pllnaprx", 1)
irit.viewstate("pllnaprx", 1)
# ######################################################
c1 = irit.cregion(irit.circle((0, 0, 0), 1), 0, 1)
drawbiarcs(c1, 0.1, 180)
drawbiarcs(c1, 1e-006, 180)
drawbiarcs(c1, 1e-006, 10)
# ######################################################
c1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 1, 0 ), \
irit.ctlpt( irit.E2, 1, 1 ), \
irit.ctlpt( irit.E2, 0, 1 ) ), irit.list( irit.KV_OPEN ) )
drawbiarcs(c1, 0.5, 180)
# import math import irit # # # A model of a twin bed (actually built!) # # Gershon Elber, June 1995 # # # All units are in centimeters. # circ = irit.circle((0, 0, 0), 3) arc0 = irit.cregion(circ, 0, 1.5) arc1 = irit.cregion(circ, 0.5, 1.5) arc2 = irit.cregion(circ, 1, 1.5) arc3 = irit.cregion(circ, 0.5, 1) arc4 = irit.cregion(circ, 0.7, 1.5) arc5 = irit.cregion(circ, 0.7, 1.3) arc6 = irit.cregion(circ, 0.7, 1) arc7 = irit.cregion(circ, 1, 1.3) arc8 = irit.cregion(circ, 0.5, 1.3) arc9 = irit.cregion(circ, 0.7, 1.5) irit.free(circ) prof1 = ((-arc1) + (-arc2) * irit.tx(4.6)) prof1a = prof1 * irit.sy(2)
c1 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0.4, 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, 0.283, 0.566 ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, 0.8 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), 0.566 ), \
irit.ctlpt( irit.P3, 1, 2.5, (-0.4 ), 0 ), \
irit.ctlpt( irit.P3, 0.707, 1.77, (-0.283 ), (-0.071 ) ), \
irit.ctlpt( irit.P3, 1, 2.5, 0, (-0.1 ) ) ), irit.list( 0, 0, 0, 1, 1, 2,\
2, 3, 3, 4, 4, 4 ) ) * irit.trans( ( 0, 0, 0 ) )
irit.color(c1, irit.RED)
c2 = c1 * irit.scale((1.05, 1.05, 1.05)) * irit.trans((0.3, 0, 0))
irit.color(c2, irit.RED)
c3 = c1 * irit.scale((0.95, 0.95, 0.95)) * irit.trans((1.7, 0, (-0.02)))
irit.color(c3, irit.RED)
c4 = irit.circle((0, 0, 0), 0.35) * irit.roty(90) * irit.trans((5, 0, 0.2))
irit.color(c4, irit.RED)
c5 = c4 * irit.trans((0.2, 0, 0))
irit.color(c5, irit.RED)
c6 = irit.circle((0, 0, 0), 0.3) * irit.roty(90) * irit.trans((10.5, 0, 0.2))
irit.color(c6, irit.RED)
c7 = irit.circle((0, 0, 0), 0.01) * irit.roty(90) * irit.trans((11, 0, 0.25))
irit.color(c7, irit.RED)
fuseback = irit.sfromcrvs( irit.list( c1, c2, c3, c4, c5, c6,\
c7 ), 3, irit.KV_OPEN )
irit.color(fuseback, irit.RED)
irit.SetViewMatrix(
irit.rotx((-90)) * irit.trans(((-3), 0, 0)) * irit.scale((0.5, 0.5, 0.5)))
