예제 #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
예제 #2
0
def subdivtodepth(tsrf, dpth, vu, vv):
    if (dpth <= 0):
        retval = tsrf
    else:
        if (dpth / 2.0 != math.floor(dpth / 2.0)):
            v = vu * (2 ^ (dpth - 1))
            umin = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 1))
            umax = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 2))
            tsrfs = irit.sdivide(tsrf, irit.COL, umin * 0.4999 + umax * 0.5001)
        else:
            v = vv * (2 ^ (dpth - 1))
            vmin = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 3))
            vmax = irit.FetchRealObject(irit.nth(irit.pdomain(tsrf), 4))
            tsrfs = irit.sdivide(tsrf, irit.ROW, vmin * 0.4999 + vmax * 0.5001)
        if (irit.SizeOf(tsrfs) == 2):
            retval = irit.list( subdivtodepth( irit.nth( tsrfs, 1 ) * \
              irit.trans( irit.Fetch3TupleObject(-v) ),
              dpth - 1,
              vu,
              vv ),
            subdivtodepth( irit.nth( tsrfs, 2 ) * \
              irit.trans( irit.Fetch3TupleObject(v) ),
              dpth - 1,
              vu,
              vv ) )
        else:
            retval = subdivtodepth(irit.nth(tsrfs, 1), dpth - 1, vu, vv)
    return retval
예제 #3
0
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
예제 #4
0
def evaltv(tv, ulen, vlen, wlen):
    retval = irit.nil()
    dom = irit.pdomain(tv)
    i = 0
    while (i <= ulen - 1):
        u = irit.FetchRealObject(irit.nth(dom, 1)) + i * irit.FetchRealObject(
            irit.nth(dom, 2) - irit.nth(dom, 1)) / float(ulen - 1)
        lst2 = irit.nil()
        j = 0
        while (j <= vlen - 1):
            v = irit.FetchRealObject(irit.nth(
                dom, 3)) + j * irit.FetchRealObject(
                    irit.nth(dom, 4) - irit.nth(dom, 3)) / float(vlen - 1)
            lst3 = irit.nil()
            k = 0
            while (k <= wlen - 1):
                w = irit.FetchRealObject(irit.nth(
                    dom, 5)) + k * irit.FetchRealObject(
                        irit.nth(dom, 6) - irit.nth(dom, 5)) / float(wlen - 1)
                irit.snoc(irit.teval(tv, u, v, w), lst3)
                k = k + 1
            irit.snoc(lst3 * irit.tx(0), lst2)
            j = j + 1
        irit.snoc(lst2 * irit.tx(0), retval)
        i = i + 1
    retval = irit.tbezier(retval)
    return retval
예제 #5
0
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
예제 #6
0
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
예제 #7
0
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
예제 #8
0
def cnvrtcrvs2domains( crvs, theta ):
    retval = irit.nil(  )
    i = 1
    while ( i <= irit.SizeOf( crvs ) ):
        dm = irit.pdomain( irit.nth( crvs, i ) )
        irit.snoc( irit.ctlpt( irit.E2, theta, irit.nth( dm, 1 ) ) + \
                    irit.ctlpt( irit.E2, theta, irit.nth( dm, 2 ) ), retval )
        i = i + 1
    return retval
예제 #9
0
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
예제 #10
0
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
예제 #11
0
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
예제 #12
0
morphpage(page1, page2, 0.1)
morphpage(page2, page3, 0.1)
morphpage(page3, page4, 0.1)
morphpage(page4, page5, 0.1)
morphpage(page5, page6, 0.1)

i = 1
while (i <= irit.SizeOf(srfmorphlist)):
    irit.view(irit.nth(srfmorphlist, i), irit.ON)
    i = i + 1
irit.free(srfmorphlist)

tv1 = irit.tfromsrfs( irit.list( page1, page2, page3, page4, page5, page6 ),\
3, irit.KV_OPEN )
irit.interact(tv1)
wmin = irit.FetchRealObject(irit.nth(irit.pdomain(tv1), 5))
wmax = irit.FetchRealObject(irit.nth(irit.pdomain(tv1), 6))
i = 0
while (i <= 100):
    irit.view(
        irit.strivar(tv1, irit.DEPTH, (wmin * (100 - i) + wmax * i) / 100),
        irit.ON)
    i = i + 1

