Esempio n. 1
0
def srfframecrvs(srf, width):
    umin = irit.nth(irit.pdomain(srf), 1)
    umax = irit.nth(irit.pdomain(srf), 2)
    vmin = irit.nth(irit.pdomain(srf), 3)
    vmax = irit.nth(irit.pdomain(srf), 4)
    retval = irit.list(
        irit.swpcircsrf(
            irit.csurface(srf, irit.COL, irit.FetchRealObject(umin)), width,
            0),
        irit.swpcircsrf(
            irit.csurface(srf, irit.COL,
                          irit.FetchRealObject((umin + umax) / 2.0)), width,
            0),
        irit.swpcircsrf(
            irit.csurface(srf, irit.COL, irit.FetchRealObject(umax)), width,
            0),
        irit.swpcircsrf(
            irit.csurface(srf, irit.ROW, irit.FetchRealObject(vmin)), width,
            0),
        irit.swpcircsrf(
            irit.csurface(srf, irit.ROW,
                          irit.FetchRealObject((vmin + vmax) / 2.0)), width,
            0),
        irit.swpcircsrf(
            irit.csurface(srf, irit.ROW, irit.FetchRealObject(vmax)), width,
            0))
    return retval
Esempio n. 2
0
irit.save("blending1", irit.list(s1, s2, s3))

irit.interact(irit.list(irit.GetAxes(), s1, s2, s3))

#
#  Blend on a (polynomial approximation of a) sphere:
#

s = (-irit.surfprev(
    irit.cregion(irit.pcircle((0, 0, 0), 1), 0, 2) * irit.rx(90)))
irit.attrprop(s, "u_resolution", irit.GenIntObject(3))
irit.attrprop(s, "v_resolution", irit.GenIntObject(3))
ds = irit.sderive(s, irit.ROW)

c1 = (-irit.csurface(s, irit.ROW, 0.8))
c2 = (-irit.csurface(s, irit.ROW, 1.2))

d1 = (-irit.csurface(ds, irit.ROW, 0.8))
d2 = (-irit.csurface(ds, irit.ROW, 1.2))

s1 = irit.hermite(c1, c2, d1, d2)
irit.color(s1, irit.RED)

n = irit.csurface(s, irit.ROW, 1)

s2 = irit.blhermite(c1, c2, d1, d2, csec1, n)
irit.color(s2, irit.GREEN)

csec2 = irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, (-1 ), 0 ), \
                                     irit.ctlpt( irit.E2, (-1 ), 0 ), \
Esempio n. 3
0
motion = irit.creparam( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E2, 0, 0 ), \
                                                     irit.ctlpt( irit.E2, (-0.6 ), 0 ), \
                                                     irit.ctlpt( irit.E2, (-0.6 ), (-0.6 ) ), \
                                                     irit.ctlpt( irit.E2, 0, (-1.8 ) ), \
                                                     irit.ctlpt( irit.E2, 0.1, (-1.8 ) ), \
                                                     irit.ctlpt( irit.E2, 0.3, 0 ), \
                                                     irit.ctlpt( irit.E2, 0.3, 0.3 ), \
                                                     irit.ctlpt( irit.E2, 0, 0 ) ), irit.list( irit.KV_OPEN ) ), 0, 1 )

a = 0
while (a <= 1):
    pt = irit.ceval(motion, a)
    c1 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, 0, 0, (-1 ) ), \
                                   irit.ctlpt( irit.E3, 0, 0, 0 ) ) ) * irit.tx( irit.FetchRealObject(irit.coord( pt, 1 )) ) * irit.ty( irit.FetchRealObject(irit.coord( pt, 2 )) )
    bisectsrf = irit.cbisector3d(irit.list(c1, circ), 1)
    isocrv = irit.csurface(bisectsrf, irit.COL, 1)
    irit.color(isocrv, irit.GREEN)
    irit.adwidth(isocrv, 3)
    pt = irit.ceval(c1, 1)
    irit.color(pt, irit.GREEN)
    display2(c1, circ, bisectsrf, isocrv, pt)
    a = a + 0.01 * speed


c2 = irit.cbezier( irit.list( irit.ctlpt( irit.E3, (-1 ), (-1 ), 0 ), \
                              irit.ctlpt( irit.E3, 0, 2.1, 0 ), \
                              irit.ctlpt( irit.E3, 1, (-1 ), 0 ) ) )
irit.ffcompat(c2, circ)

