Пример #1
0
    def test_usage(self):
        mesh = osd.Topology(faces)
        mesh.boundaryMode = osd.BoundaryMode.EDGE_ONLY

        mesh.vertices[0].sharpness = 2.7
        self.assertAlmostEqual(mesh.vertices[0].sharpness, 2.7)

        self.assertEqual(len(mesh.vertices), len(verts) / len(dtype))
        self.assertEqual(len(mesh.faces), len(faces))
        self.assertEqual(len(mesh.faces[0].edges), len(faces[0]))

        mesh.finalize()

        subdivider = osd.Subdivider(
            mesh,
            vertexLayout = dtype,
            indexType = np.uint32,
            levels = 4)

        subdivider.setCoarseVertices(verts, np.float32)
        subdivider.refine()

        numQuads = len(subdivider.getRefinedQuads()) / 4
        numVerts = len(subdivider.getRefinedVertices()) / len(dtype)

        self.assertEqual(numQuads, 1536, "Unexpected number of refined quads")
        self.assertEqual(numVerts, 2056, "Unexpected number of refined verts")
Пример #2
0
    def test_Topology_creation(self):

        # Input data
        indices, valences = _flatten(faces)

        # Native list-of-lists, constant valence:
        mesh = osd.Topology(faces)
        self.assert_(mesh,
                     "Unable to construct Topology object from a list-of-lists")

        # Native list, constant valence:
        mesh = osd.Topology(indices, 4)
        self.assert_(mesh,
                     "Unable to construct Topology object from a list")

        # Native list-of-lists, variable valence:
        faces2 = faces + [(8,9,10)]
        mesh = osd.Topology(faces2)
        self.assert_(mesh,
                     "Unable to construct Topology object from a list of "
                     "variable-sized lists")

        # Two-dimensional numpy array:
        numpyFaces = np.array(indices, 'uint16').reshape(-1, 4)
        mesh = osd.Topology(numpyFaces)
        self.assert_(mesh,
                     "Unable to construct Topology object from a "
                     "two-dimensional numpy array")

        # Native index list and valence list:
        mesh = osd.Topology(indices, valences)
        self.assert_(mesh)
 
        # Numpy index list and valence list:
        indices = np.array(indices, 'uint16')
        valences = np.array(valences, 'uint8')
        mesh = osd.Topology(indices, valences)
        self.assert_(mesh)

        # Ensure various topology checks
        self.assertRaises(osd.OsdTypeError, osd.Topology, indices, None)
        self.assertRaises(osd.OsdTypeError, osd.Topology, faces, valences)
        faces2 = faces + [(8,9)]
        self.assertRaises(osd.TopoError, osd.Topology, faces2)
        valences2 = valences + [3]
        self.assertRaises(osd.TopoError, osd.Topology, indices, valences2)
Пример #3
0
def interactive():

    app = QtGui.QApplication(sys.argv)
    renderer = Renderer()
    win = Window(renderer)
    win.raise_()

    cage = [
        0.0,
        -1.414214,
        1.0,  # 0
        1.414214,
        0.0,
        1.0,  # 1
        -1.414214,
        0.0,
        1.0,  # 2
        0.0,
        1.414214,
        1.0,  # 3
        -1.414214,
        0.0,
        -1.0,  # 4
        0.0,
        1.414214,
        -1.0,  # 5
        0.0,
        -1.414214,
        -1.0,  # 6
        1.414214,
        0.0,
        -1.0
    ]  # 7

    cage = np.array(cage, np.float32).reshape((-1, 3))

    faces = [
        (0, 1, 3, 2),  # 0
        (2, 3, 5, 4),  # 1
        (4, 5, 7, 6),  # 2
        (6, 7, 1, 0),  # 3
        (1, 7, 5, 3),  # 4
        (6, 0, 2, 4)
    ]  # 5

    topo = osd.Topology(faces)

    dtype = [('x', np.float32), ('y', np.float32), ('z', np.float32)]

    def updateTopo(numLevels=4):
        global subdivider
        topo.reset()
        topo.finalize()
        subdivider = osd.Subdivider(topo,
                                    vertexLayout=dtype,
                                    indexType=np.uint32,
                                    levels=numLevels)
        quads = subdivider.getRefinedQuads()
        renderer.updateIndicesVbo(quads)

    def updateCoarseVertices():
        global subdivider
        subdivider.setCoarseVertices(cage)
        subdivider.refine()
        pts = subdivider.getRefinedVertices()
        renderer.updatePointsVbo(pts)

    updateTopo()
    updateCoarseVertices()

    renderer.drawHook = updateCoarseVertices

    # Start an interactive session
    import code
    from time import time
    timer = QtCore.QTimer()
    code.interact(local=dict(globals(), **locals()))

    sys.exit(0)
Пример #4
0
def main():

    app = QtGui.QApplication(sys.argv)
    renderer = Renderer()
    win = Window(renderer)
    win.raise_()

    verts = [
        0.0,
        -1.414214,
        1.0,  # 0
        1.414214,
        0.0,
        1.0,  # 1
        -1.414214,
        0.0,
        1.0,  # 2
        0.0,
        1.414214,
        1.0,  # 3
        -1.414214,
        0.0,
        -1.0,  # 4
        0.0,
        1.414214,
        -1.0,  # 5
        0.0,
        -1.414214,
        -1.0,  # 6
        1.414214,
        0.0,
        -1.0
    ]  # 7

    verts = np.array(verts, np.float32).reshape((-1, 3))

    faces = [
        (0, 1, 3, 2),  # 0
        (2, 3, 5, 4),  # 1
        (4, 5, 7, 6),  # 2
        (6, 7, 1, 0),  # 3
        (1, 7, 5, 3),  # 4
        (6, 0, 2, 4)
    ]  # 5

    topo = osd.Topology(faces)
    topo.boundaryMode = osd.BoundaryMode.EDGE_ONLY
    for v in (2, 3, 4, 5):
        topo.vertices[v].sharpness = 2.0
    for e in xrange(4):
        topo.faces[3].edges[e].sharpness = 3
    topo.finalize()

    subdivider = osd.Subdivider(topo,
                                vertexLayout='f4, f4, f4',
                                indexType=np.uint32,
                                levels=4)
    subdivider.setCoarseVertices(verts)
    subdivider.refine()
    inds = subdivider.getRefinedQuads()
    renderer.updateIndicesVbo(inds)

    def animateVerts():
        from time import time
        import math
        t = 4 * time()
        t = 0
        t = 0.5 + 0.5 * math.sin(t)
        t = 0.25 + t * 0.75
        a = np.array([0.0, -1.414214, 1.0])
        b = np.array([1.414214, 0.0, 1.0])
        c = np.array([0.0, -1.414214, -1.0])
        d = np.array([1.414214, 0.0, -1.0])
        center = (a + b + c + d) / 4
        center = np.multiply(center, 1 - t)
        verts[0] = center + np.multiply(a, t)
        verts[1] = center + np.multiply(b, t)
        verts[6] = center + np.multiply(c, t)
        verts[7] = center + np.multiply(d, t)

    def updateAnimation():
        animateVerts()
        subdivider.setCoarseVertices(verts)
        subdivider.refine()
        pts = subdivider.getRefinedVertices()
        renderer.updatePointsVbo(pts)

    updateAnimation()
    renderer.drawHook = updateAnimation
    retcode = app.exec_()
    sys.exit(retcode)