tv1 = irit.tfromsrfs( irit.list( page1, page2, page3, page4, page5, page6 ),\
4, irit.KV_OPEN )
irit.interact(tv1)
wmin = irit.FetchRealObject(irit.nth(irit.pdomain(tv1), 5))
wmax = irit.FetchRealObject(irit.nth(irit.pdomain(tv1), 6))
i = 0
while (i <= 100):
예제 #13
0
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))
예제 #14
0
irit.color(polylns, irit.MAGENTA)
irit.interact(irit.list(b, polylns))
irit.free(polylns)

be2 = irit.coerce(b, irit.E2)
irit.color(b, irit.RED)

p = irit.tseval(b, 1 / 3.0, 1 / 3.0, 1 / 3.0)
n = irit.tsnormal(b, 1 / 3.0, 1 / 3.0, 1 / 3.0)
nrml = (irit.coerce(p, irit.E3) +
        irit.coerce(irit.coerce(p, irit.POINT_TYPE) + n, irit.E3))

irit.save(
    "trisrf1",
    irit.list(b, be2, p, n, nrml, irit.fforder(b), irit.ffmsize(b),
              irit.ffctlpts(b), irit.pdomain(b), irit.tseval(b, 0, 0, 1),
              irit.tseval(b, 0, 1, 0), irit.tseval(b, 1, 0, 0),
              irit.tseval(b, 1 / 3.0, 1 / 3.0, 1 / 3.0),
              irit.tsnormal(b, 1 / 3.0, 1 / 3.0, 1 / 3.0)))

irit.interact(irit.list(b, be2, nrml, p))
irit.free(b)
irit.free(be2)