a = 0
while (a <= 1):
Esempio n. 4
0
c1 = ( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0, 0, 0 ), \
                                    irit.ctlpt( irit.E3, 0.5, 0.07, 0 ), \
                                    irit.ctlpt( irit.E3, 1, 0, 0 ) ), irit.list( irit.KV_OPEN ) ) + irit.cbspline( 3, irit.list( \
                                    irit.ctlpt( irit.E3, 1, 0, 0 ), \
                                    irit.ctlpt( irit.E3, 0.5, (-0.07 ), 0 ), \
                                    irit.ctlpt( irit.E3, 0, 0, 0 ) ), irit.list( irit.KV_OPEN ) ) )

eng1c1 = c1 * irit.scale( ( 2.5, 1, 2.5 ) ) * irit.trans( ( 3.45, 1.5, (-0.44 ) ) )
eng2c1 = c1 * irit.scale( ( 1.7, 1, 1.7 ) ) * irit.trans( ( 6.8, 2.6, (-0.24 ) ) )

# 
#  The extraction of the wing profiles just above the engines to make
#  sure the engine holder do not over/under shoot. The commented interaction
#  commands below will display the relevat curves of the engine holder.
# 
wingprof1 = irit.csurface( lwingmain, irit.ROW, 0.4 )
irit.color( wingprof1, irit.GREEN )
wingprof2 = irit.csurface( lwingmain, irit.ROW, 0.78 )
irit.color( wingprof2, irit.GREEN )
irit.free( lwingmain )

eng1c2 = c1 * irit.roty( 3 ) * irit.scale( ( 2, 1, 2.5 ) ) * irit.trans( ( 5.55, 1.5, 0.1 ) )
#  interact( list( Eng1Body, Eng1c1, Eng1c2, Eng1Holder, wingProf1 ) );
eng2c2 = c1 * irit.roty( 3.5 ) * irit.scale( ( 1.2, 1, 1.2 ) ) * irit.trans( ( 7.4, 2.6, (-0.03 ) ) )
#  interact( list( Eng2Body, Eng2c1, Eng2c2, wingProf2 ) );

eng1holder = irit.ruledsrf( eng1c2, eng1c1 )
if ( do_texture == 1 ):
    irit.attrib( eng1holder, "texture", texture )
irit.attrib( eng1holder, "rgb", irit.GenStrObject(graycolor) )
irit.color( eng1holder, irit.WHITE )
Esempio n. 5
0
cb1 = irit.coerce(cb, irit.E3)

irit.printf(
    "c/sderive tests = %d  %d  %d\n",
    irit.list(cb1 == irit.cderive(irit.cinteg(cb1)),
              sb == irit.sderive(irit.sinteg(sb, irit.ROW), irit.ROW),
              sb == irit.sderive(irit.sinteg(sb, irit.COL), irit.COL)))

#
#  Iso curves extraction from surface.
#
cb_all = irit.list(irit.GetAxes())
irit.snoc(sb, cb_all)
t = 0.1
while (t <= 0.9):
    cb1 = irit.csurface(sb, irit.COL, t)
    irit.color(cb1, irit.GREEN)
    irit.snoc(cb1, cb_all)
    t = t + 0.1
t = 0.1
while (t <= 0.9):
    cb1 = irit.csurface(sb, irit.ROW, t)
    irit.color(cb1, irit.GREEN)
    irit.snoc(cb1, cb_all)
    t = t + 0.1
if (display == 1):
    irit.interact(cb_all)

#
#  curves extraction from surface mesh. Note curves may be not on the surface.
#
Esempio n. 6
0
i = 0
while ( i <= 7 ):
    irit.snoc(  irit.point( math.cos( i * 2 * math.pi/8 ), math.sin( i * 2 * 3.14159/8 ), 0 ), ptlist )
    i = i + 1

