def SedimentColour(self, z): # The method changes the texture of the sediment surface. The texture is such that color of each element is # directly correlated to the sediment depth of the element. # ============== BUG ============== BUG ============== BUG ============== BUG ============== BUG ============== # There is a bug which occurs randomly, in those cases the texture is transposed. It is unclear what causes the # bug and what can be done to remove it. # ============== BUG ============== BUG ============== BUG ============== BUG ============== BUG ============== from PIL import Image b = np.zeros((512, 512, 3)) b[:, :, 1] = 255 * z / np.max(z) img = Image.fromarray(b.astype('uint8'), 'RGB') #img.show() img = img.rotate( 90 ) # The rotation is necessary for the image to align with the surface properly. #img = img.transpose(Image.TRANSPOSE) # The rotation is necessary for the image to align with the surface properly. img.save('my.png') bmp1 = tvtk.PNGReader() #bmp1 = tvtk.JPEGReader() bmp1.file_name = "my.png" my_texture = tvtk.Texture(input_connection=bmp1.output_port, interpolate=0) # If the scalar_visibility is not False the colour of the texture will depend on the height of the surface. When # they value is false the appearance of the texture do not depend on the height of the surface, THIS IS CRUCIAL. self.a.actor.mapper.scalar_visibility = False self.a.actor.enable_texture = True self.a.actor.tcoord_generator_mode = 'plane' self.a.actor.actor.texture = my_texture
def update_plot(self, terrain, track): # This function is called when the view is opened. We don't # populate the scene when the view is not yet open, as some # VTK features require a GLContext. # We can do normal mlab calls on the embedded scene. # self.scene.mlab.test_points3d() # Here's were I embedded my code self.scene.mlab.clf() # Plot the elevation mesh elevation_mesh = self.scene.mlab.mesh(terrain['x'], terrain['y'], terrain['z']) # Read and apply texture bmp = tvtk.PNGReader(file_name=bombo.TEXTURE_FILE) texture = tvtk.Texture(input_connection=bmp.output_port, interpolate=1) elevation_mesh.actor.actor.mapper.scalar_visibility = False elevation_mesh.actor.enable_texture = True elevation_mesh.actor.tcoord_generator_mode = 'plane' elevation_mesh.actor.actor.texture = texture # Display path nodes if len(track['x']) == 1: track_line = self.scene.mlab.points3d( track['x'], track['y'], track['z'], color=track['color'], mode='sphere', scale_factor=track['line_radius'] * 10) else: track_line = self.scene.mlab.plot3d( track['x'], track['y'], track['z'], color=track['color'], line_width=10.0, tube_radius=track['line_radius']) # Display north text north_label = self.scene.mlab.text3d( (terrain['x'][0][0] + terrain['x'][-1][0]) / 2, terrain['y'][0][0], np.max(terrain['z']), "NORTH", scale=(track['textsize'], track['textsize'], track['textsize'])) # Displaying start test if len(track['x']) > 1: start_label = self.scene.mlab.text3d(track['x'][0], track['y'][0], track['z'][0] * 1.5, "START", scale=(track['textsize'], track['textsize'], track['textsize']))
def __init__(self, **traits): d = {'bmp':tvtk.BMPReader(), 'jpg':tvtk.JPEGReader(), 'png':tvtk.PNGReader(), 'pnm':tvtk.PNMReader(), 'dcm':tvtk.DICOMImageReader(), 'tiff':tvtk.TIFFReader(), 'ximg':tvtk.GESignaReader(), 'dem':tvtk.DEMReader(), 'mha':tvtk.MetaImageReader(), 'mhd':tvtk.MetaImageReader(), } # Account for pre 5.2 VTk versions, without MINC reader if hasattr(tvtk, 'MINCImageReader'): d['mnc'] = tvtk.MINCImageReader() d['jpeg'] = d['jpg'] self._image_reader_dict = d # Call parent class' init. super(ImageReader, self).__init__(**traits)
def manual_sphere(image_file): # caveat 1: flip the input image along its first axis img = plt.imread(image_file) # shape (N,M,3), flip along first dim #outfile = image_file.replace('.png', '_flipped.png') # flip output along first dim to get right chirality of the mapping #img = img[::-1,...] #plt.imsave(outfile, img) #image_file = outfile # work with the flipped file from now on # parameters for the sphere R = 1 # radius of the sphere Nrad = 180 # points along theta and phi phi = np.linspace(0, 2 * np.pi, Nrad) # shape (Nrad,) theta = np.linspace(0, np.pi, Nrad) # shape (Nrad,) phigrid, thetagrid = np.meshgrid(phi, theta) # shapes (Nrad, Nrad) # compute actual points on the sphere x = R * np.sin(thetagrid) * np.cos(phigrid) y = R * np.sin(thetagrid) * np.sin(phigrid) z = R * np.cos(thetagrid) # create figure mlab.figure(size=(600, 600)) # create meshed sphere mesh = mlab.mesh(x, y, z) mesh.actor.actor.mapper.scalar_visibility = False mesh.actor.enable_texture = True # probably redundant assigning the texture later # load the (flipped) image for texturing img = tvtk.PNGReader(file_name=image_file) texture = tvtk.Texture(input_connection=img.output_port, interpolate=0, repeat=0) mesh.actor.actor.texture = texture # tell mayavi that the mapping from points to pixels happens via a sphere mesh.actor.tcoord_generator_mode = 'sphere' # map is already given for a spherical mapping cylinder_mapper = mesh.actor.tcoord_generator # caveat 2: if prevent_seam is 1 (default), half the image is used to map half the sphere cylinder_mapper.prevent_seam = 0 # use 360 degrees, might cause seam but no fake data
def auto_sphere(image_file): # create a figure window (and scene) fig = mlab.figure(size=(600, 600)) # load and map the texture img = tvtk.PNGReader() img.file_name = image_file texture = tvtk.Texture(input_connection=img.output_port, interpolate=1) # (interpolate for a less raster appearance when zoomed in) # use a TexturedSphereSource, a.k.a. getting our hands dirty R = 1 Nrad = 180 # create the sphere source with a given radius and angular resolution sphere = tvtk.TexturedSphereSource(radius=R, theta_resolution=Nrad, phi_resolution=Nrad) # assemble rest of the pipeline, assign texture sphere_mapper = tvtk.PolyDataMapper(input_connection=sphere.output_port) sphere_actor = tvtk.Actor(mapper=sphere_mapper, texture=texture) fig.scene.add_actor(sphere_actor)
def draw_bilboard(fig, texture_name, pos=(0, 0, 0), scale=1.0): plane = tvtk.PlaneSource(center=pos) # pdb.set_trace() # plane = resize(plane, scale) reader = tvtk.PNGReader() reader.set_data_scalar_type_to_unsigned_char() reader.set(file_name=texture_name) plane_texture = tvtk.Texture() plane_texture.set_input(reader.get_output()) plane_texture.set(interpolate=0) # pdb.set_trace() map = tvtk.TextureMapToPlane() map.set_input(plane.get_output()) plane_mapper = tvtk.PolyDataMapper() plane_mapper.set(input=map.get_output()) p = tvtk.Property(opacity=1.0, color=(1, 0, 0)) plane_actor = tvtk.Actor(mapper=plane_mapper, texture=plane_texture) fig.scene.add_actor(plane_actor)
def compare_image_with_saved_image(src_img, img_fname, threshold=10, allow_resize=True): """Compares a source image (src_img, which is a tvtk.ImageData) with the saved image file whose name is given in the second argument. If the image file does not exist the image is generated and stored. If not the source image is compared to that of the figure. This function also handles multiple images and finds the best matching image. If `allow_resize` is True then the images are rescaled if they are not of the same size. """ f_base, f_ext = os.path.splitext(os.path.abspath(img_fname)) if not os.path.isfile(img_fname): # generate the image pngw = tvtk.PNGWriter(file_name=img_fname, input=src_img) pngw.write() if VERBOSE: print "Creating baseline image '%s'." % img_fname return pngr = tvtk.PNGReader(file_name=img_fname) pngr.update() if allow_resize: src_resample = tvtk.ImageResample(input=src_img, interpolate=1, interpolation_mode='cubic') img_resample = tvtk.ImageResample(input=pngr.output, interpolate=1, interpolation_mode='cubic') _set_scale(src_resample, img_resample) idiff = tvtk.ImageDifference(input=src_resample.output, image=img_resample.output) else: idiff = tvtk.ImageDifference(input=src_img, image=pngr.output) idiff.update() min_err = idiff.thresholded_error img_err = min_err best_img = img_fname err_index = 0 count = 0 if min_err > threshold: count = 1 test_failed = 1 err_index = -1 while 1: # keep trying images till we get the best match. new_fname = f_base + "_%d.png" % count if not os.path.exists(new_fname): # no other image exists. break # since file exists check if it matches. pngr.file_name = new_fname pngr.update() if allow_resize: _set_scale(src_resample, img_resample) idiff.update() alt_err = idiff.thresholded_error if alt_err < threshold: # matched, err_index = count test_failed = 0 min_err = alt_err img_err = alt_err best_img = new_fname break else: if alt_err < min_err: # image is a better match. err_index = count min_err = alt_err img_err = alt_err best_img = new_fname count = count + 1 # closes while loop. if test_failed: _handle_failed_image(idiff, src_img, pngr, best_img) _print_image_error(img_err, err_index, f_base) msg = "Failed image test: %f\n" % idiff.thresholded_error raise AssertionError, msg # output the image error even if a test passed _print_image_success(img_err, err_index)
def mlabtex( x, y, z, text, color=(0, 0, 0), figure=None, name=None, opacity=1.0, orientation=(0.0, 0.0, 0.0), scale=1.0, dpi=1200, ): r""" Render for matplotlib like text in mayavi. Analogous to mlab.text3d. Parameters ---------- x : float x position of the text. y : float y position of the text. z : float z position of the text. text : string The text is positionned in 3D, in figure coordinnates. color : tuple, optional color of the text given as rgb tuple. Default: ``(0, 0, 0)`` figure : Scene, optional Must be a Scene or None. name : string, optional the name of the vtk object created. opacity : float, optional The overall opacity of the vtk object. Must be a float. Default: 1.0 orientation : tuple, optional the angles giving the orientation of the text. If the text is oriented to the camera, these angles are referenced to the axis of the camera. If not, these angles are referenced to the z axis. Must be an array with shape (3,). scale : float, optional The scale of the text, in figure units. It is rescaled by the size of the letter "I". dpi : int, optional Used dpi. Default: 1200 Returns ------- surf : Surf Mayavi ``Surf`` class with the rendered text as texture. Notes ----- If you get the following error: ``RuntimeError: libpng signaled error`` Try to set the dpi higher. (1200 recomended) If big symbols like ``\int`` or ``\sum`` don't show up properly, try setting a ``\displaystyle`` infront of them. """ # create temporary file for the reference height of the letter "I" reffile = TmpFile(suffix=".png") render_latex(r"I", path=reffile.name, dpi=dpi) ref = tvtk.PNGReader() ref.file_name = reffile.name ref.update() # Reference heigth of the letter "I" ref_y = ref.data_extent[3] reffile.close() # create temporary file for the png pngfile = TmpFile(suffix=".png") # create png file containing text with matplotlib render_latex(text, path=pngfile.name, color=color, dpi=dpi) # loading image with tvtk surf = mlabimg( x, y, z, pngfile.name, figure, name, opacity, orientation, scale, typ="png", ref_y_extent=ref_y, ) # close temp file pngfile.close() return surf