Python transforms.ortho函数代码示例

 def resize(self, width, height):
     gloo.set_viewport(0, 0, width, height)
     data_width = self._data_lim[0][1] - self._data_lim[0][0]
     data_height = self._data_lim[1][1] - self._data_lim[1][0]
     data_aspect = data_width / float(data_height)
     frame_aspect = width / float(height)
     if frame_aspect >= data_aspect:
         padding = (frame_aspect * data_height - data_width) / 2.
         frame_lim = [
             [self._data_lim[0][0] - padding,
              self._data_lim[0][1] + padding],
             [self._data_lim[1][0],
              self._data_lim[1][1]]]
     else:
         padding = (data_width / frame_aspect - data_height) / 2.
         frame_lim = [
             [self._data_lim[0][0],
              self._data_lim[0][1]],
             [self._data_lim[1][0] - padding,
              self._data_lim[1][1] + padding]]
     args_ortho = frame_lim[0][::(1 if self._dir_x_right else -1)]
     args_ortho += frame_lim[1][::(1 if self._dir_y_top else -1)]
     args_ortho += -1000, 1000
     self.projection = ortho(*args_ortho)
     self.program['projection'] = self.projection

    def __init__(self):
        app.Canvas.__init__(self, keys='interactive', size=((W * 5), (H * 5)))

        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
        self.texture = gloo.Texture2D(I, interpolation='linear')

        self.program['u_texture'] = self.texture
        self.program.bind(gloo.VertexBuffer(data))

        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.projection = ortho(0, W, 0, H, -1, 1)
        self.program['u_projection'] = self.projection

        gloo.set_clear_color('white')

        self._timer = app.Timer('auto', connect=self.update, start=True)

        self.sim_is_initialized = False
        self.sim = None

        self.show()

 def toggle_projection(self, event=None):
     """Toggle between perspective and orthonormal projection modes."""
     self.perspective = not self.perspective
     if self.perspective:
         self.volume_renderer.set_vol_projection(perspective(60, 1., 100, 0))
     else:
         self.volume_renderer.set_vol_projection(ortho(-1, 1, -1, 1, -1000, 1000))

    def __init__(self):
        app.Canvas.__init__(self, keys='interactive')
        self.size = W * 5, H * 5

        self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
        self.texture = gloo.Texture3D(I, interpolation='nearest',
                                      wrapping='clamp_to_edge')
        self.program['u_texture'] = self.texture
        self.program['i'] = 0.0
        self.program.bind(gloo.VertexBuffer(data))

        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.projection = ortho(0, W, 0, H, -1, 1)
        self.program['u_projection'] = self.projection

        self.i = 0

        gloo.set_clear_color('white')

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    # Do a series of rotations that should end up into the same orientation
    # again, to ensure the order of computation is all correct
    # i.e. if rotated would return the transposed matrix this would not work
    # out (the translation part would be incorrect)
    new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0))))
    new_xfm = new_xfm.dot(rotate(90, (1, 0, 0)))
    assert_allclose(xfm, new_xfm)

    new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

 def on_resize(self, event):
     width, height = event.size
     self.width=width
     self.height=height
     gloo.set_viewport(0, 0, width, height)
     self.projection = ortho(-self.scale/2, self.scale/2, -self.scale/2, self.scale/2, -1, 100) #perspective(1.0, width / float(height), 1.0, 10000000.0)
     self.program['u_projection'] = self.projection

 def on_mouse_wheel(self, event):
     #print(event.delta[1])
     oldscale=self.scale
     if event.delta[1]>0:
         self.scale /=event.delta[1]+1
     else:
         self.scale *= -event.delta[1]+1
     factor=self.scale/oldscale
     self.event=event
     self.projection = ortho(-self.scale/2, self.scale/2, -self.scale/2, self.scale/2, -1, 100) #perspective(1.0, width / float(height), 1.0, 10000000.0)
     self.program['u_projection'] = self.projection
     self.view = np.eye(4, dtype=np.float32)
     x,y=self.getEventCoordinates(event)
     print(factor)
     if factor<1:
         x-(x-self.pos[0])/factor
         y-(y-self.pos[1])/factor
     else:
         x=self.pos[0]-(x-self.pos[0])/factor
         y=self.pos[1]-(y-self.pos[1])/factor
     self.pos[0]=x
     self.pos[1]=y
     translate(self.view, -x, -y, -1)
     self.program['u_view'] = self.view
     self.getEventCoordinates(self.event)
     self.update()        

 def on_resize(self, event):
     width, height = event.size
     gl.glViewport(0, 0, width, height)
     self.projection = ortho(0, width, 0, height, -100, 100)
     self.u_size = width / 512.0
     self.program['u_projection'] = self.projection
     self.program['u_size'] = self.u_size

    def __init__(self):
        app.Canvas.__init__(self)

        # This size is used for comparison with agg (via matplotlib)
        self.size = 512, 512 + 2 * 32
        self.title = "Markers demo [press space to change marker]"

        self.vbo = VertexBuffer(data)
        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = ortho(0, self.size[0], 0, self.size[1], -1, 1)
        self.programs = [
            Program(markers.vert, markers.frag + markers.tailed_arrow),
            Program(markers.vert, markers.frag + markers.disc),
            Program(markers.vert, markers.frag + markers.diamond),
            Program(markers.vert, markers.frag + markers.square),
            Program(markers.vert, markers.frag + markers.cross),
            Program(markers.vert, markers.frag + markers.arrow),
            Program(markers.vert, markers.frag + markers.vbar),
            Program(markers.vert, markers.frag + markers.hbar),
            Program(markers.vert, markers.frag + markers.clobber),
            Program(markers.vert, markers.frag + markers.ring)]

        for program in self.programs:
            program.set_vars(self.vbo,
                             u_antialias=u_antialias,
                             u_size=1,
                             u_model=self.model,
                             u_view=self.view,
                             u_projection=self.projection)
        self.index = 0
        self.program = self.programs[self.index]

    def __init__(self, emulate3d=True):
        app.Canvas.__init__(self, keys='interactive', size=((W*5), (H*5)))

        if emulate3d:
            tex_cls = gloo.TextureEmulated3D
        else:
            tex_cls = gloo.Texture3D
        self.texture = tex_cls(img_array, interpolation='nearest',
                               wrapping='clamp_to_edge')

        self.program = ModularProgram(VERT_SHADER, FRAG_SHADER)
        self.program.frag['sampler_type'] = self.texture.glsl_sampler_type
        self.program.frag['sample'] = self.texture.glsl_sample
        self.program['u_texture'] = self.texture
        self.program['i'] = 0.0
        self.program.bind(gloo.VertexBuffer(data))

        self.view = np.eye(4, dtype=np.float32)
        self.model = np.eye(4, dtype=np.float32)
        self.projection = np.eye(4, dtype=np.float32)

        self.program['u_model'] = self.model
        self.program['u_view'] = self.view
        self.projection = ortho(0, W, 0, H, -1, 1)
        self.program['u_projection'] = self.projection

        self.i = 0

        gloo.set_clear_color('white')

        self._timer = app.Timer('auto', connect=self.on_timer, start=True)

        self.show()

    def set_data(self, data):
        self.data = data

        self.xmin, self.xmax = np.nanmin(data.x_coords), np.nanmax(data.x_coords)
        self.ymin, self.ymax = np.nanmin(data.y_coords), np.nanmax(data.y_coords)
        self.zmin, self.zmax = np.nanmin(data.values), np.nanmax(data.values)

        self.cm_dx = (self.xmax-self.xmin)*0.1

        self.view = translate((0, 0, 0))
        self.projection = ortho(self.xmin, self.xmax + self.cm_dx, self.ymin, self.ymax, -1, 1)

        self.program['u_view'] = self.view
        self.program['u_projection'] = self.projection
        self.program['u_colormap'] = gloo.Texture1D(self.colormap.get_colors(), interpolation='linear')
        
        self.program_cm['u_view'] = self.view
        self.program_cm['u_projection'] = self.projection

        self.program_line['u_view'] = self.view
        self.program_line['u_projection'] = self.projection

        t0 = time.clock()
        vertices = self.generate_vertices(data)
        #print 'generate_vertices: ', time.clock()-t0
        self.vbo = gloo.VertexBuffer(vertices)
        self.program.bind(self.vbo)

        self.update()

