Ejemplo n.º 1
0
steps = 50

m = ivw.regression.Measurements()

network = inviwopy.app.network
canvas = network.CanvasGL

orgsize = canvas.size

with ivw.camera.Camera(network.EntryExitPoints.camera,
                       lookfrom=vec3(0, 4, 0),
                       lookto=vec3(0, 0, 0),
                       lookup=vec3(0, 0, 1)) as c:
    for size in [256, 512, 768, 1024]:
        canvas.size = size2_t(size, size)
        ivw.regression.saveCanvas(canvas,
                                  "CanvasGL-" + str(size) + "x" + str(size))

        start = time.perf_counter()
        for step in c.rotate(math.pi / steps, steps, vec3(0, 1, 0)):
            inviwoqt.update()
        end = time.perf_counter()
        frametime = (end - start) / steps
        fps = 1.0 / frametime

        m.addFrequency('FPS-' + str(size) + 'x' + str(size), fps)

m.save()
canvas.size = orgsize
Ejemplo n.º 2
0
import inviwopy
import inviwopy.glm as glm

app = inviwopy.app
network = app.network

app.network.clear()
app.network.lock()

bg = app.processorFactory.create("org.inviwo.Background", glm.ivec2(0, -100))
bg.backgroundStyle.selectedDisplayName = "Uniform color"
bg.bgColor1.value = glm.vec4(1, 1, 1, 1)

canvas = app.processorFactory.create("org.inviwo.CanvasGL", glm.ivec2(0, 0))
canvas.inputSize.dimensions.value = glm.size2_t(256, 600)

network.addProcessor(bg)
network.addProcessor(canvas)

proc = app.processorFactory.create("org.inviwo.TextOverlayGL")

fontNames = proc.font.fontFace.displayNames
fontIdentifiers = proc.font.fontFace.identifiers

prev = bg

fontSize = 16
processorSpacing = 50
# vertical spacing of text
vertTextSpacing = 1.0 / len(fontNames)
    def setup_network(self, filepath):
        app = self.app
        network = app.network
        factory = app.processorFactory

        # start with a clean network
        network.clear()

        #hdf_fermi_source = factory.create('org.inviwo.HDF5FermiSource', glm.ivec2(0,0))
        self.hdf_fermi_source = HDF5FermiSource('fermi', 'fermi source')
        self.hdf_fermi_source.filename.value = filepath
        network.addProcessor(self.hdf_fermi_source)

        cube_proxy_geometry = factory.create('org.inviwo.CubeProxyGeometry',
                                             glm.ivec2(50, 100))
        network.addProcessor(cube_proxy_geometry)

        network.addConnection(self.hdf_fermi_source.getOutport('outport'),
                              cube_proxy_geometry.getInport('volume'))

        volume_bounding_box = factory.create('org.inviwo.VolumeBoundingBox',
                                             glm.ivec2(250, 100))
        network.addProcessor(volume_bounding_box)

        network.addConnection(self.hdf_fermi_source.getOutport('outport'),
                              volume_bounding_box.getInport('volume'))

        background = factory.create('org.inviwo.Background',
                                    glm.ivec2(450, 100))
        network.addProcessor(background)

        entry_exit_points = factory.create('org.inviwo.EntryExitPoints',
                                           glm.ivec2(50, 200))
        network.addProcessor(entry_exit_points)

        network.addConnection(cube_proxy_geometry.getOutport('proxyGeometry'),
                              entry_exit_points.getInport('geometry'))

        mesh_renderer = factory.create('org.inviwo.GeometryRenderGL',
                                       glm.ivec2(250, 200))
        network.addProcessor(mesh_renderer)

        network.addConnection(volume_bounding_box.getOutport('mesh'),
                              mesh_renderer.getInport('geometry'))

        network.addConnection(background.getOutport('outport'),
                              mesh_renderer.getInport('imageInport'))

        network.addLink(mesh_renderer.getPropertyByIdentifier('camera'),
                        entry_exit_points.getPropertyByIdentifier('camera'))

        self.iso_raycaster = factory.create('org.inviwo.ISORaycaster',
                                            glm.ivec2(0, 300))
        network.addProcessor(self.iso_raycaster)

        network.addConnection(self.hdf_fermi_source.getOutport('outport'),
                              self.iso_raycaster.getInport('volume'))

        network.addConnection(entry_exit_points.getOutport('entry'),
                              self.iso_raycaster.getInport('entry'))

        network.addConnection(entry_exit_points.getOutport('exit'),
                              self.iso_raycaster.getInport('exit'))

        network.addConnection(mesh_renderer.getOutport('image'),
                              self.iso_raycaster.getInport('bg'))

        network.addLink(
            self.hdf_fermi_source.getPropertyByIdentifier('fermi_level'),
            self.iso_raycaster.raycasting.getPropertyByIdentifier('isoValue'))

        canvas = factory.create('org.inviwo.CanvasGL', glm.ivec2(0, 400))
        network.addProcessor(canvas)

        network.addConnection(self.iso_raycaster.getOutport('outport'),
                              canvas.getInport('inport'))

        network.addLink(entry_exit_points.getPropertyByIdentifier('camera'),
                        self.iso_raycaster.getPropertyByIdentifier('camera'))

        canvas.inputSize.dimensions.value = glm.size2_t(500, 500)
        canvas.widget.show()