c1 = irit.coerce( irit.cbspline( 3, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.rz( (-22.5 ) )
c2 = irit.coerce( irit.cbspline( 2, ptlist, irit.list( irit.KV_PERIODIC ) ), irit.KV_OPEN ) * irit.sc( 1.1 )
irit.free( ptlist )

minsize = 0.01
body = irit.sfromcrvs( irit.list( c2 * irit.sc( minsize ) * irit.tz( 0.05 ), c2 * irit.sc( 0.7 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.8 ) * irit.tz( 0.05 ), c2 * irit.sc( 0.9 ), c2, c2 * irit.tz( 2 ), c2 * irit.tz( 2.2 ), c1 * irit.tz( 2.2 ), c1 * irit.tz( 2 ), c1 * irit.tz( 0.4 ), c1 * irit.sc( 0.5 ) * irit.tz( 0.2 ), c1 * irit.sc( minsize ) * irit.tz( 0.2 ) ), 3, irit.KV_OPEN )
irit.free( c1 )
irit.free( c2 )


cbody = irit.csurface( irit.coerce( body, irit.KV_OPEN ), irit.COL, 1 )

cbodyin = irit.cregion( cbody, 0.6, 1 )
irit.color( cbodyin, irit.RED )
irit.adwidth( cbodyin, 3 )
cbodyout = (-irit.cregion( cbody, 0, 0.6 ) )
irit.color( cbodyout, irit.GREEN )
irit.adwidth( cbodyout, 3 )

ruled1 = irit.ruledsrf( cbodyin, cbodyout )
irit.interact( irit.list( ruled1, cbodyout, cbodyin ) )
irit.save( "distmtc1", irit.list( ruled1, cbodyout, cbodyin ) )

cbodyin2 = irit.ffmatch( cbodyout, cbodyin, 30, 100, 2, 0,\
(-1 ) )
irit.color( cbodyin2, irit.RED )
Esempio n. 7
0
tea3 = teapot * irit.tz( 5 ) 

irit.SetViewMatrix(  irit.scale( ( 0.15, 0.15, 0.15 ) ) * irit.rx( 50 ) * irit.ry( 40 ) * irit.tx( (-0.7 ) ) * irit.ty( 0.2 ))
irit.interact( irit.list( irit.GetViewMatrix(), teapot, tea1, tea2, tea3 ) )
irit.free( tea1 )
irit.free( tea2 )
irit.free( tea3 )

# 
#  Extract Isocurves from the teapot surfaces.
# 

# 
#  Body
# 
tmp = irit.csurface( body, irit.COL, 0 )
irit.color( tmp, irit.YELLOW )
bodyiso = irit.list( tmp )
t = 0.3
while ( t <= 3.01 ):
    tmp = irit.csurface( body, irit.COL, t )
    irit.color( tmp, irit.YELLOW )
    irit.snoc( tmp, bodyiso )
    t = t + 0.3
t = 0.3
while ( t <= 3.91 ):
    tmp = irit.csurface( body, irit.ROW, t )
    irit.color( tmp, irit.YELLOW )
    irit.snoc( tmp, bodyiso )
    t = t + 0.3
Esempio n. 8
0
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))

printtest("mfrommv", irit.strivar(t, irit.COL, 0.16),
          irit.coerce(irit.mfrommv(mt, 0, 0.16), irit.SURFACE_TYPE))
printtest("mfrommv", irit.strivar(t, irit.ROW, 0.96),
          irit.coerce(irit.mfrommv(mt, 1, 0.96), irit.SURFACE_TYPE))
printtest("mfrommv", irit.strivar(t, irit.DEPTH, 0.66),
          irit.coerce(irit.mfrommv(mt, 2, 0.66), irit.SURFACE_TYPE))

printtest("mfrommesh", irit.cmesh(s, irit.ROW, 2),
          irit.coerce(irit.mfrommesh(ms, 1, 2), irit.CURVE_TYPE))
Esempio n. 9
0
                                           irit.ctlpt( irit.E2, (-0.5 ), (-0.3 ) ), \
                                           irit.ctlpt( irit.E2, (-0.5 ), 0 ), \
                                           irit.ctlpt( irit.E2, (-0.5 ), 0.05 ), \
                                           irit.ctlpt( irit.E2, (-0.45 ), 0.05 ), \
                                           irit.ctlpt( irit.E2, (-0.45 ), (-0.25 ) ), \
                                           irit.ctlpt( irit.E2, 0, (-0.45 ) ), \
                                           irit.ctlpt( irit.E2, 0.45, (-0.25 ) ), \
                                           irit.ctlpt( irit.E2, 0.45, 0.05 ), \
                                           irit.ctlpt( irit.E2, 0.5, 0.05 ), \
                                           irit.ctlpt( irit.E2, 0.5, 0 ), \
                                           irit.ctlpt( irit.E2, 0.5, (-0.3 ) ), \
                                           irit.ctlpt( irit.E2, 0.1, (-0.5 ) ), \
                                           irit.ctlpt( irit.E2, 0, (-0.5 ) ) ), irit.list( irit.KV_OPEN ) )
