def ant(scl):
save_res = irit.GetResolution()
bodyall = antbody()
body = irit.nth(bodyall, 1)
eyes = irit.nth(bodyall, 2)
leg = antleg()
llegs = irit.list(
leg * irit.sc(1.1) * irit.sx(1.3) * irit.ry((-45)) * irit.trans(
(0.1, 0, 1.02)),
leg * irit.sc(1.3) * irit.ry(10) * irit.trans((0.1, 0.05, 1)),
leg * irit.sc(1.2) * irit.sx(1.4) * irit.ry(40) * irit.trans(
(0.1, 0.02, 0.95)))
irit.SetResolution(20)
irit.attrprop(llegs, "u_resolution", irit.GenRealObject(0.2))
antennas = irit.list(
antantenna() * irit.ry((-110)) * irit.trans(((-0.02), 0.2, 1.6)),
antantenna() * irit.ry((-70)) * irit.trans((0.02, 0.2, 1.6)))
irit.attrprop(antennas, "u_resolution", irit.GenRealObject(0.2))
body = (body + irit.gpolygon(llegs, 1) + irit.gpolygon(llegs, 1) * irit.sx(
(-1)) + irit.gpolygon(antennas, 1))
irit.attrib(body, "rgb", irit.GenStrObject("255,50,50"))
irit.SetResolution(save_res)
retval = irit.list(
body,
eyes) * irit.sz(1.3) * irit.sc(1) * irit.ty(0.28785) * irit.rx(90)
return retval
def antanim(scl):
save_res = irit.GetResolution()
bodyall = antbody()
body = irit.nth(bodyall, 1)
eyes = irit.nth(bodyall, 2)
llegs = irit.list(
antlleganim(1) * irit.sc(1.1) * irit.sx(1.3) * irit.ry(
(-45)) * irit.trans((0.1, 0, 1.02)),
antlleganim((-1)) * irit.sc(1.3) * irit.ry(10) * irit.trans(
(0.1, 0.05, 1)),
antlleganim(1) * irit.sc(1.2) * irit.sx(1.4) * irit.ry(40) *
irit.trans((0.1, 0.02, 0.95)))
rlegs = irit.list(
antrleganim(
(-1)) * irit.sc(1.1) * irit.sx(1.3) * irit.ry(45) * irit.trans(
((-0.1), 0, 1.02)),
antrleganim(1) * irit.sc(1.3) * irit.ry((-10)) * irit.trans(
((-0.1), 0.05, 1)),
antrleganim((-1)) * irit.sc(1.2) * irit.sx(1.4) * irit.ry(
(-40)) * irit.trans(((-0.1), 0.02, 0.95)))
irit.SetResolution(20)
antennas = irit.list(
antantenna() * irit.ry((-110)) * irit.trans(((-0.02), 0.2, 1.6)),
antantenna() * irit.ry((-70)) * irit.trans((0.02, 0.2, 1.6)))
irit.attrprop(antennas, "u_resolution", irit.GenRealObject(0.2))
body = (body + irit.gpolygon(antennas, 1))
irit.attrib(body, "rgb", irit.GenStrObject("255,50,50"))
irit.SetResolution(save_res)
retval = irit.list(
body, llegs, rlegs,
eyes) * irit.sz(1.3) * irit.sc(1) * irit.ty(0.28785) * irit.rx(90)
mov_y = irit.creparam( irit.ctlpt( irit.E1, 0 ) + \
irit.ctlpt( irit.E1, (-1 ) ), 0, 1.2 )
irit.attrib(retval, "animation", mov_y)
return retval
def antantenna():
c = irit.pcircle((0, 0, 0), 0.03) * irit.ry(90)
retval = (-irit.sfromcrvs(
irit.list(
c * irit.sy(1.4) * irit.rz(45) * irit.tx(0.1) * irit.ty((-0.15)),
c * irit.rz(45) * irit.tx(0.2) * irit.ty(0.2),
c * irit.sy(1.4) * irit.tx(0.3) * irit.ty(0.4),
c * irit.rz((-55)) * irit.tx(0.4) * irit.ty(0.15),
c * irit.sc(0.8) * irit.rz((-45)) * irit.tx(0.5) * irit.ty((-0.1)),
c * irit.sc(0.65) * irit.rz((-45)) * irit.tx(0.58) * irit.ty(
(-0.22)),
c * irit.sc(0.001) * irit.rz((-45)) * irit.tx(0.58) * irit.ty(
(-0.22))), 3, irit.KV_OPEN))
irit.attrib(retval, "rgb", irit.GenStrObject("255,50,50"))
return retval
def antrleganim(s):
retval = antleg() * irit.ry(180)
t = 0.2 * (s + 1) / 2
rot_y = irit.creparam( irit.cbspline( 2, irit.list( irit.ctlpt( irit.E1, 13 * s ), \
irit.ctlpt( irit.E1, (-13 ) * s ), \
irit.ctlpt( irit.E1, (-13 ) * s ), \
irit.ctlpt( irit.E1, 13 * s ) ), irit.list( 0, 0, 1.3, 1.7, 3, 3 ) ),\
0 + t, 1 + t )
rot_z = irit.creparam( irit.cbspline( 2, irit.list( \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 7 + 7 * s ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 0 ), \
irit.ctlpt( irit.E1, 7 - 7 * s ), \
irit.ctlpt( irit.E1, 0 ) ), irit.list( irit.KV_OPEN ) ), 0 + t, 1 + t )
irit.attrib(retval, "animation", irit.list(rot_z, rot_y))
return retval
#
# Gershon Elber, Oct 2002
#
oldcnvxpl2vrtices = irit.iritstate("cnvxpl2vrtcs", irit.GenRealObject(0))
# ############################################################################
c = irit.cbspline( 4, irit.list( irit.ctlpt( irit.E2, 0, 0.15 ), \
irit.ctlpt( irit.E2, 0.25, 0.15 ), \
irit.ctlpt( irit.E2, 0.52, 0.4 ), \
irit.ctlpt( irit.E2, 0.85, 0.3 ), \
irit.ctlpt( irit.E2, 0.85, 0 ) ), irit.list( irit.KV_OPEN ) )
c = ((-c) + c * irit.sx((-1)))
srf8a = irit.surfprev(c * irit.ry(90)) * irit.sx(0.9) * irit.homomat(
irit.list(irit.list(1, 0, 0.2, 0), irit.list(0, 1, 0, 0),
irit.list(0, 0, 1, 0), irit.list(0, 0, 0, 1))) * irit.homomat(
irit.list(irit.list(1, 0, 0, 0), irit.list(0, 1, 0.2, 0),
irit.list(0, 0, 1, 0), irit.list(0, 0, 0, 1)))
irit.color(srf8a, irit.YELLOW)
irit.awidth(srf8a, 0.001)
k = irit.srfkernel(srf8a, 5, 3)
irit.interact(irit.list(srf8a, k))
irit.save("srf1krnl", irit.list(k, srf8a))
# ############################################################################
irit.free(arc8)
irit.free(arc9)
cross1 = (prof1 + prof4 * irit.tx(60))
cross2 = (prof1 + prof2 * irit.tx(50) + prof4 * irit.tx(80))
irit.free(prof1)
irit.free(prof1a)
irit.free(prof2)
irit.free(prof2a)
irit.free(prof3)
irit.free(prof3a)
irit.free(prof4)
irit.free(prof4a)
leg1 = irit.surfrev(cross1 * irit.ry((-90)))
leg2 = irit.surfrev(cross2 * irit.ry((-90)))
irit.free(cross1)
irit.free(cross2)
legs = irit.list(leg1, leg1 * irit.tx(80), leg2 * irit.trans((0, 190, 0)),
leg2 * irit.trans((80, 190, 0)))
irit.attrib(legs, "rgb", irit.GenStrObject("244,164,96"))
irit.free(leg1)
irit.free(leg2)
skel = irit.list( irit.box( ( (-1 ), (-1 ), 25 ), 80, 2, 20 ),\
irit.box( ( (-1 ), (-1 ), 25 ), 2, 190, 20 ),\
irit.box( ( (-1 ), 189, 25 ), 80, 2, 20 ),\
irit.box( ( 79, (-1 ), 25 ), 2, 190, 20 ),\
irit.box( ( (-1 ), 90, 25 ), 80, 2, 20 ) )
def interact( none ):
irit.viewdclear( )
irit.viewobj( none )
irit.pause( )
echosrc2 = irit.iritstate( "echosource", echosrc2 )
irit.free( echosrc2 )
#
# Define the trivarate warping function.
#
s1 = irit.ruledsrf( irit.ctlpt( irit.E3, 0.5, 0, 0 ) + \
irit.ctlpt( irit.E3, 1.5, 0, 0 ), \
irit.ctlpt( irit.E3, 0.5, 1.2, 0 ) + \
irit.ctlpt( irit.E3, 1.5, 1.2, 0 ) )
tv = irit.tfromsrfs( irit.list( s1, s1 * irit.ry( 30 ), s1 * irit.ry( 60 ), s1 * irit.ry( 90 ), s1 * irit.ry( 120 ), s1 * irit.ry( 150 ), s1 * irit.ry( 180 ) ), 3, irit.KV_OPEN )
tv = irit.treparam( irit.treparam( tv, irit.COL, 0, 0.5 ), irit.ROW, 0.2,\
0.8 )
irit.awidth( tv, 0.001 )
irit.free( s1 )
#
# Define our warping function.
#
def warpsurface( srf, tv ):
usize = irit.FetchRealObject(irit.nth( irit.ffmsize( srf ), 1 ))
vsize = irit.FetchRealObject(irit.nth( irit.ffmsize( srf ), 2 ))
clr = irit.getattr( srf, "color" )
i = 0
while ( i <= usize * vsize - 1 ):
bladeside = irit.ruledsrf(sec1, sec2)
bladetop = irit.ruledsrf(irit.cregion(sec2, 0, 0.5),
(-irit.cregion(sec2, 0.5, 1)))
blademain = irit.list(bladeside, bladetop) * irit.tz(0.2)
irit.free(bladeside)
irit.free(bladetop)
bladefillet = irit.sfromcrvs(
irit.list(sec1 * irit.sc(1.35) * irit.sy(1.5) * irit.tz((-0.1)), sec1,
sec1 * irit.tz(0.2)), 3, irit.KV_OPEN)
irit.free(sec1)
irit.free(sec2)
blade = irit.list(blademain, bladefillet) * irit.tx(0.1) * irit.ry(
90) * irit.sc(0.285) * irit.tx(0.636) * irit.rx(20)
irit.attrib(blade, "rgb", irit.GenStrObject("128,128,128"))
irit.free(blademain)
irit.free(bladefillet)
#
# The Base
#
basesec = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0.1, 0.055 ), \
irit.ctlpt( irit.E2, 0.4, 0.052 ), \
irit.ctlpt( irit.E2, 0.435, 0.06 ), \
irit.ctlpt( irit.E2, 0.44, 0.24 ), \
irit.ctlpt( irit.E2, 0.47, 0.3 ), \
irit.ctlpt( irit.E2, 0.62, 0.29 ), \
(diag, 0, diag)), irit.FALSE)
item1 = (itemaux2 - diagpoly - diagpoly * irit.sy((-1)) - diagpoly * irit.sz(
(-1)) - diagpoly * irit.sz((-1)) * irit.sy((-1)))
item1 = irit.convex(item1)
irit.color(item1, irit.RED)
item2 = item1 * irit.sx((-1))
irit.color(item2, irit.MAGENTA)
item3 = item1 * irit.rx(90) * irit.rz(90)
irit.color(item3, irit.GREEN)
item4 = item1 * irit.rx(90) * irit.rz((-90))
irit.color(item4, irit.YELLOW)
item5 = item1 * irit.rx(90) * irit.ry(90)
irit.color(item5, irit.BLUE)
item6 = item1 * irit.rx(90) * irit.ry((-90))
irit.color(item6, irit.CYAN)
grp1 = irit.list(item2, item3, item5)
grp2 = irit.list(item1, item4, item6)
scl = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E1, 1 ), \
irit.ctlpt( irit.E1, 1 ), \
irit.ctlpt( irit.E1, 5 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )
mov_xyz = irit.creparam( irit.cbspline( 4, irit.list( irit.ctlpt( irit.E3, 0, 0, (-3 ) ), \
irit.ctlpt( irit.E3, (-1 ), 1, (-3 ) ), \
irit.ctlpt( irit.E3, (-0.5 ), 0.5, (-0.5 ) ), \
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some examples of using reflection lines.
#
# Gershon Elber, October 1999
#
save_res = irit.GetResolution()
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.rx(2) * irit.ry(2) * irit.sc(0.5))
irit.viewobj(irit.GetViewMatrix())
irit.SetViewMatrix(save_mat)
# ############################################################################
s = 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.rx( 90 )
s = irit.sraise(irit.sraise(s, irit.ROW, 3), irit.COL, 3)
s = (-irit.seditpt(s, irit.ctlpt(irit.E3, 0, 1, 0), 1, 1))
irit.color(s, irit.MAGENTA)
reflectlns = irit.nil()
displayobjobjhdres( c3, c4, eps, 0 ) displayobjobjhdres( c3, c4, eps, 1 ) displayobjobjhdres( c4, c3, eps, 1 ) displayobjobjhdres( c4, c4a * irit.tx( (-0.5 ) ), eps, 0 ) displayobjobjhdres( c2, c4a * irit.tx( (-0.5 ) ), eps, 0 ) displayobjobjhdres( c2, c4a * irit.sx( (-3 ) ) * irit.tx( 0.5 ), eps, 0 ) displayobjobjhdres( c2, c2a * irit.sx( (-3 ) ) * irit.tx( 0.5 ), eps, 0 ) displayobjobjhdres( c5, c5 * irit.sx( 0.7 ) * irit.sy( 0.95 ) * irit.ry( 20 ), eps, 0 ) displayobjobjhdres( c6, c6 * irit.rz( 20 ), eps, 0 ) irit.save( "hausdorf", glblres ) # view( GlblRes, 1 ); # ############################################################################ irit.free( glblres ) iprod = irit.iritstate( "bspprodmethod", iprod ) irit.free( iprod ) irit.free( c1 ) irit.free( c2 ) irit.free( c2a ) irit.free( c3 )
displayobjobjmdres(c3, c3 * irit.tx((-0.5)), 1e-010)
displayobjobjmdres(c4, c4 * irit.rz(180), 1e-010)
displayobjobjmdres(c4, c4a * irit.tx((-0.5)), 1e-010)
displayobjobjmdres(s2, c4a * irit.tx((-0.5)), 1e-010)
displayobjobjmdres(s2, c4a * irit.sx((-3)) * irit.tx(0.5), 1e-010)
displayobjobjmdres(s2, c2a * irit.sx((-3)) * irit.tx(0.5), 1e-010)
displayobjobjmdres(s2, s2 * irit.sx((-3)) * irit.tx(0.5), 1e-010)
displayobjobjmdres(s2,
s2 * irit.sx((-3)) * irit.tx(0.5) * irit.ry((-10)), 1e-010)
displayobjobjmdres(s2, s2 * irit.sx((-3)) * irit.tx(0.5) * irit.ry(10), 1e-010)
displayobjobjmdres(s3, s3 * irit.sx(3) * irit.tx(0.5) * irit.ry(10), 1e-010)
displayobjobjmdres(s3 * irit.rx(90),
s3 * irit.sx(3) * irit.tx(0.5) * irit.ry(10), 1e-010)
displayobjobjmdres(s3 * irit.rx(90) * irit.ry(120),
s3 * irit.sx(3) * irit.tx(0.5) * irit.ry(10), 1e-010)
displayobjobjmdres(
s3 * irit.sx(3) * irit.tx(0.5) * irit.ry((-60)) * irit.tx(
(-0.5)) * irit.tz((-1.2)),
s3 * irit.rx(90) * irit.ry(120), 1e-010)
#
# Can you compute the volume of this thing!?
#
save_mat = irit.GetViewMatrix()
irit.SetViewMatrix(irit.sc(0.4))
cork = irit.ruledsrf(irit.pcircle((0, 0, 0), 1),
irit.pcircle((0, 0, 0), 1) * irit.sx(0) * irit.tz(2))
irit.interact(
irit.list(
irit.GetViewMatrix(),
cork * irit.rx((-90)) * irit.tx((-1.2)) * irit.ty(0.4),
cork * irit.tx((-1.2)) * irit.ty((-1.2)),
cork * irit.rx((-90)) * irit.ry(90) * irit.tx(1.2) * irit.ty(0.4),
cork * save_mat * irit.tx(1.2) * irit.ty((-1.8))))
irit.save("corkplug", cork)
corkcross = irit.nth(irit.prisa(cork, 256, 1, irit.COL, (0, 0, 0), 1), 1)
irit.color(corkcross, irit.MAGENTA)
corkprisa = irit.prisa(cork, 256, 1, irit.COL, (0, 0, 0), 0)
irit.color(corkprisa, irit.RED)
all = irit.list(corkprisa * irit.ty(
(-1.3)), corkcross * irit.ty(1)) * irit.sc(0.35)
irit.interact(all)
irit.save("cork_prs", all)
a2 = irit.arrow3d(irit.point(1, 0, 0), irit.vector((-1.5), 0.5, 1), 1, 0.02,
0.2, 0.05)
a3 = irit.arrow3d( irit.point( 0, 0.6, 0.8 ), irit.vector( 0.5, 0.7, 0.3 ), 0.5, 0.01, 0.2,\
0.02 )
irit.interact(irit.list(irit.GetAxes(), a1, a2, a3))
irit.save( "macros8", irit.list( v, irit.tx( 1 ) * \
irit.ty( 1 ) * \
irit.tz( 1 ) * \
irit.sx( 2 ) * \
irit.sy( 2 ) * \
irit.sz( 3 ) * \
irit.sc( 3 ) * \
irit.rx( 10 ) * \
irit.ry( 20 ) * \
irit.rz( (-30 ) ),
irit.rotz2vec( v ) * w,
irit.rotz2vec( irit.vector( 1, 0, 0 ) ),
irit.rotz2vec( irit.vector( 0, 1, 0 ) ),
irit.rotz2vec( irit.vector( 0, 0, 1 ) ),
irit.rotvec2z( v ),
w, a1, a2, a3 ) )
irit.free(v)
irit.free(w)
irit.free(a1)
irit.free(a2)
irit.free(a3)
#This is an IRIT script and as such requires both math and irit import:
#
import math
import irit
#
#
# Some examples of K-orthotomics (See Fundamentals of Computer Aided
# Geometric Design, by J. Hoschek and D. Lasser.)
#
# Gershon Elber, August 1996.
#
save_mat = irit.GetViewMatrix()
view_mat3d = save_mat * irit.ry(15) * irit.sc(0.6)
view_mat2d = irit.sc(0.6)
irit.viewobj(view_mat2d)
irit.viewstate("widthlines", 1)
# ############################################################################
#
# A cubic curve
#
pt = irit.point(0, 0.35, 0)
irit.color(pt, irit.CYAN)
#
# Modifying the curve.
#
#
irit.SetResolution(10)
s1 = irit.sphere((0.2, 0.2, 0.8), 0.18)
irit.color(s1, irit.YELLOW)
s2 = irit.sphere((0.75, 0.25, 0.16667), 0.12) * irit.sz(3)
irit.color(s2, irit.MAGENTA)
c1 = irit.maxedgelen( irit.triangl( irit.cylin( ( 0.15, 0.85, 0.01 ), ( 0, 0, 0.98 ), 0.1, 3 ), 1 ),\
0.2 )
irit.color(c1, irit.CYAN)
c2 = irit.maxedgelen( irit.triangl( irit.cylin( ( 0.85, 0.85, 0.01 ), ( 0, 0, 0.98 ), 0.1, 3 ), 1 ),\
0.2 )
irit.color(c2, irit.CYAN)
genie = irit.list( teapotorig * irit.sc( 0.15 ) * irit.ry( (-90 ) ) * irit.trans( ( 0.5, 0.4, 0.47 ) ), s1, s2, c1,\
c2 )
b = irit.box((0, 0, 0), 1, 1, 1)
irit.attrib(b, "transp", irit.GenRealObject(0.5))
irit.interact(irit.list(irit.GetAxes(), b, genie))
wgenie = warpobj(genie, tv)
irit.interact(irit.list(teapot, wgenie, tv))
irit.save("genitpot", irit.list(teapot, wgenie, tv))
# ############################################################################
irit.SetViewMatrix(save_mat2)
1e-005), 0)
printtest("srf of revolution", irit.isgeom(extr, irit.GEOM_SRF_OF_REV, 1e-005),
0)
crv = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0.1, 0, 0 ), \
irit.ctlpt( irit.E3, 1, 0, 0 ), \
irit.ctlpt( irit.E3, 1, 0, 1 ) ) )
# too slow for regular testing.
#srev = surfrev( crv );
#PrintTest( "Srf of revolution", isgeom( srev, irit.GEOM_SRF_OF_REV, 1e-10 ), 1 );
#
srev = irit.surfprev(crv) * irit.tx(1) * irit.ty(2) * irit.sc(0.5) * irit.rx(
10) * irit.ry(20) * irit.rz(30)
printtest("srf of revolution", irit.isgeom(srev, irit.GEOM_SRF_OF_REV, 0.1), 1)
printtest("srf of revolution", irit.isgeom(srev, irit.GEOM_SRF_OF_REV, 0.01),
0)
crv = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.3, 0, 0 ), \
irit.ctlpt( irit.E3, 0.3, 0, 0.05 ), \
irit.ctlpt( irit.E3, 0.1, 0, 0.05 ), \
irit.ctlpt( irit.E3, 0.1, 0, 0.4 ), \
irit.ctlpt( irit.E3, 0.5, 0, 0.4 ), \
irit.ctlpt( irit.E3, 0.6, 0, 0.8 ) ), irit.list( irit.KV_OPEN ) )
srev = irit.surfprev(crv) * irit.tx((-1)) * irit.tz(
(-5)) * irit.sc(0.25) * irit.rx(55) * irit.ry((-220)) * irit.rz((-130))
printtest("srf of revolution", irit.isgeom(srev, irit.GEOM_SRF_OF_REV, 0.1), 1)
printtest("srf of revolution", irit.isgeom(srev, irit.GEOM_SRF_OF_REV, 0.001),
0)
wingplane1 = 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 ) )
wingplane2 = (-wingplane1) * irit.tz(0.1)
irit.attrib(wingplane1, "rgb", irit.GenStrObject("10, 10, 10"))
irit.attrib(wingplane2, "rgb", irit.GenStrObject("255, 255, 255"))
irit.attrib(wingframe, "rgb", irit.GenStrObject("100, 100, 100"))
wingbase = irit.list(wingframe, wingplane1, wingplane2)
irit.free(wingframe)
irit.free(wingplane1)
irit.free(wingplane2)
wing = wingbase * irit.tx(1) * irit.ty(1) * irit.sc(0.11) * irit.rz(
45) * irit.ry(90) * irit.tz(2.1) * irit.ty(0.1)
wings = irit.list(wing, wing * irit.rz(90), wing * irit.rz(180),
wing * irit.rz(270))
irit.free(wing)
wingbasesec = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, (-0.1 ), 0, 2.1 ), \
irit.ctlpt( irit.E3, (-0.02 ), 0, 2.1 ), \
irit.ctlpt( irit.E3, (-0.02 ), 0, 2.2 ), \
irit.ctlpt( irit.E3, (-0.02 ), 0, 2.21 ), \
irit.ctlpt( irit.E3, (-0.001 ), 0, 2.21 ) ), irit.list( irit.KV_OPEN ) )
wingbase = irit.surfrev(wingbasesec)
irit.free(wingbasesec)
irit.attrib(wingbase, "transp", irit.GenRealObject(0.95))
irit.color(wingbase, irit.WHITE)
all = irit.list(body, base1, niddle1, base2, wings, wingbase)
def antbody():
save_res = irit.GetResolution()
c = irit.pcircle((0, 0, 0), 1)
body = (-irit.sfromcrvs(
irit.list(
c * irit.sc(1e-006) * irit.ty((-0.1)) * irit.tz(0.19),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.19),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.21),
c * irit.sy(0.8) * irit.sc(0.14) * irit.ty((-0.1)) * irit.tz(0.23),
c * irit.sy(0.8) * irit.sc(0.14) * irit.ty((-0.1)) * irit.tz(0.26),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.28),
c * irit.sy(0.8) * irit.sc(0.11) * irit.ty((-0.1)) * irit.tz(0.29),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.05)) * irit.tz(0.31),
c * irit.sy(0.8) * irit.sc(0.27) * irit.ty(
(-0.05)) * irit.tz(0.41),
c * irit.sy(0.8) * irit.sc(0.19) * irit.ty(
(-0.05)) * irit.tz(0.44),
c * irit.sy(0.8) * irit.sc(0.19) * irit.ty(
(-0.05)) * irit.tz(0.45),
c * irit.sy(0.8) * irit.sc(0.3) * irit.ty(
(-0.035)) * irit.tz(0.47),
c * irit.sy(0.8) * irit.sc(0.32) * irit.ty(
(-0.035)) * irit.tz(0.59),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.035)) * irit.tz(0.62),
c * irit.sy(0.8) * irit.sc(0.24) * irit.ty(
(-0.035)) * irit.tz(0.63),
c * irit.sy(0.8) * irit.sc(0.3) * irit.ty((-0.03)) * irit.tz(0.65),
c * irit.sy(0.8) * irit.sc(0.28) * irit.ty(
(-0.03)) * irit.tz(0.76),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.85),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(0.87),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty((-0.1)) * irit.tz(0.93),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty((-0.1)) * irit.tz(1.03),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(1.1),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0.1)) * irit.tz(1.12),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty(
(-0.06)) * irit.tz(1.18),
c * irit.sy(0.8) * irit.sc(0.18) * irit.ty(
(-0.03)) * irit.tz(1.32),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0)) * irit.tz(1.41),
c * irit.sy(0.8) * irit.sc(0.07) * irit.ty((-0)) * irit.tz(1.43),
c * irit.sy(0.8) * irit.sc(0.22) * irit.ty(0.05) * irit.tz(1.5),
c * irit.sy(0.8) * irit.sc(0.2) * irit.ty((-0)) * irit.tz(1.66),
c * irit.sy(0.8) * irit.sc(0.05) * irit.ty(
(-0.22)) * irit.tz(1.85),
c * irit.sy(0.8) * irit.sc(1e-006) * irit.ty(
(-0.22)) * irit.tz(1.86)), 3, irit.KV_OPEN))
irit.SetResolution(15)
eye1 = irit.sphere((0, 0, 0), 0.08) * irit.rx(20) * irit.ry(
(-20)) * irit.trans((0.15, 0.05, 1.59))
eye2 = eye1 * irit.sx((-1))
irit.SetResolution(20)
bodycut = body / eye1 ^ eye2
irit.attrib(bodycut, "rgb", irit.GenStrObject("255,50,50"))
eye1cut = eye1 / body
irit.attrib(eye1cut, "reflection", irit.GenStrObject("0.85"))
irit.attrib(eye1cut, "rgb", irit.GenStrObject("15,15,15"))
eye2cut = eye2 / body
irit.attrib(eye2cut, "reflection", irit.GenStrObject("0.85"))
irit.attrib(eye2cut, "rgb", irit.GenStrObject("15,15,15"))
irit.SetResolution(save_res)
retval = irit.list(bodycut, irit.list(eye1cut, eye2cut))
return retval
import math
import irit
#
#
# Examples of surface accessibility analysis.
#
# Gershon Elber, December 1999
#
# ############################################################################
#
# Plane surface - sphere check surface example.
#
c = irit.cregion(irit.pcircle((0, 0, 0), 1), 1, 3) * irit.ry(90)
psphere = irit.surfprev(c) * irit.sc(0.3) * irit.tz(1)
irit.color(psphere, irit.YELLOW)
pln = 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(pln, irit.RED)
pts = irit.saccess(pln, irit.GenRealObject(0), psphere, irit.GenRealObject(0),
0.1, 1e-005)
spts = irit.nil()
sptserr = irit.nil()
sclfctr = 0.6
sqr2 = sqr1 * irit.sc((-sclfctr)) * irit.tz(sclfctr * 2)
trap1 = irit.poly(
irit.list(
irit.point((-1), (-1), 1) * irit.sc(sclfctr),
irit.point((-1), 1, 1) * irit.sc(sclfctr), irit.point((-1), 1, 1),
irit.point((-1), (-1), 1)), 0)
trap2 = trap1 * irit.rz(180)
prim1 = irit.list(sqr1, sqr2, trap1, trap2)
prim2 = prim1 * irit.rx(90)
prim3 = prim1 * irit.rx((-90))
baseunitaux = irit.list(prim1, prim2, prim3,
trap1 * irit.rx(90) * irit.ry((-90)),
trap2 * irit.rx((-90)) * irit.ry(90))
baseunit = irit.list(baseunitaux, baseunitaux * irit.ty(2.35),
irit.box(
((-0.15), 1, (-0.5)), 0.3, 0.35, 1)) * irit.sc(0.5)
irit.free(baseunitaux)
baseunit1 = baseunit
irit.color(baseunit1, irit.RED)
baseunit2 = baseunit * irit.tx(1.175)
irit.color(baseunit2, irit.GREEN)
baseunit3 = baseunit * irit.rx(180) * irit.rz(90)
irit.color(baseunit3, irit.CYAN)
irit.ctlpt( irit.E3, 0, 0, 1 ), \
irit.ctlpt( irit.E3, 0, 0.747, 0.761 ), \
irit.ctlpt( irit.E3, 0, 1.07, (-0.0984 ) ), \
irit.ctlpt( irit.E3, 0, 0.762, (-0.631 ) ), \
irit.ctlpt( irit.E3, 0, 0.483, (-0.896 ) ), \
irit.ctlpt( irit.E3, 0, 0.279, (-1.54 ) ), \
irit.ctlpt( irit.E3, 0, 0, (-1.78 ) ) ), irit.list( irit.KV_OPEN ) )
crvs = irit.list(
c1b * irit.sc(0.001) * irit.trans((1.02, 0, 0.18)),
c1b * irit.sc(0.07) * irit.sz(0.4) * irit.trans((1.02, 0, 0.18)),
c1b * irit.sc(0.18) * irit.sz(0.3) * irit.trans((0.8, 0, 0.16)),
c1b * irit.sc(0.27) * irit.sz(0.5) * irit.trans((0.6, 0, 0.16)),
c1b * irit.sc(0.43) * irit.sz(0.64) * irit.trans((0.3, 0, 0.2)),
c1b * irit.sc(0.54) * irit.sz(0.7) * irit.trans((0, 0, 0.23)),
c1b * irit.sc(0.52) * irit.ry(25) * irit.sz(0.76) * irit.trans(
((-0.34), 0, 0.26)),
c1b * irit.sc(0.41) * irit.sz(1.13) * irit.ry(50) * irit.trans(
((-0.6), 0, 0.32)),
c1b * irit.sc(0.3) * irit.sz(1.3) * irit.ry(65) * irit.trans(
((-0.7), 0, 0.42)),
c1b * irit.sc(0.16) * irit.sz(1.4) * irit.ry(75) * irit.trans(
((-0.71), 0, 0.5)),
c1a * irit.sc(0.16) * irit.sz(1.4) * irit.ry(75) * irit.trans(
((-0.72), 0, 0.53)),
c1a * irit.sc(0.2) * irit.sz(2) * irit.ry(75) * irit.trans(
((-0.8), 0, 0.6)),
c1a * irit.sc(0.2) * irit.sz(2) * irit.ry(75) * irit.trans(
((-0.82), 0, 0.66)),
c1a * irit.sc(0.2) * irit.sz(1.2) * irit.ry(75) * irit.trans(
((-0.79), 0, 0.8)),
a = (-2)
while (a <= 0):
pt = (a, 0, 0)
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, (-0.2 ), (-1 ) ), \
irit.ctlpt( irit.E3, 0, (-3.2 ), 0 ), \
irit.ctlpt( irit.E3, 0, (-0.2 ), 1 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, pt), 0)
display(c1, pt, bisectsrf)
a = a + 0.005 * speed
# ############################################################################
#
# A cubic
#
circ = irit.pcircle((0, 0, 0), 1) * irit.rz(90) * irit.ry((-90))
irit.ffcompat(c1, circ)
pt = (0, 0, 0)
a = 0
while (a <= 1):
c1x = irit.cmorph(c1, circ, 0, a)
bisectsrf = irit.cbisector3d(irit.list(c1x, pt), 0)
display(c1x, pt, bisectsrf)
a = a + 0.01 * speed
a = 0
while (a <= 0.9):
pt = (0, a, 0)
bisectsrf = irit.cbisector3d(irit.list(circ, pt), 0)
# Logo frame
#
hplogo = irit.ruledsrf( irit.ctlpt( irit.E3, 6, (-0.01 ), 6.4 ) + \
irit.ctlpt( irit.E3, 7.7, (-0.01 ), 6.4 ), \
irit.ctlpt( irit.E3, 6, (-0.01 ), 6.8 ) + \
irit.ctlpt( irit.E3, 7.7, (-0.01 ), 6.8 ) )
irit.attrib(hplogo, "rgb", irit.GenStrObject("0,0,255"))
#
# On-off button
#
irit.SetResolution(4)
onoff = irit.con2((0, (-0.1), 0), (0, 0.3, 0), 0.2, 0.1,
3) * irit.ry(45) * irit.sz(1.5) * irit.tx(0.2) * irit.tz(0.7)
irit.SetResolution(20)
base = (base - onoff)
onoff = irit.box((0.135, 0, 0.6), 0.135, 0.2, 0.2)
topfeed = irit.extrude( irit.cbezier( irit.list( irit.ctlpt( irit.E3, 2, 0.51, 6.2 ), \
irit.ctlpt( irit.E3, 3.7, 0.51, 7 ), \
irit.ctlpt( irit.E3, 4.5, 0.51, 7.5 ), \
irit.ctlpt( irit.E3, 5.39, 0.51, 7.5 ) ) ) + \
irit.ctlpt( irit.E3, 5.39, 0.51, 6.01 ) + \
irit.ctlpt( irit.E3, 2, 0.51, 6.01 ) + \
irit.ctlpt( irit.E3, 2, 0.51, 6.2 ), ( 0, 3.98, 0 ), 3 )
drawer1 = irit.ruledsrf( irit.ctlpt( irit.E3, 3.5, 0.38, 0.56 ) + \
stick1 = (irit.box(((-0.5), 0, (-3)), 1, 1, 6) - irit.box(
((-1), (-0.5), 1), 2, 1, 1))
irit.attrib(stick1, "rgb", irit.GenStrObject("255, 0, 0"))
stick2 = (irit.box(((-0.5), 0, (-3)), 1, (-1), 6) - irit.box(
((-1), (-0.5), (-2)), 2, 1, 3))
irit.attrib(stick2, "rgb", irit.GenStrObject("255, 100, 0"))
stick3 = (irit.box(((-3), (-0.5), (-1)), 6, 1, 1) - irit.box(
((-2), (-1), (-0.5)), 1.75, 2, 1) - irit.box(
(0.25, (-1), (-0.5)), 1.75, 2, 1) - irit.box(
((-0.5), 0, (-1)), 1, 2, 2))
irit.attrib(stick3, "rgb", irit.GenStrObject("255, 0, 100"))
stick4 = stick3 * irit.ry(180)
irit.attrib(stick4, "rgb", irit.GenStrObject("255, 100, 100"))
stick5 = (irit.box((0, (-3), (-0.5)), 1, 6, 1) - irit.box((0.5, (-2), (-1)),
(-1), 4, 2))
irit.attrib(stick5, "rgb", irit.GenStrObject("255, 100, 0"))
stick6 = stick5 * irit.ry(180)
irit.attrib(stick6, "rgb", irit.GenStrObject("255, 50, 50"))
# ################################
bar1 = ( irit.box( ( (-3 ), (-0.5 ), 1 ), 6, 1, 2 ) - \
(irit.box( ( (-0.5 ), (-1 ), 1 ), 1, 1, 3 ) + \
irit.box( ( (-0.5 ), (-1 ), 2 ), 1, 3, 2 ) ))
pt2 = irit.point(irit.random((-0.5), 0.5), irit.random((-0.5), 0.5), 0)
pt3 = irit.point(irit.random((-0.5), 0.5), irit.random((-0.5), 0.5), 0)
pl = irit.poly(irit.list(pt1, pt2, pt3), irit.FALSE)
irit.color(pl, irit.GREEN)
ellimp = irit.ellipse3pt(irit.Fetch3TupleObject(pt1),
irit.Fetch3TupleObject(pt2),
irit.Fetch3TupleObject(pt3), 0)
ell = irit.conicsec(ellimp, 0, 0, 0)
irit.color(ell, irit.YELLOW)
irit.adwidth(ell, 2)
i = 10
while (i <= n):
m = irit.rz(i) * irit.rx(i * 2) * irit.ry(i * 3) * irit.sc(
i / 360.0) * irit.tx(i / 360.0 - 1) * irit.tz(i / 720.0 - 0.5)
ell3imp = irit.cnc2quad(ellimp, i / 1000.0)
ell3imp = irit.implctrans(2, ell3imp, m)
ell3 = irit.quadric(ell3imp)
irit.color(ell3, irit.MAGENTA)
all = irit.list(irit.GetAxes(), ell3, ell)
irit.view(all, irit.ON)
irit.milisleep(100)
i = i + 10
irit.save("ellips4", all)
# ############################################################################
irit.viewstate("widthlines", 0)
ri = irit.iritstate("randominit", irit.GenRealObject(1964))
# Seed-initiate the randomizer,
irit.free(ri)
size = 0.25
v1 = (0, 0, 0)
v2 = (size * 3, 0, 0)
v3 = (size * 3, size * 3, 0)
v4 = (0, size * 3, 0)
plaux = irit.poly(irit.list(v1, v2, v3, v4, v1), irit.TRUE)
cubebbox = irit.list(plaux, plaux * irit.tz(size * 3), plaux * irit.rx(90),
plaux * irit.rx(90) * irit.ty(size * 3),
plaux * irit.ry((-90)),
plaux * irit.ry((-90)) * irit.tx(size * 3))
irit.attrib(cubebbox, "rgb", irit.GenStrObject("255, 255, 255"))
irit.free(plaux)
def cubeat(x, y, z):
retval = irit.box((x - size / 2.0, y - size / 2.0, z - size / 2.0), size,
size, size)
irit.attrib(
retval, "rgb",
irit.GenStrObject(
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255))) + "," +
str(int(irit.random(64, 255)))))
return retval
irit.ctlpt( irit.E3, 0, (-0.1 ), 1 ) ) )
c2 = irit.cbezier( irit.list( \
irit.ctlpt( irit.E3, (-1 ), 0.1, 0 ), \
irit.ctlpt( irit.E3, 0, 2.1, 0 ), \
irit.ctlpt( irit.E3, 1, 0.1, 0 ) ) )
bisectsrf = irit.cbisector3d(irit.list(c1, c2), 1)
display(c1, c2, bisectsrf)
a = a + 0.02 * speed
# ############################################################################
#
# A line and a circle
#
circ = irit.creparam(irit.pcircle((0, 0, 0), 1), 0, 1) * irit.rz(
(-90)) * irit.ry(180)
irit.ffcompat(c2, circ)
a = 0
while (a <= 1):
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, (-1 ) ), \
irit.ctlpt( irit.E3, 0, 0, 1 ) ) )
c2x = irit.cmorph(c2, circ, 0, a)
bisectsrf = irit.cbisector3d(irit.list(c1, c2x), 1)
display(c1, c2x, bisectsrf)
a = a + 0.01 * speed
# ############################################################################
#
# A line and a circle (again)
#
c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), (-1 ), (-1 ) ), \
irit.ctlpt( irit.E3, (-0.5 ), 8, (-1 ) ), \
irit.ctlpt( irit.E3, 0, (-15 ), (-1 ) ), \
irit.ctlpt( irit.E3, 0.5, 8, (-1 ) ), \
irit.ctlpt( irit.E3, 1, (-1 ), (-1 ) ) ) )
c2 = c1 * irit.sc(0.7) * irit.tz(1.7)
r1 = irit.ruledsrf(c1, c2)
irit.awidth(r1, 0.007)
c1 = irit.pcircle((0, 0, 0), 0.3) * irit.tz(2)
c2 = c1 * irit.sc(0.5) * irit.tz((-3))
r2 = irit.ruledsrf(c1, c2) * irit.ry(90)
irit.awidth(r2, 0.007)
c = irit.nth(
irit.rrinter(irit.cmesh(r1, irit.ROW, 0), irit.cmesh(r1, irit.ROW, 1),
irit.cmesh(r2, irit.ROW, 0), irit.cmesh(r2, irit.ROW, 1), 50,
0), 1)
irit.color(c, irit.RED)
irit.adwidth(c, 3)
irit.awidth(c, 0.02)
irit.attrib(c, "gray", irit.GenRealObject(0.5))
irit.interact(irit.list(r1, r2, c))
irit.save("rrint5a", irit.list(r1, r2, c))
while (i <= 5):
x1 = x1 ^ (x1 * irit.tx(irit.random(
(-2), 2)) * irit.ty(irit.random(
(-2), 2)) * irit.tz(irit.random((-0.002), 0.002)))
i = i + 1
i = 0
while (i <= 10):
irit.printf(
"%d), error = %f\n",
irit.list(
i,
irit.nth(
irit.fitpmodel(
x1 * irit.rx(irit.random(
(-90), 90)) * irit.ry(irit.random(
(-90), 90)) * irit.tz(irit.random((-2), 2)), 0,
1e-005, 100), 1)))
i = i + 1
# ############################################################################
irit.save("prim_fit", irit.list(planefit, spfit, cylfit, conefit))
irit.pause()
irit.free(x1)
irit.free(x2)
irit.free(planefit)
irit.free(spfit)
irit.free(cylfit)
irit.free(conefit)
