From 847e5319b5fe04b198bf37cf49f92c06575fc79f Mon Sep 17 00:00:00 2001 From: Tyler Goodlet Date: Tue, 26 Apr 2022 08:52:34 -0400 Subject: [PATCH] Drop uppx guard around downsamples on interaction Since downsampling with the more correct version of m4 (uppx driven windows sizing) is super fast now we don't need to avoid downsampling on low uppx values. Further all graphics objects now support in-view slicing so make sure to use it on interaction updates. Pass in the view profiler to update method calls for more detailed measuring. Even moar, - Add a manual call to `.maybe_downsample_graphics()` inside the mouse wheel event handler since it seems that sometimes trailing events get lost from the `.sigRangeChangedManually` signal which can result in "non-downsampled-enough" graphics on chart given the scroll amount; this manual call seems to entirely fix this? - drop "max zoom" guard since internals now support (near) infinite scroll out to graphics becoming a single pixel column line XD - add back in commented xrange signal connect code for easy testing to verify against range updates not happening without it --- piker/ui/_interaction.py | 71 +++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 37 deletions(-) diff --git a/piker/ui/_interaction.py b/piker/ui/_interaction.py index 943f3370..a2c99e38 100644 --- a/piker/ui/_interaction.py +++ b/piker/ui/_interaction.py @@ -34,10 +34,9 @@ import trio from ..log import get_logger from .._profile import pg_profile_enabled, ms_slower_then -from ._style import _min_points_to_show +# from ._style import _min_points_to_show from ._editors import SelectRect from . import _event -from ._ohlc import BarItems log = get_logger(__name__) @@ -485,11 +484,11 @@ class ChartView(ViewBox): # don't zoom more then the min points setting l, lbar, rbar, r = chart.bars_range() - vl = r - l + # vl = r - l - if ev.delta() > 0 and vl <= _min_points_to_show: - log.debug("Max zoom bruh...") - return + # if ev.delta() > 0 and vl <= _min_points_to_show: + # log.debug("Max zoom bruh...") + # return # if ( # ev.delta() < 0 @@ -570,6 +569,17 @@ class ChartView(ViewBox): self._resetTarget() self.scaleBy(s, focal) + + # XXX: without this is seems as though sometimes + # when zooming in from far out (and maybe vice versa?) + # the signal isn't being fired enough since if you pan + # just after you'll see further downsampling code run + # (pretty noticeable on the OHLC ds curve) but with this + # that never seems to happen? Only question is how much this + # "double work" is causing latency when these missing event + # fires don't happen? + self.maybe_downsample_graphics() + self.sigRangeChangedManually.emit(mask) # self._ic.set() @@ -736,7 +746,7 @@ class ChartView(ViewBox): # flag to prevent triggering sibling charts from the same linked # set from recursion errors. - autoscale_linked_plots: bool = True, + autoscale_linked_plots: bool = False, name: Optional[str] = None, # autoscale_overlays: bool = False, @@ -804,7 +814,7 @@ class ChartView(ViewBox): # for chart in plots: # if chart and not chart._static_yrange: # chart.cv._set_yrange( - # bars_range=br, + # # bars_range=br, # autoscale_linked_plots=False, # ) # profiler('autoscaled linked plots') @@ -858,9 +868,6 @@ class ChartView(ViewBox): # splitter(s) resizing src_vb.sigResized.connect(self._set_yrange) - # mouse wheel doesn't emit XRangeChanged - src_vb.sigRangeChangedManually.connect(self._set_yrange) - # TODO: a smarter way to avoid calling this needlessly? # 2 things i can think of: # - register downsample-able graphics specially and only @@ -871,9 +878,15 @@ class ChartView(ViewBox): self.maybe_downsample_graphics ) - def disable_auto_yrange( - self, - ) -> None: + # mouse wheel doesn't emit XRangeChanged + src_vb.sigRangeChangedManually.connect(self._set_yrange) + + # src_vb.sigXRangeChanged.connect(self._set_yrange) + # src_vb.sigXRangeChanged.connect( + # self.maybe_downsample_graphics + # ) + + def disable_auto_yrange(self) -> None: self.sigResized.disconnect( self._set_yrange, @@ -885,6 +898,11 @@ class ChartView(ViewBox): self._set_yrange, ) + # self.sigXRangeChanged.disconnect(self._set_yrange) + # self.sigXRangeChanged.disconnect( + # self.maybe_downsample_graphics + # ) + def x_uppx(self) -> float: ''' Return the "number of x units" within a single @@ -905,13 +923,6 @@ class ChartView(ViewBox): def maybe_downsample_graphics(self): - uppx = self.x_uppx() - # if not ( - # # we probably want to drop this once we are "drawing in - # # view" for downsampled flows.. - # uppx and uppx > 6 - # and self._ic is not None - # ): profiler = pg.debug.Profiler( msg=f'ChartView.maybe_downsample_graphics() for {self.name}', disabled=not pg_profile_enabled(), @@ -922,7 +933,7 @@ class ChartView(ViewBox): # the profiler in the delegated method calls. delayed=False, # gt=3, - # gt=ms_slower_then, + gt=ms_slower_then, ) # TODO: a faster single-loop-iterator way of doing this XD @@ -940,12 +951,6 @@ class ChartView(ViewBox): ): continue - graphics = flow.graphics - - # use_vr = False - # if isinstance(graphics, BarItems): - # use_vr = True - # pass in no array which will read and render from the last # passed array (normally provided by the display loop.) chart.update_graphics_from_flow( @@ -953,17 +958,9 @@ class ChartView(ViewBox): use_vr=True, # gets passed down into graphics obj - # profiler=profiler, + profiler=profiler, ) profiler(f'range change updated {chart_name}:{name}') profiler.finish() - # else: - # # don't bother updating since we're zoomed out bigly and - # # in a pan-interaction, in which case we shouldn't be - # # doing view-range based rendering (at least not yet). - # # print(f'{uppx} exiting early!') - # profiler(f'dowsampling skipped - not in uppx range {uppx} <= 16') - - # profiler.finish()