def run(self, bead): "Creates the display" plot = self.__fcn(bead) if np.isscalar(bead) else bead crvs = [(i[1], j) for i, j in plot.data.items() if i[0] == 'Curve'][::2] quad = self.__quadmesh(crvs) text = self.__quadmeshtext(crvs) sp1 = [ self.__getx(j.data) for i, j in plot.data.items() if i[0] == 'Scatter' ][1::2] sp2 = [(np.ones((len(j), 3)) * (i + .5) + [-.5, .5, np.NaN]).ravel() for i, j in enumerate(sp1)] if self._reference is not None: ref = self.__quadmeshref(sp1, sp2) if len(sp1): pks = hv.Curve( (np.repeat(np.concatenate(sp1), 3), np.concatenate(sp2)), label='peaks').options(**self._peakstyle) else: pks = hv.Curve(([], []), label='peaks').options(**self._peakstyle) if self._reference is not None: return (quad * ref * pks * text).redim(x='z', y='key', z='events') return (quad * pks * text).redim(x='z', y='key', z='events')
def __errorbars(cls, det, params, opts, pstyle, hist): if 'size' in pstyle: pstyle = dict(pstyle) pstyle.pop('size') if len(det.positions) == 0: return hv.Curve(([], []), **opts).options(**pstyle) means = [((i - params[1]) * params[0], Probability.resolution(j)) for i, j in det.output] xvals = np.hstack([[i - j, i + j, np.NaN] for i, j in means]) yvals = np.hstack([[hist[i], hist[i], np.NaN] for i, j in means]) return hv.Curve((xvals, yvals), **opts).options(**pstyle)
def temperatures(self): "displays the temperatures" get = lambda i, j: getattr(self._items, i)[j] fcn = lambda i, j: hv.Curve( (get(i, 'index'), get(i, 'value')), 'image id', '°C', label=j) return fcn('tservo', 'T° Servo') * fcn('tsink', 'T° Sink') * fcn( 'tsample', 'T° Sample')
def __quadmeshref(self, sp1, sp2): ind = 0 sp2.pop(ind) ref2 = (np.zeros((len(sp1[ind]), 3)) + [0., len(sp1), np.NaN]).ravel() ref = hv.Curve((np.repeat(sp1.pop(ind), 3), ref2), label=f'{self._reference}') return ref.options(**self._refstyle)
def run(self, bead): "creates the display" if self.__pins is None: self.__pins = self._hpins() if isinstance(self._fit, dict): cnf = dict(sequence=self._sequence, oligos=self._oligos, **dict(self._fit)) elif self._fit is not True: cnf = dict(sequence=self._sequence, oligos=self._oligos, fit=self._fit) else: cnf = dict(sequence=self._sequence, oligos=self._oligos) self.__fits = self._items.new(FitToHairpinDict, config=cnf) if 'rescaling' in getattr(getattr(self._items, 'track', None), 'instrument', ()): self.__fits.config = self.__fits.config.rescale( float(self._items.track.instrument['rescaling'])) cache = self.__cache if bead not in cache: try: cache[bead] = min(self.__fits[bead].distances.items(), key=lambda i: i[1][0]) except Exception as exc: # pylint: disable=broad-except cache[bead] = None, exc key, dist = cache[bead] if isinstance(dist, Exception): return hv.Overlay([hv.Curve(([0], [0])), hv.Text(0, 1, str(dist))]) tmp = self(stretch=dist.stretch, bias=dist.bias) crv = tmp.elements(self._items[[bead]], group=key) # pylint: disable=no-member hpc = self.__pins[key] data = np.copy(hpc.data) tmp = next(iter(crv)).data if isinstance(tmp, np.ndarray): data[:, 1] *= np.nanmax(tmp[:, 1]) else: data[:, 1] *= np.nanmax(tmp['events']) def _pos(val): return .8 * np.nanmax(val) + .2 * np.nanmin(val) pars = np.round(dist.stretch, 1), np.round(dist.bias, 4) if pars[1] < 0: txt = f'{hpc.vdims[0]} = {pars[0]}·({hpc.kdims[0]}+{-pars[1]})' else: txt = f'{hpc.vdims[0]} = {pars[0]}·({hpc.kdims[0]}-{pars[1]})' text = hv.Text(_pos(data[:, 0]), _pos(data[:, 1]), txt, kdims=hpc.kdims + hpc.vdims) return hv.Overlay(crv + [hpc.clone(data=data), text], group=key)
def fixed(self, display=True, zrange=(-.02, .04), **kwa): "displays aligned cycles for fixed beads only" data = super().fixed(**kwa) if display: alg = FixedBeadDetection(**kwa) hmap = getattr(data.withphases(*alg.diffphases), 'display').display() spread = lambda x: hv.Curve( np.diff(self.fixedspread(x, **kwa), axis=0).ravel(), label="spread").redim(y="z", x="frames") hmap = hmap * hv.DynamicMap(spread, kdims=['bead']) return hmap.redim.range(z=zrange) if zrange else hmap return data
def _crv(data, opts, labl, ind): # pylint: disable=inconsistent-return-statements cols = sorted( [i for i in data.columns if i.split("@")[0].strip() == ind]) cols = [hv.Dimension(i, label=labl) for i in cols] tmp = dict(opts) if ind == "consensus": tmp.pop('color', None) ind = hv.Dimension(ind, label=labl) if len(cols) == 1 or len(cols) == 3: crv = hv.Curve(data, "zmag", ind, label=ind.name).options(**tmp) if len(cols) == 1: return crv if len(cols) == 2: return hv.Area(data, "zmag", cols, label=ind.name).options(**tmp) if len(cols) == 3: return hv.Area(data, "zmag", cols[1:], label=ind.name).options(**tmp) * crv assert False
def _show(bead): try: info = self.beaddata(bead=bead) exc = "" except Exception as _: # pylint: disable=broad-except zcyc = self._concat( self._items.secondaries.zmagcycles.values()) info = pd.DataFrame({ "zmag": zcyc, "z": np.zeros_like(zcyc), "phase": np.ones_like(zcyc), "cycle": np.ones_like(zcyc) }) exc = str(_) crv = (hv.Curve(info, 'zmag', ["z", "phase"]).options(alpha=self._alpha, color="gray")) return (crv * crv.to.scatter().opts(color="phase", cmap="greens") * hv.Text((info.zmag.min() + info.zmag.max()) / 2, .5, exc))
def _hpins(self): "returns haipin positions" opts = deepcopy(self._opts) for i, j in self.graphdims().items(): opts.setdefault(i, j) pks = {} if self._labels is True: opts['label'] = 'sequence' tmp = sequences.peaks(self._sequence, self._oligos) if isinstance(tmp, np.ndarray): tmp = (('hairpin 1', tmp), ) for key, vals in cast(Sequence[Tuple[str, np.ndarray]], tmp): xvals = np.repeat(vals['position'], 3) yvals = np.concatenate([[(0., .1)[plus], (.9, 1.)[plus], np.NaN] for plus in vals['orientation']]) pks[key] = (hv.Curve((xvals, yvals), **opts).options(**self._sequencestyle)) return pks
def _beadextent(self, bead): # pylint: disable=too-many-locals act = lambda _, info: (info[0], np.nanmedian(info[1])) extr = lambda i, j: { k[0][1]: k[1] for k in (i.cleancycles[bead, ...].withphases(j).withaction(act)) } ovr = {} dim = hv.Dimension('extents', unit='µm') for key, track in self.tracks.items(): if bead in set(track.beads.keys()): mins = extr(track, PHASE.initial) maxs = extr(track, PHASE.pull) keys = sorted(set(mins) & set(maxs)) extents = np.full(max(keys) + 1, np.NaN, dtype='f4') extents[keys] = [maxs[i] - mins[i] for i in keys] frame = pd.DataFrame( dict(cycles=np.arange(len(extents), dtype='i4'), extents=extents)) else: frame = pd.DataFrame( dict(cycles=np.empty(0, dtype='i4'), extents=np.empty(0, dtype='f4'))) ovr[key] = hv.Curve(frame, 'cycles', dim) data = pd.concat( [j.data.dropna().assign(track=i) for i, j in ovr.items()]) miss = list(set(ovr) - set(data.track.unique())) data = pd.concat( [data, pd.DataFrame({ 'track': miss, 'extents': [0] * len(miss) })]) return (hv.BoxWhisker(data, "track", dim) + hv.NdOverlay(ovr).options(show_grid=True)).cols(1)
def __histogram(det, params, norm, opts): return hv.Curve((det.xaxis(*params), det.yaxis(norm)), **opts)