def test_transforms():
    """Test basic transforms"""
    xfm = np.random.randn(4, 4).astype(np.float32)

    for rot in [xrotate, yrotate, zrotate]:
        new_xfm = rot(rot(xfm, 90), -90)
        assert_allclose(xfm, new_xfm)

    new_xfm = rotate(rotate(xfm, 90, 1, 0, 0), 90, -1, 0, 0)
    assert_allclose(xfm, new_xfm)

    new_xfm = translate(translate(xfm, 1, -1), 1, -1, 1)
    assert_allclose(xfm, new_xfm)

    new_xfm = scale(scale(xfm, 1, 2, 3), 1, 1. / 2., 1. / 3.)
    assert_allclose(xfm, new_xfm)

    # These could be more complex...
    xfm = ortho(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = frustum(-1, 1, -1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

    xfm = perspective(1, 1, -1, 1)
    assert_equal(xfm.shape, (4, 4))

 def on_resize(self, event):
     width, height = event.size
     gloo.set_viewport(0, 0, width, height)
     self.projection = ortho(0, width, 0, height, -100, 100)
     self.u_size = width / 512.0
     self.program["u_projection"] = self.projection
     self.program["u_size"] = self.u_size

	def apply_zoom(self):
		width, height = self.physical_size
		gloo.set_viewport(0, 0, width, height)
		a, b, c = .5, .5, 2
		if width>height:
			a *= width/height
		else:
			b *= height/width
		self.projection = ortho(-a, a, -b, b, -c, c)
		self.program['u_projection'] = self.projection

    def __init__(self, fragment_shader, vol_texture, num_channels, entry_texture, gain=1.0):
        gloo.Program.__init__(self, self.vert_shader, fragment_shader)

        self['u_data_texture'] = vol_texture
        self['u_projection'] = ortho(-.5, .5, -.5, .5, -100, 100)
        self.bind(self.port_verts)
        self['u_model'] = self.port_model
        self['u_view'] = np.eye(4, dtype=np.float32)
        self['u_entry_texture'] = entry_texture
        self['u_gain'] = gain
        self['u_numchannels'] = num_channels