def _compute_vertices_and_box(self): """Compute location of the box for rendering. Returns ------- vertices : np.ndarray Nx2 array of any vertices to be rendered as Markers face_color : str String of the face color of the Markers edge_color : str String of the edge color of the Markers and Line for the box pos : np.ndarray Nx2 array of vertices of the box that will be rendered using a Vispy Line width : float Width of the box edge """ if (self._interaction_box._box is not None and self._interaction_box.show): box = self._interaction_box._box if self._interaction_box.show_handle: box = self._add_rotation_handle(box) face_color = self._highlight_color edge_color = self._highlight_color if self._interaction_box.show_vertices: colors = np.array([(1.0, 1.0, 1.0) for point in box]) if self._interaction_box.selected_vertex is not None: colors[self._interaction_box. selected_vertex] = self._highlight_color if self._interaction_box.show_handle: vertices = box[Box.WITH_HANDLE][:, ::-1] face_color = ColorArray(colors[Box.WITH_HANDLE]) else: vertices = box[Box.WITHOUT_HANDLE][:, ::-1] face_color = ColorArray(colors[Box.WITHOUT_HANDLE]) else: vertices = np.empty((0, 2)) face_color = 'white' # Use a subset of the vertices of the interaction_box to plot # the line around the edge if self._interaction_box.show_handle: pos = box[Box.LINE_HANDLE][:, ::-1] else: pos = box[Box.LINE][:, ::-1] width = self._highlight_width self._box = box else: # Otherwise show nothing vertices = np.empty((0, 2)) face_color = 'white' edge_color = 'white' pos = None width = 0 self._box = None return vertices, face_color, edge_color, pos, width
def pointer_gamut_visual(reference_colourspace='CIE xyY', size=4.0, edge_size=0.5, uniform_colour=(0.9, 0.9, 0.9), uniform_opacity=0.8, uniform_edge_colour=(0.9, 0.9, 0.9), uniform_edge_opacity=0.8, parent=None): """ Returns a :class:`vispy.scene.visuals.Symbol` class instance representing Pointer's Gamut data using cross symbols. Parameters ---------- reference_colourspace : unicode, optional **{'CIE XYZ', 'CIE xyY', 'CIE Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW', 'IPT', 'Hunter Lab', 'Hunter Rdab'}**, Reference colourspace to use for colour conversions / transformations. size : numeric, optional Cross size. edge_size : numeric, optional Cross edge size. uniform_colour : array_like, optional Uniform cross colour. uniform_opacity : numeric, optional Uniform cross opacity. uniform_edge_colour : array_like, optional Uniform cross edge colour. uniform_edge_opacity : numeric, optional Uniform cross edge opacity. parent : Node, optional Parent of the Pointer's Gamut visual in the `SceneGraph`. Returns ------- Symbol Pointer's Gamut visual. """ points = common_colourspace_model_axis_reorder( XYZ_to_colourspace_model( POINTER_GAMUT_DATA, POINTER_GAMUT_ILLUMINANT, reference_colourspace), reference_colourspace) RGB = ColorArray(uniform_colour, alpha=uniform_opacity).rgba RGB_e = ColorArray(uniform_edge_colour, alpha=uniform_edge_opacity).rgba markers = Symbol(symbol='cross', positions=points, size=size, edge_size=edge_size, face_colour=RGB, edge_colour=RGB_e, parent=parent) return markers
def _glsl_step(controls=None, colors=None, texture_map_data=None): assert (controls[0], controls[-1]) == (0., 1.) ncolors = len(controls) - 1 assert ncolors >= 2 assert (texture_map_data is not None) LUT = texture_map_data texture_len = texture_map_data.shape[0] LUT_tex_idx = np.linspace(0.0, 1.0, texture_len) # Replicate indices to colormap texture. # The resulting matrix has size of (texture_len,len(controls)). # It is used to perform piecewise constant interpolation # for each RGBA color component. t2 = np.repeat(LUT_tex_idx[:, np.newaxis], len(controls), 1) # Perform element-wise comparison to find # control points for all LUT colors. bn = np.sum(controls.transpose() <= t2, axis=1) j = np.clip(bn - 1, 0, ncolors - 1) # Copying color data from ColorArray to array-like # makes data assignment to LUT faster. colors_rgba = ColorArray(colors[:])._rgba LUT[:, 0, :] = colors_rgba[j] s2 = "uniform sampler2D texture2D_LUT;" s = "{\n return texture2D(texture2D_LUT, \ vec2(0.0, clamp(t, 0.0, 1.0)));\n} " return "%s\nvec4 colormap(float t) {\n%s\n}" % (s2, s)
def __init__(self, vertices, faces, uniform_colour=(0.5, 0.5, 1.0), uniform_opacity=1.0, vertex_colours=None, wireframe=False, wireframe_offset=None): """ Creates a primitive visual based on :class:`vispy.visuals.mesh.MeshVisual` class. Parameters ---------- vertices : array_like Vertices data. faces : array_like Faces data. uniform_colour : array_like, optional Uniform mesh colour. uniform_opacity : numeric, optional Uniform mesh opacity. vertex_colours : array_like, optional Per vertex varying colour. wireframe : bool, optional Use wireframe display. wireframe_offset : array_like, optional Wireframe offset. Notes ----- - `vertex_colours` argument takes precedence over `uniform_colour` if provided. - `uniform_opacity` argument will be stacked to `vertex_colours` argument if the latter last dimension is equal to 3. """ self._wireframe = wireframe self._wireframe_offset = wireframe_offset mode = 'lines' if self._wireframe else 'triangles' uniform_colour = ColorArray(uniform_colour, alpha=uniform_opacity).rgba if vertex_colours is not None: if vertex_colours.shape[-1] == 3: vertex_colours = np.hstack( (vertex_colours, np.full((vertex_colours.shape[0], 1), uniform_opacity, DEFAULT_FLOAT_DTYPE))) else: vertex_colours[..., 3] = uniform_opacity MeshVisual.__init__( self, vertices, faces, vertex_colours, None, uniform_colour, mode=mode)
def __init__(self, colors=None): # Ensure the colors are arrays. if colors is not None: self.colors = colors if not isinstance(self.colors, ColorArray): self.colors = ColorArray(self.colors) # Process the GLSL map function by replacing $color_i by the if len(self.colors) > 0: self.glsl_map = _process_glsl_template(self.glsl_map, self.colors.rgba)
def __getitem__(self, item): if isinstance(item, tuple): raise ValueError('ColorArray indexing is only allowed along ' 'the first dimension.') # Ensure item is either a scalar or a column vector. item = _vector(item, type='column') # Clip the values in [0, 1]. item = np.clip(item, 0., 1.) colors = self.map(item) return ColorArray(colors)
def pointer_gamut_boundaries_visual(reference_colourspace='CIE xyY', width=2.0, uniform_colour=(0.9, 0.9, 0.9), uniform_opacity=0.8, parent=None): """ Returns a :class:`vispy.scene.visuals.Line` class instance representing Pointer's Gamut boundaries. Parameters ---------- reference_colourspace : unicode, optional See :func:`pointer_gamut_visual` argument for possible values. Reference colourspace to use for colour conversions / transformations. width : numeric, optional Line width. uniform_colour : array_like, optional Uniform line colour. uniform_opacity : numeric, optional Uniform line opacity. parent : Node, optional Parent of the Pointer's Gamut boundaries visual in the `SceneGraph`. Returns ------- Line Pointer's Gamut boundaries visual. """ XYZ = np.vstack((POINTER_GAMUT_BOUNDARIES, POINTER_GAMUT_BOUNDARIES[0, ...])) illuminant = DEFAULT_PLOTTING_ILLUMINANT points = common_colourspace_model_axis_reorder( XYZ_to_colourspace_model( XYZ, illuminant, reference_colourspace), reference_colourspace) points[np.isnan(points)] = 0 RGB = ColorArray(uniform_colour, alpha=uniform_opacity).rgba line = Line(points, RGB, width=width, method='agg', parent=parent) return line
def pointer_gamut_hull_visual(reference_colourspace='CIE xyY', width=2.0, uniform_colour=(0.9, 0.9, 0.9), uniform_opacity=0.4, parent=None): """ Returns a :class:`vispy.scene.visuals.Node` class instance with :class:`vispy.scene.visuals.Lines` class instance children representing Pointer's Gamut hull. Parameters ---------- reference_colourspace : unicode, optional See :func:`pointer_gamut_visual` argument for possible values. Reference colourspace to use for colour conversions / transformations. width : numeric, optional Lines width. uniform_colour : array_like, optional Uniform lines colour. uniform_opacity : numeric, optional Uniform lines opacity. parent : Node, optional Parent of the Pointer's Gamut hull visual in the `SceneGraph`. Returns ------- Node Pointer's Gamut hull visual. """ node = Node(parent=parent) pointer_gamut_data = np.reshape(POINTER_GAMUT_DATA, (16, -1, 3)) for i in range(16): points = common_colourspace_model_axis_reorder( XYZ_to_colourspace_model( np.vstack((pointer_gamut_data[i], pointer_gamut_data[i][0, ...])), POINTER_GAMUT_ILLUMINANT, reference_colourspace), reference_colourspace) points[np.isnan(points)] = 0 RGB = ColorArray(uniform_colour, alpha=uniform_opacity).rgba Line(points, RGB, width=width, parent=node) return node
def __init__(self, limits=(0.33, 0.66, 1.0)): limits = np.array(limits, float).ravel() if len(limits) != 3: raise ValueError('limits must have 3 values') if (np.diff(limits) < 0).any() or (limits <= 0).any(): raise ValueError('limits must be strictly increasing and positive') controls = np.array([ -limits[2], -limits[1], -limits[0], limits[0], limits[1], limits[2] ]) controls = ((controls / limits[2]) + 1) / 2. colors = [(0., 1., 1., 1.), (0., 0., 1., 1.), (0., 0., 1., 0.), (1., 0., 0., 0.), (1., 0., 0., 1.), (1., 1., 0., 1.)] colors = ColorArray(colors) super(_RedYellowBlueCyan, self).__init__(colors, controls=controls, interpolation='linear')
def __init__(self, h_pos=20, h_neg=250, saturation=1.0, value=0.7, center="light"): saturation *= 99 value *= 99 start = husl_to_rgb(h_neg, saturation, value) mid = ((0.133, 0.133, 0.133) if center == "dark" else (0.92, 0.92, 0.92)) end = husl_to_rgb(h_pos, saturation, value) colors = ColorArray([start, mid, end]) super(_Diverging, self).__init__(colors)
def __init__(self, ncolors=6, hue_start=0, saturation=1.0, value=1.0, controls=None, interpolation='linear'): hues = np.linspace(0, 360, ncolors + 1)[:-1] hues += hue_start hues %= 360 colors = ColorArray([(hue, saturation, value) for hue in hues], color_space='hsv') super(_HSL, self).__init__(colors, controls=controls, interpolation=interpolation)
def _glsl_mix(controls=None, colors=None, texture_map_data=None): """Generate a GLSL template function from a given interpolation patterns and control points. Parameters ---------- colors : array-like, shape (n_colors, 4) The control colors used by the colormap. Elements of colors must be convertible to an instance of Color-class. controls : list The list of control points for the given colors. It should be an increasing list of floating-point number between 0.0 and 1.0. The first control point must be 0.0. The last control point must be 1.0. The number of control points depends on the interpolation scheme. texture_map_data : ndarray, shape(texture_len, 4) Numpy array of size of 1D texture lookup data for luminance to RGBA conversion. """ assert (controls[0], controls[-1]) == (0., 1.) ncolors = len(controls) assert ncolors >= 2 assert (texture_map_data is not None) LUT = texture_map_data texture_len = texture_map_data.shape[0] # Perform linear interpolation for each RGBA color component. c_rgba = ColorArray(colors)._rgba x = np.linspace(0.0, 1.0, texture_len) LUT[:, 0, 0] = np.interp(x, controls, c_rgba[:, 0]) LUT[:, 0, 1] = np.interp(x, controls, c_rgba[:, 1]) LUT[:, 0, 2] = np.interp(x, controls, c_rgba[:, 2]) LUT[:, 0, 3] = np.interp(x, controls, c_rgba[:, 3]) s2 = "uniform sampler2D texture2D_LUT;" s = "{\n return texture2D(texture2D_LUT, \ vec2(0.0, clamp(t, 0.0, 1.0)));\n} " return "%s\nvec4 colormap(float t) {\n%s\n}" % (s2, s)
def __init__(self, ncolors=6, hue_start=0, saturation=1.0, value=0.7, controls=None, interpolation='linear'): hues = np.linspace(0, 360, ncolors + 1)[:-1] hues += hue_start hues %= 360 saturation *= 99 value *= 99 colors = ColorArray( [husl_to_rgb(hue, saturation, value) for hue in hues], ) super(_HUSL, self).__init__(colors, controls=controls, interpolation=interpolation)
def RGB_scatter_visual(RGB, colourspace='ITU-R BT.709', reference_colourspace='CIE xyY', symbol='disc', size=4.0, edge_size=0.5, uniform_colour=None, uniform_opacity=1.0, uniform_edge_colour=None, uniform_edge_opacity=1.0, resampling='auto', parent=None): """ Returns a :class:`vispy.scene.visuals.Symbol` class instance representing *RGB* data using given symbols. Parameters ---------- RGB : array_like *RGB* data to draw. colourspace : unicode, optional **{'ITU-R BT.709', 'ACES2065-1', 'ACEScc', 'ACEScg', 'ACESproxy', 'ALEXA Wide Gamut', 'Adobe RGB (1998)', 'Adobe Wide Gamut RGB', 'Apple RGB', 'Best RGB', 'Beta RGB', 'CIE RGB', 'Cinema Gamut', 'ColorMatch RGB', 'DCI-P3', 'DCI-P3+', 'DRAGONcolor', 'DRAGONcolor2', 'Don RGB 4', 'ECI RGB v2', 'ERIMM RGB', 'Ekta Space PS 5', 'Max RGB', 'NTSC', 'Pal/Secam', 'ProPhoto RGB', 'REDcolor', 'REDcolor2', 'REDcolor3', 'REDcolor4', 'RIMM RGB', 'ROMM RGB', 'ITU-R BT.2020', 'Russell RGB', 'S-Gamut', 'S-Gamut3', 'S-Gamut3.Cine', 'SMPTE-C RGB', 'V-Gamut', 'Xtreme RGB', 'sRGB'}**, :class:`colour.RGB_Colourspace` class instance name defining the *RGB* colourspace of the data to draw. reference_colourspace : unicode, optional **{'CIE XYZ', 'CIE xyY', 'CIE Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW', 'IPT', 'Hunter Lab', 'Hunter Rdab'}**, Reference colourspace to use for colour conversions / transformations. symbol : unicode, optional Symbol type to draw. size : numeric, optional Symbol size. edge_size : numeric, optional Symbol edge size. uniform_colour : array_like, optional Uniform symbol colour. uniform_opacity : numeric, optional Uniform symbol opacity. uniform_edge_colour : array_like, optional Uniform symbol edge colour. uniform_edge_opacity : numeric, optional Uniform symbol edge opacity. resampling : numeric or unicode, optional Resampling value, if numeric input, one pixel every `resampling` argument value will be kept. parent : Node, optional Parent of the *RGB* scatter visual in the `SceneGraph`. Returns ------- Symbol *RGB* scatter visual. """ colourspace = get_RGB_colourspace(colourspace) RGB = np.asarray(RGB) if resampling == 'auto': resampling = max(int((0.0078125 * np.average(RGB.shape[0:1])) // 2), 1) RGB = RGB[::resampling, ::resampling].reshape((-1, 3)) XYZ = RGB_to_XYZ(RGB, colourspace.whitepoint, colourspace.whitepoint, colourspace.RGB_to_XYZ_matrix) points = common_colourspace_model_axis_reorder( XYZ_to_colourspace_model(XYZ, colourspace.whitepoint, reference_colourspace), reference_colourspace) points[np.isnan(points)] = 0 RGB = np.clip(RGB, 0, 1) if uniform_colour is None: RGB = np.hstack((RGB, np.full((RGB.shape[0], 1), uniform_opacity, DEFAULT_FLOAT_DTYPE))) else: RGB = ColorArray(uniform_colour, alpha=uniform_opacity).rgba if uniform_edge_colour is None: RGB_e = RGB else: RGB_e = ColorArray(uniform_edge_colour, alpha=uniform_edge_opacity).rgba markers = Symbol(symbol=symbol, positions=points, size=size, edge_size=edge_size, face_colour=RGB, edge_colour=RGB_e, parent=parent) return markers
def spectral_locus_visual(reference_colourspace='CIE xyY', cmfs='CIE 1931 2 Degree Standard Observer', width=2.0, uniform_colour=None, uniform_opacity=1.0, method='gl', parent=None): """ Returns a :class:`vispy.scene.visuals.Line` class instance representing the spectral locus. Parameters ---------- reference_colourspace : unicode, optional **{'CIE XYZ', 'CIE xyY', 'CIE Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW', 'IPT', 'Hunter Lab', 'Hunter Rdab'}**, Reference colourspace to use for colour conversions / transformations. cmfs : unicode, optional Standard observer colour matching functions used to draw the spectral locus. width : numeric, optional Line width. uniform_colour : array_like, optional Uniform symbol colour. uniform_opacity : numeric, optional Uniform symbol opacity. method : unicode, optional **{'gl', 'agg'}**, Line drawing method. parent : Node, optional Parent of the spectral locus visual in the `SceneGraph`. Returns ------- Line Spectral locus visual. """ cmfs = first_item(filter_cmfs(cmfs).values()) XYZ = cmfs.values XYZ = np.vstack([XYZ, XYZ[0, ...]]) illuminant = DEFAULT_PLOTTING_ILLUMINANT points = common_colourspace_model_axis_reorder( XYZ_to_colourspace_model(XYZ, illuminant, reference_colourspace), reference_colourspace) points[np.isnan(points)] = 0 if uniform_colour is None: RGB = normalise_maximum(XYZ_to_sRGB(XYZ, illuminant), axis=-1) RGB = np.hstack([ RGB, np.full((RGB.shape[0], 1), uniform_opacity, DEFAULT_FLOAT_DTYPE) ]) else: RGB = ColorArray(uniform_colour, alpha=uniform_opacity).rgba line = Line(points, np.clip(RGB, 0, 1), width=width, method=method, parent=parent) return line
# Some colormap presets autumn=Colormap([(1., 0., 0., 1.), (1., 1., 0., 1.)]), blues=Colormap([(1., 1., 1., 1.), (0., 0., 1., 1.)]), cool=Colormap([(0., 1., 1., 1.), (1., 0., 1., 1.)]), greens=Colormap([(1., 1., 1., 1.), (0., 1., 0., 1.)]), reds=Colormap([(1., 1., 1., 1.), (1., 0., 0., 1.)]), spring=Colormap([(1., 0., 1., 1.), (1., 1., 0., 1.)]), summer=Colormap([(0., .5, .4, 1.), (1., 1., .4, 1.)]), fire=_Fire(), grays=_Grays(), hot=_Hot(), ice=_Ice(), winter=_Winter(), light_blues=_SingleHue(), orange=_SingleHue(hue=35), viridis=Colormap(ColorArray(_viridis_data)), # Diverging presets coolwarm=Colormap( ColorArray([(226, 0.59, 0.92), (222, 0.44, 0.99), (218, 0.26, 0.97), (30, 0.01, 0.87), (20, 0.3, 0.96), (15, 0.5, 0.95), (8, 0.66, 0.86)], color_space="hsv")), PuGr=_Diverging(145, 280, 0.85, 0.30), GrBu=_Diverging(255, 133, 0.75, 0.6), GrBu_d=_Diverging(255, 133, 0.75, 0.6, "dark"), RdBu=_Diverging(220, 20, 0.75, 0.5), # Configurable colormaps cubehelix=CubeHelixColormap, single_hue=_SingleHue, hsl=_HSL,
def __init__(self, hue=200, saturation_range=[0.1, 0.8], value=1.0): colors = ColorArray([(hue, saturation_range[0], value), (hue, saturation_range[1], value)], color_space='hsv') super(_SingleHue, self).__init__(colors)