def test_default_colors(appear: Appearance, data): """Test the default background/foreground colors.""" cfg = get_renderer_config(appear) lcfg = LayoutConfig(orientation=ORIENTATION) datas = [data] * NPLOTS r = Renderer(cfg, lcfg, datas, None, None) verify(r, appear, datas) # Ensure default ChannelConfig(line_color=None) does not override line color chan = ChannelConfig(wav_path="") channels = [chan] * NPLOTS r = Renderer(cfg, lcfg, datas, channels, None) verify(r, appear, datas)
def test_line_colors(appear: Appearance, data): """Test channel-specific line color overrides""" cfg = get_renderer_config(appear) lcfg = LayoutConfig(orientation=ORIENTATION) datas = [data] * NPLOTS # Move line color (appear.fg.color) from renderer cfg to individual channel. chan = ChannelConfig(wav_path="", line_color=appear.fg.color) channels = [chan] * NPLOTS cfg.init_line_color = "#888888" chan.line_color = appear.fg.color r = Renderer(cfg, lcfg, datas, channels, None) verify(r, appear, datas)
def test_renderer_layout(): # 2 columns cfg = RendererConfig(WIDTH, HEIGHT) lcfg = LayoutConfig(ncols=2) nplots = 15 datas = [RENDER_Y_ZEROS] * nplots r = Renderer(cfg, lcfg, datas, None, None) r.update_main_lines(RenderInput.wrap_datas(datas), [0] * nplots) layout = r.layout # 2 columns, 8 rows assert layout.wave_ncol == 2 assert layout.wave_nrow == 8
def test_line_colors(bg_str, fg_str, grid_str, data): """ Test channel-specific line color overrides """ cfg = RendererConfig( WIDTH, HEIGHT, bg_color=bg_str, init_line_color="#888888", grid_color=grid_str, stereo_grid_opacity=OPACITY, line_width=2.0, antialiasing=False, ) lcfg = LayoutConfig() chan = ChannelConfig(wav_path="", line_color=fg_str) channels = [chan] * NPLOTS r = MatplotlibRenderer(cfg, lcfg, NPLOTS, channels) verify(r, bg_str, fg_str, grid_str, data)
def test_default_colors(bg_str, fg_str, grid_str, data): """ Test the default background/foreground colors. """ cfg = RendererConfig( WIDTH, HEIGHT, bg_color=bg_str, init_line_color=fg_str, grid_color=grid_str, stereo_grid_opacity=OPACITY, line_width=2.0, antialiasing=False, ) lcfg = LayoutConfig() r = MatplotlibRenderer(cfg, lcfg, NPLOTS, None) verify(r, bg_str, fg_str, grid_str, data) # Ensure default ChannelConfig(line_color=None) does not override line color chan = ChannelConfig(wav_path="") channels = [chan] * NPLOTS r = MatplotlibRenderer(cfg, lcfg, NPLOTS, channels) verify(r, bg_str, fg_str, grid_str, data)
def test_stereo_layout( orientation: Orientation, stereo_orientation: StereoOrientation, wave_nchans: List[int], nrow_ncol: int, is_nrows: bool, ): """ Not-entirely-rigorous test for layout computation. Mind-numbingly boring to write (and read?). Honestly I prefer a good naming scheme in RendererLayout.arrange() over unit tests. - This is a regression test... - And an obstacle to refactoring or feature development. """ # region Setup if is_nrows: nrows = nrow_ncol ncols = None else: nrows = None ncols = nrow_ncol lcfg = LayoutConfig( orientation=orientation, nrows=nrows, ncols=ncols, stereo_orientation=stereo_orientation, ) nwaves = len(wave_nchans) layout = RendererLayout(lcfg, wave_nchans) # endregion # Assert layout dimensions correct assert layout.wave_ncol == ncols or ceildiv(nwaves, nrows) assert layout.wave_nrow == nrows or ceildiv(nwaves, ncols) region2d: List[List[RegionSpec]] = layout.arrange(lambda r_spec: r_spec) # Loop through layout regions assert len(region2d) == len(wave_nchans) for wave_i, wave_chans in enumerate(region2d): stereo_nchan = wave_nchans[wave_i] assert len(wave_chans) == stereo_nchan # Compute channel dims within wave. if stereo_orientation == StereoOrientation.overlay: chans_per_wave = [1, 1] elif stereo_orientation == StereoOrientation.v: # pos[0]++ chans_per_wave = [stereo_nchan, 1] else: assert stereo_orientation == StereoOrientation.h # pos[1]++ chans_per_wave = [1, stereo_nchan] # Sanity-check position of channel 0 relative to origin (wave grid). assert (np.add.reduce(wave_chans[0].pos) != 0) == (wave_i != 0) npt.assert_equal(wave_chans[0].pos % chans_per_wave, 0) for chan_j, chan in enumerate(wave_chans): # Assert 0 <= position < size. assert chan.pos.shape == chan.size.shape == (2, ) assert (0 <= chan.pos).all() assert (chan.pos < chan.size).all() # Sanity-check position of chan relative to origin (wave grid). npt.assert_equal(chan.pos // chans_per_wave, wave_chans[0].pos // chans_per_wave) # Check position of region (relative to channel 0) chan_wave_pos = chan.pos - wave_chans[0].pos if stereo_orientation == StereoOrientation.overlay: npt.assert_equal(chan_wave_pos, [0, 0]) elif stereo_orientation == StereoOrientation.v: # pos[0]++ npt.assert_equal(chan_wave_pos, [chan_j, 0]) else: assert stereo_orientation == StereoOrientation.h # pos[1]++ npt.assert_equal(chan_wave_pos, [0, chan_j]) # Check screen edges screen_edges = chan.screen_edges assert bool(screen_edges & Edges.Top) == (chan.row == 0) assert bool(screen_edges & Edges.Left) == (chan.col == 0) assert bool(screen_edges & Edges.Bottom) == (chan.row == chan.nrow - 1) assert bool(screen_edges & Edges.Right) == (chan.col == chan.ncol - 1) # Check stereo edges wave_edges = chan.wave_edges if stereo_orientation == StereoOrientation.overlay: assert wave_edges == ~Edges.NONE elif stereo_orientation == StereoOrientation.v: # pos[0]++ lr = Edges.Left | Edges.Right assert wave_edges & lr == lr assert bool(wave_edges & Edges.Top) == (chan.row % stereo_nchan == 0) assert bool(wave_edges & Edges.Bottom) == ((chan.row + 1) % stereo_nchan == 0) else: assert stereo_orientation == StereoOrientation.h # pos[1]++ tb = Edges.Top | Edges.Bottom assert wave_edges & tb == tb assert bool(wave_edges & Edges.Left) == (chan.col % stereo_nchan == 0) assert bool(wave_edges & Edges.Right) == ((chan.col + 1) % stereo_nchan == 0)
def test_edges(nrows: int, ncols: int, row: int, col: int): if not (nrows > 0 and ncols > 0 and 0 <= row < nrows and 0 <= col < ncols): with pytest.raises(ValueError): edges = Edges.at(nrows, ncols, row, col) return edges = Edges.at(nrows, ncols, row, col) assert bool(edges & Edges.Left) == (col == 0) assert bool(edges & Edges.Right) == (col == ncols - 1) assert bool(edges & Edges.Top) == (row == 0) assert bool(edges & Edges.Bottom) == (row == nrows - 1) @pytest.mark.parametrize( "lcfg", [LayoutConfig(ncols=2), LayoutConfig(nrows=8)]) def test_hlayout(lcfg): nplots = 15 layout = RendererLayout(lcfg, [1] * nplots) assert layout.wave_ncol == 2 assert layout.wave_nrow == 8 region2d: List[List[RegionSpec]] = layout.arrange(lambda arg: arg) assert len(region2d) == nplots for i, regions in enumerate(region2d): assert len(regions) == 1, (i, len(regions)) np.testing.assert_equal(region2d[0][0].pos, (0, 0)) np.testing.assert_equal(region2d[1][0].pos, (0, 1)) np.testing.assert_equal(region2d[2][0].pos, (1, 0))