rslideslopesrf = (-irit.sweepsrf( irit.coerce( rslidecross, irit.E3 ) * irit.scale( ( 0.7, 0.7, 0.7 ) ), rslidehelix2, irit.vector( 0, 0, 1 ) ) )
irit.attrib( rslideslopesrf, "resolution", irit.GenRealObject(2 ))
rslideslopeendcrv = irit.csurface( rslideslopesrf, irit.ROW, 12.7243 )
rslideslopeend = irit.list( irit.ruledsrf( irit.cregion( rslideslopeendcrv, 0, 0.25 ), (-irit.cregion( rslideslopeendcrv, 0.25, 0.5 ) ) ), irit.ruledsrf( irit.cregion( rslideslopeendcrv, 0.5, 0.75 ), (-irit.cregion( rslideslopeendcrv, 0.75, 1 ) ) ) )
rslideslope = irit.list( rslideslopeend, rslideslopesrf )
irit.color( rslideslope, irit.YELLOW )
irit.attrib( rslideslope, "reflect", irit.GenRealObject(0.5 ))
irit.attrib( rslideslope, "rgb", irit.GenStrObject("255,255,55" ))
irit.free( rslidehelix2 )
irit.free( rslidecross )
irit.free( rslideslopeend )
irit.free( rslideslopeendcrv )
irit.free( rslideslopesrf )

rslidecenter = irit.surfrev( irit.cbspline( 3, irit.list( irit.ctlpt( irit.E3, 0.1, 0, 0 ), \
                                                          irit.ctlpt( irit.E3, 0.1, 0, 1.1 ), \
                                                          irit.ctlpt( irit.E3, 0.11, 0, 1.1 ), \
                                                          irit.ctlpt( irit.E3, 0.11, 0, 1.11 ), \
Esempio n. 10
0
                                     irit.ctlpt( irit.E2, 0.4, 0.75 ), \
                                     irit.ctlpt( irit.E2, 0.2, 0.75 ), \
                                     irit.ctlpt( irit.E2, 0.2, 0.25 ), \
                                     irit.ctlpt( irit.E2, 0.5, 0.25 ) ), irit.list( irit.KV_OPEN ) )
tsrf1 = irit.trimsrf(srf1, tcrv1, 0)
irit.attrib(tsrf1, "resolution", irit.GenIntObject(2))

crv1 = irit.compose(srf1, tcrv1)
irit.free(srf1)
irit.free(tcrv1)
irit.color(crv1, irit.GREEN)

pc = irit.crefine(irit.pcircle(((-1.7), (-1), 1), 0.4), 0, irit.list(1, 2, 3))
srf2 = irit.ruledsrf( irit.ceditpt( irit.ceditpt( pc, irit.ctlpt( irit.E3, (-2.1 ), (-1 ), 1.2 ), 9 ), \
                                                      irit.ctlpt( irit.E3, (-1.3 ), (-1 ), 1.2 ), 3 ), pc * irit.tz( 1 ) ) * irit.rotz( (-90 ) ) * irit.trans( ( 2.7, (-0.7 ), 0 ) )
crv2 = irit.csurface(srf2, irit.ROW, 0)
irit.color(crv2, irit.GREEN)
irit.free(pc)

tan1 = irit.symbdiff(
    crv1 * irit.scale((0.6, 0.4, 1)) * irit.trans((0.7, 0.6, 0)), crv1)
tan2 = irit.pcircle((0, 0, 3), 0)

blend = irit.hermite(crv1, (-crv2), tan1 * irit.sc(1), (-tan2) * irit.sc(1))
irit.color(blend, irit.RED)
irit.attrib(blend, "width", irit.GenRealObject(0.02))

all = irit.list(blend, tsrf1, (-srf2))
irit.interact(all)
irit.save("blend1", all)
Esempio n. 11
0
                                 irit.ctlpt( irit.E3, 0.7, 0, 0.8 ), \
                                 irit.ctlpt( irit.E3, 0.2, 0.4, 1 ), \
                                 irit.ctlpt( irit.E3, 0.4, 0.5, 1 ), \
                                 irit.ctlpt( irit.E3, 0.5, 1, 0.7 ) ) )
irit.color(b, irit.GREEN)

bmesh = irit.ffmesh(b)
irit.color(bmesh, irit.RED)

irit.interact(irit.list(b, bmesh))
irit.free(bmesh)

isos = irit.nil()
i = 0
while (i <= 1):
    irit.snoc(irit.csurface(b, irit.ROW, i), isos)
    i = i + 0.1
i = 0
while (i <= 1):
    irit.snoc(irit.csurface(b, irit.COL, i), isos)
    i = i + 0.25
i = 0
while (i <= 1):
    irit.snoc(irit.csurface(b, irit.DEPTH, i), isos)
    i = i + 1 / 3.0
irit.interact(isos)
irit.free(isos)

polygns = irit.gpolygon(b, 1)
irit.color(polygns, irit.RED)
irit.interact(irit.list(b, polygns))