c = irit.tsbezier( 4, irit.list( irit.ctlpt( irit.E3, 0, (-0.3 ), 0 ), \
                                 irit.ctlpt( irit.E3, 0.2, (-0.5 ), (-0.2 ) ), \
                                 irit.ctlpt( irit.E3, 0.6, (-0.3 ), 0.2 ), \
                                 irit.ctlpt( irit.E3, 0.9, (-0.4 ), 0.1 ), \
예제 #15
0
          irit.meval(irit.coerce(mv1, irit.KV_FLOAT), irit.list(1, 1, 3)),
          irit.meval(mv1, irit.list(1, 1, 3)))

mv1 = irit.coerce(
    irit.tfromsrfs(
        irit.list(s1,
                  s1 * irit.tx(0.25) * irit.ty(0.5) * irit.tz(0.8),
                  s1 * irit.tz(2)), 3, irit.KV_FLOAT), irit.MULTIVAR_TYPE)
printtest("coerce",
          irit.meval(irit.coerce(mv1, irit.KV_OPEN), irit.list(0, 0, 0)),
          irit.meval(mv1, irit.list(0, 0, 0)))
printtest("coerce",
          irit.meval(irit.coerce(mv1, irit.KV_OPEN), irit.list(1, 1, 1)),
          irit.meval(mv1, irit.list(1, 1, 1)))

printtest("pdomain", irit.pdomain(mc), irit.pdomain(c))
printtest("pdomain", irit.pdomain(ms), irit.pdomain(s))
printtest("pdomain", irit.pdomain(mt), irit.pdomain(t))

printtest("meval", irit.meval(mc, irit.list(0.3)), irit.ceval(c, 0.3))
printtest("meval", irit.meval(mc, irit.list(0.65)), irit.ceval(c, 0.65))

printtest("meval", irit.meval(ms, irit.list(0.3, 0.7)),
          irit.seval(s, 0.3, 0.7))
printtest("meval", irit.meval(ms, irit.list(0.65, 0.21)),
          irit.seval(s, 0.65, 0.21))
printtest("meval", irit.meval(ms3, irit.list(0.65, 0.21)),
          irit.seval(s3, 0.65, 0.21))
printtest("meval", irit.meval(mt, irit.list(0.123, 0.456, 0.789)),
          irit.teval(t, 0.123, 0.456, 0.789))
printtest("meval", irit.meval(mt, irit.list(0.321, 0.987, 0.654)),
예제 #16
0
dlevel = irit.iritstate("dumplevel", dlevel)
irit.free(dlevel)

tv1t = tv1 * irit.rotx(50) * irit.trans((1.5, (-1.5), 2))
irit.color(tv1t, irit.RED)
tv2t = tv2 * irit.sc(0.75) * irit.trans(((-1.5), 1.5, (-2)))
irit.color(tv2t, irit.GREEN)

irit.interact(irit.list(tv1, tv1t))
irit.interact(irit.list(tv2, tv2t))


irit.save( "trivar2a", irit.list( irit.list( tv1, tv1t ), \
         irit.list( tv2, tv2t ) * irit.tx( 3 ), \
         irit.list( irit.fforder( tv1 ), irit.ffctlpts( tv1 ), irit.ffmsize( tv1 ), \
      irit.pdomain( tv1 ), irit.fforder( tv2 ), irit.ffmsize( tv2 ), \
      irit.ffkntvec( tv2 ), irit.ffctlpts( tv2 ), irit.pdomain( tv2t ) ), \
         irit.list( irit.tvolume( tv1, 1 ), irit.tvolume( tv1t, 1 ), \
      irit.tvolume( tv2, 1 ), irit.tvolume( tv2t, 1 ) ) ) )

irit.free(tv1t)
irit.free(tv2t)

#
# Point inclusion
#

irit.tpinclude(tv2, (0, 0, 0), 20)  # Prep. aux data.

pts = irit.nil()
x = -1
예제 #17
0
    "trimsrf7",
    irit.list(offtsrf3a, tsrf3a, irit.seval(tsrf1a, 0.5, 0.5),
              irit.stangent(tsrf1a, irit.ROW, 0.5, 0.5, 1),
              irit.stangent(tsrf1a, irit.COL, 0.5, 0.5, 1),
              irit.snormal(tsrf1a, 0.5, 0.5), irit.seval(tsrf3a, 0.5, 0.5),
              irit.stangent(tsrf3a, irit.ROW, 0.5, 0.5, 1),
              irit.stangent(tsrf3a, irit.COL, 0.5, 0.5, 1),
              irit.snormal(tsrf3a, 0.5, 0.5)))

irit.interact(irit.strimsrf(tsrf1a))
irit.interact(irit.ctrimsrf(tsrf1a, 1))
irit.interact(irit.ctrimsrf(tsrf3a, 0))

irit.save(
    "trimsrf8",
    irit.list(irit.pdomain(tsrf1a), irit.pdomain(tsrf3b),
              irit.strimsrf(tsrf1a), irit.ctrimsrf(tsrf1a, 1)))

irit.free(s1)
irit.free(s2)

irit.save("trimsrf9", irit.list(tsrf2a, tsrf3b))
irit.printf("trim surfaces save/load test = %d\n",
            irit.list(irit.load("trimsrf9") == irit.list(tsrf2a, tsrf3b)))

# ############################################################################

irit.free(offtsrf3a)
irit.free(tsrf2bp)
irit.free(tsrf2ap)
irit.free(tsrf1a)
예제 #18
0
irit.free( crvsdm )
irit.free( vdir )
irit.free( crvse3 )

# ############################################################################
# 
#  View point almost on the boundary from inside (art gallery guards)
# 


res = irit.nil(  )
i = 1
while ( i <= irit.SizeOf( crvs ) ):
    c = irit.nth( crvs, i )
    co = irit.offset( c, irit.GenRealObject(-0.0001 ), 1e-006, 0 )
    tmin = irit.FetchRealObject( irit.nth( irit.pdomain( co ), 1 ) )
    tmax = irit.FetchRealObject( irit.nth( irit.pdomain( co ), 2 ) )
    dt = 0.06
    t = tmin
    while ( t <= tmax ):
        pt = irit.coerce( irit.ceval( co, t ), irit.POINT_TYPE )
        irit.adwidth( pt, 3 )
        irit.color( pt, irit.CYAN )
        vc = irit.cvisible( c, irit.Fetch3TupleObject( pt * irit.tz( 1 ) ), 1e-005 )
        irit.adwidth( vc, 3 )
        irit.color( vc, irit.YELLOW )
        if ( t == 0.12 or t == 0.36 or t == 0.6 or t == 0.84 ):
            irit.snoc( irit.list( pt, vc, c ) * irit.ty( i * 1.6 ) * irit.tx( t * 7 ), res )
        irit.view( irit.list( pt, vc, c ), irit.ON )
        t = t + dt
    i = i + 1