edZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl Z ddl mZmZmZmZddlmZddlmZmZmZdd lmZdd lmZgd Zej8ddd d ej8dd dd ej8d ddd ej8dd d d ej8d dd d ej8d d dd ej8dddd ej8d d d d ej8d d d d ej8dddd ej8ddd d d ZdZdZe e!e"eDcgc]}e||dz dzfc}Z#de#d<ejHdezdzZ%ejHdezdzZ&d`dZ'dadZ(e%dfdZ)e*e%dfdZ+dZ,Gd d!ej8Z-d"Z.d#Z/d$Z0dbd%Z1e jdd&Z3e jdd'Z4e jdd(Z5dcd)Z6d*Z7ddd+Z8d,Z9d-Z:ded.Z;d/Zd2Z?dgd3Z@d4ZAdhd5ZBd6ZCd7ZDdid8ZEd9ZFd:ZGd;ZHdjd<ZIeJeKeLe jjd=dd>d?k\r e jZId@ZPdkdAZQdBZRdCZSdldDZTdEZUdFZVdmdGZWdHZXdndIZYdJZZdKZ[dodLZ\dMZ]dNZ^djdOZ_dpdPZ`dQZadRZbdSZcdqdTZddrdUZedafdVZgdWZhdXZidsdYZjdtdZZkdtd[Zldud\Zmd]ZnGd^d_eoZpycc}w)vz functions.py - Miscellaneous functions with no other home Copyright 2010 Luke Campagnola Distributed under MIT/X11 license. See license.txt for more information. )divisionN) OrderedDict)QtdebuggetConfigOptionreload) MetaArray)QT_LIBQtCoreQtGui)getCupy)getNumbaFunctions)0siScalesiFormatsiParsesiEvalsiApplyColormkColormkBrushmkPenhsvColor CIELabColor colorCIELab colorDistance colorTuplecolorStrintColorglColor makeArrowPatheqaffineSliceCoords affineSliceinterweaveArraysinterpolateArraysubArraytransformToArraytransformCoordinatessolve3DTransformsolveBilinearTransform clip_scalar clip_array rescaleDataapplyLookupTablemakeRGBAmakeARGB makeQImage imageToArray colorToAlphagaussianFilter downsample arrayToQPathisocurve traceImage isosurfaceinvertQTransform pseudoScattertoposort disconnect SignalBlockd) bgrcmykwdlsuyzafpnµm kMGTPEZYzyzafpnum kMGTPEZYiuzb(?P[+-]?((((\d+(\.\d*)?)|(\d*\.\d+))([eE][+-]?\d+)?)|((?i:nan)|(inf))))\s*((?P[uz]?)(?P\w.*))?$z&(?P[+-]?\d+)\s*(?P[uz]?)(?P.*)$c t|tjr t|} t j |sy t ||krd}n[ttt jt jt |t jdz dd}|dk(rd}n.|dks|dkDr d |d zz}n|r t|dz}n t|dz}d |z}d |z}||fS#xYw) u Return the recommended scale factor and SI prefix string for x. Example:: siScale(0.0001) # returns (1e6, 'μ') # This indicates that the number 0.0001 is best represented as 0.0001 * 1e6 = 100 μUnits )rrig"g"@rSirOze%drPg$@) isinstancedecimalDecimalfloatmathisfiniteabsintr,floorlog SI_PREFIXESSI_PREFIXES_ASCII)xminVal allowUnicoderHprefm1ps 5/usr/lib/python3/dist-packages/pyqtgraph/functions.pyrrIs!W__% !H}}Q  1v   DJJtxxA'7'FGsS TAv R1q5!} qs#D$QqS)D AB RA t9# s C..C1c |durd}|durd}t|||\}}t|dkDr|ddk(s||z}|dt|zdz} | ||z||fzS|r |d z|z} nd } dt|zd z} | ||z||| t||||| fzS) u Return the number x formatted in engineering notation with SI prefix. Example:: siFormat(0.0001, suffix='V') # returns "100 μV" T FrSrez%.zg%s%s±z +/- z g%s%s%s%s) precisionsuffixspacerb)rlenstrr) rarlrmrnerrorrbrcrfrdfmt plusminuss rgrrls } ~6<0IQ IMd1gnt| }S^#g-ac4(((  u,IIS^#k1ac4HUi`fns}C5DEE Ec|j}|Dt|dkDr6|t| d|k7rtd|d|d|dt| dz}|dk(r|dz }|j|}|td|z |j d }| |j d }n|}|j d |dn||dfS|fS#t $rd}YAwxYw#t $rd}Y;wxYw) uConvert a value written in SI notation to a tuple (number, si_prefix, suffix). Example:: siParse('100 µV") # returns ('100', 'µ', 'V') Note that in the above example, the µ symbol is the "micro sign" (UTF-8 0xC2B5), as opposed to the Greek letter mu (UTF-8 0xCEBC). Parameters ---------- s : str The string to parse. regex : re.Pattern, optional Compiled regular expression object for parsing. The default is a general-purpose regex for parsing floating point expressions, potentially containing an SI prefix and a suffix. suffix : str, optional Suffix to check for in ``s``. The default (None) indicates there may or may not be a suffix contained in the string and it is returned if found. An empty string ``""`` is handled differently: if the string contains a suffix, it is discarded. This enables interpreting characters following the numerical value as an SI prefix. NrzString 'z%' does not have the expected suffix ''XrSzCannot parse number "%s"siPrefixrmnumber)stripro ValueErrormatchgroup IndexError)rNregexrmrHsipsufs rgrrs2  A c&kAo c&k\] v %UVX^_` ` mF | s "| S AAy3a788ggj!~ ''(#C 778 CKbS " TTQT TT   C s$CC CC C'&C'cNt|||\}}}||}t||S)u Convert a value written in SI notation to its equivalent prefixless value. Example:: siEval("100 μV") # returns 0.0001 )rm)rr)rNtyprrmvalsiprefixvs rgrrs/$AuV<C6 CA 1h rtc\|dk7r t|nd}|dkDr|d|zzS|dkr |d| zz S|S)z rSr )SI_PREFIX_EXPONENTS)rrns rgrrsH*2RH%QA1uRU{ QR!V| rtceZdZdZdZdZy)rcPtjj|t|yN)r QColor__init__rselfargss rgrzColor.__init__s dGTN3rtc"|jS)z-Return (r,g,b,a) normalized for use in opengl)getRgbFrs rgr z Color.glColors||~rtcn|j|j|j|jf|Sr)redgreenbluealpha)rinds rg __getitem__zColor.__getitem__s+A$**dii` (int, hues) see :func:`intColor() ` "#RGB" "#RGBA" "#RRGGBB" "#RRGGBBAA" QColor QColor instance; makes a copy. ================ ================================================ z&Not sure how to make a color from "%s"rrzNo color named "%s"N#rrSzUnable to convert z to QColorr@__len__rP)rprorUr rColorsKeyErrorr{joinbytesfromhexisValidnp issubdtypetypefloatingr\hasattrr TypeErrorintegerrZ) rerrrGraqcolrFrErDas rgrrs& 3SY >C 4yA~ d1gs #QA1v{J <<q 22ts{s1v{abEq6A: 21Q 23A||U]]1%566||A<<>K #5aS !CDD Q .<<Q( ( ]]4Q="++ 6DGcM* *A *AA T!Wi (47|q q'1aT!W"!!W 1aT!W"a))n$ ]]4Q="** 5DG$ $C. Ta1a  Ta 1an67Aq\ Bbkk!nCF! + BD B << U J$%:Q%>?TIJ!3D CsJ9 K<)K9Kcnd|vr|d}nt|dk(rp|d}|7tjtjj j St|tjrtj|S|}nt|dkDr|}tjtS)z | Convenience function for constructing Brush. | This function always constructs a solid brush and accepts the same arguments as :func:`mkColor() ` | Calling mkBrush(None) returns an invisible brush. colorrr) ror QBrushr r BrushStyleNoBrushrUr)rkwdsrargs rgrr.s $W  Ta1g ;<< 4 4 < <= = U\\ *<<$ $E TQ << ''rtc|jdd}|jdd}|jdd}|jdd}|jdd}|jd d}t|dk(rx|d }t|tr t d i|St|t j rt j |S|%tjjj}n|}t|dkDr|}| td }| t|}n t|}t j t j||} | j||| j||| j!||d kDr3| j#tjj$j&| S)az Convenience function for constructing QPen. Examples:: mkPen(color) mkPen(color, width=2) mkPen(cosmetic=False, width=4.5, color='r') mkPen({'color': "#FF0", width: 2}) mkPen(None) # (no pen) In these examples, *color* may be replaced with any arguments accepted by :func:`mkColor() ` rNwidthrstyledashcosmeticThsvrrMg@r)getrorUdictrr QPenr rPenStyleNoPenrrr setCosmeticsetStylesetDashPattern setCapStyle PenCapStyleRoundCap) rkargsrrrrrrrpens rgrrCss IIgt $E IIgq !E IIgt $E 99VT "DyyT*H ))E4 C 4yA~1g c4 <3<  c5:: &::c? " [II&&,,EE 4y1} }  # **U\\%(% 0COOH  U  4  s{  --667 JrtcFtjj||||S)zEGenerate a QColor from HSVa values. (all arguments are float 0.0-1.0))r rfromHsvF)huesatrrs rgrr}s << c3 66rt))g7d?g,C?gv?)gz6?g,C?g]m{?)gN@aÓ?g2%䃾?"~j?))g!rh @g) 0gCl߿)g鷯gjt?g_L?)gPkw?g&1ʿgx?)r?gw-!l?ctjd|dzdz }|dxx|dz z cc<|dxx|dz zcc<t|D]$\}}|dkDr ||dz||<||d z d z ||<&t|z}t|z}tj d}t|d dD]!\}}|d kDrd |dzzdz ||<d|z||<#t |dd}tjjg||S)u Generates as QColor from CIE L*a*b* values. Parameters ---------- L: float Lightness value ranging from 0 to 100 a, b: float (green/red) and (blue/yellow) coordinates, typically -127 to +127. alpha: float, optional Opacity, ranging from 0 to 1 Notes ----- The CIE L*a*b* color space parametrizes color in terms of a luminance `L` and the `a` and `b` coordinates that locate the hue in terms of a "green to red" and a "blue to yellow" axis. These coordinates seek to parametrize human color preception in such a way that the Euclidean distance between the coordinates of two colors represents the visual difference between these colors. In particular, the difference ΔE = sqrt( (L1-L2)² + (a1-a2)² + (b1-b2)² ) = 2.3 is considered the smallest "just noticeable difference" between colors. This simple equation represents the CIE76 standard. Later standards CIE94 and CIE2000 refine the difference calculation ΔE, while maintaining the L*a*b* coordinates. Alternative (and arguably more accurate) methods exist to quantify color difference, but the CIELab color space remains a convenient approximation. Under a known illumination, assumed to be white standard illuminant D65 here, a CIELab color induces a response in the human eye that is described by the tristimulus value XYZ. Once this is known, an sRGB color can be calculated to induce the same response. More information and underlying mathematics can be found in e.g. "CIELab Color Space" by Gernot Hoffmann, available at http://docs-hoffmann.de/cielab03022003.pdf . Also see :func:`colorDistance() `. rPtrrrBgI_{?{a?S%@Ngsåi?zG?g?)\(?ףp= )@r) rfull enumerate VECTOR_XYZnMATRIX_RGB_FROM_XYZzerosr-r rfromRgbF) LrrDrvec_XYZidxrvec_RGBarr_sRGBs rgrrs#\gga1b5#'G AJ!c'J AJ!c'Jg&;S ="3<?GCL#CL61U:GCL ; G#G#W,Gxx{Hwr{,(S ?!C%L058HSM!CKHSM ( 8S#/H << 48 4U 44rtc|jdd}tjd}t|D]!\}}|dkDr|dzdz dz||<|dz ||<#t|z}|t z }t|D]$\}}|dkDr ||d z||<d ||zd z||<&tj d |d zdz d|d|d z zd|d |dz zg}|S)a Describes a QColor by an array of CIE L*a*b* values. Also see :func:`CIELabColor() ` . Parameters ---------- qcol: QColor QColor to be converted Returns ------- np.ndarray Color coordinates `[L, a, b]`. NrPg }ڵ?rrg333333@rg2#?gUUUUUU?rrrrrrrrBr)rrrrMATRIX_XYZ_FROM_RGBrarray)rsrgbrrrrvec_XYZ1vec_Labs rgrrs <<>"1 DhhqkGt%'S # $ Y-3GCL;GCL ' "G+G$Hh'9S >$SMC0HSM!(3-/&8HSM 9 hh hqkB x{Xa[() x{Xa[()+-G Nrtc~|j}t|dkrtjgtS|dk(rqg}d}|D]S}t |}||}t jtj||z dz}|j||}Utj|Std|d)a Returns the perceptual distances between a sequence of QColors. See :func:`CIELabColor() ` for more information. Parameters ---------- colors: list of QColor Two or more colors to calculate the distances between. metric: str, optional Metric used to determined the difference. Only 'CIE76' is supported at this time, where a distance of 2.3 is considered a "just noticeable difference". The default may change as more metrics become available. Returns ------- List The `N-1` sequential distances between `N` colors. rdtypeCIE76NrzMetric z is not available.) upperrorrrXrrYsqrtsumappendr{)colorsmetricdistlab1collab2dEs rgrrs&\\^F 6{Qrxx%88  Cs#D|BFFT$YN46B KKOD xx~ wvh&89 ::rtc"|jS)z&Return a tuple (R,G,B,A) from a QColor)getRgbrGs rgrrs 88:rtcdt|zS)z(Generate a hex string code from a QColorz%02x%02x%02x%02x)rrs rgrr!s  1 %%rtc t|}t|}t|||zz} | |z} | |z} |dkDr|| ||z |dz zzz} n|} || ||z z|zz} tjj| || |S)a Creates a QColor from a single index. Useful for stepping through a predefined list of colors. The argument *index* determines which color from the set will be returned. All other arguments determine what the set of predefined colors will be Colors are chosen by cycling across hues while varying the value (brightness). By default, this selects from a list of 9 hues.r)r\r rfromHsv)indexhuesvaluesmaxValueminValuemaxHueminHuerrrindhindvrhs rgrr&s t9D [F e*v &C :D $;D z t 1vax@A A $&-(T11A <<  35 11rtc8t|i|}|jS)z Convert a color to OpenGL color format (r,g,b,a) floats 0.0-1.0 Accepts same arguments as :func:`mkColor `. )rr)rrrGs rgr r <s A 99;rtc|.|tjtj|dzz}tj}|j dd|j || |A||tjtj|zz }|j |dn|dz}|||z tjtj|zz }|j || |j ||z| |j ||z||j |||j |||j dd|S)a Construct a path outlining an arrow with the given dimensions. The arrow points in the -x direction with tip positioned at 0,0. If *headWidth* is supplied, it overrides *tipAngle* (in degrees). If *tailLen* is None, no tail will be drawn. ?r)rYtanradiansr QPainterPathmoveTolineTo)headLen headWidthtipAngletailLen tailWidth baseAnglepathinnerYs rgr!r!Fs!dhht||HsN'CDD    DKK!KK)$9txx Y0G'HHH FAS Ii/488DLLt'|j|jD]\}}t||ryyt|t(t*frht|t(t*frRt|t|k7st|t|k7ryt'||D]\}} t|| ryy t-j.t} | j1||k(} | | j9ddd t| } | t>ur| S| tj@ur t?| St| tj stC| d rx| jEd rg |j|jk7ry tC| d r/| jEd r| jGjIS| jIStKd t=t| z#t2$rd} YwxYw#t4t6f$rY | j9dddyyt;dt;dt=t|t=|t;dt=t|t=|xYw# | j9dddwwxYw#YyxYw) aThe great missing equivalence function: Guaranteed evaluation to a single bool value. This function has some important differences from the == operator: 1. Returns True if a IS b, even if a==b still evaluates to False. 2. While a is b will catch the case with np.nan values, special handling is done for distinct float('nan') instances using math.isnan. 3. Tests for equivalence using ==, but silently ignores some common exceptions that can occur (AtrtibuteError, ValueError). 4. When comparing arrays, returns False if the array shapes are not the same. 5. When comparing arrays of the same shape, returns True only if all elements are equal (whereas the == operator would return a boolean array). 6. Collections (dict, list, etc.) must have the same type to be considered equal. One consequence is that comparing a dict to an OrderedDict will always return False. TF)rP)moduleNz#failed to evaluate equivalence for:z a:z b: implementsr z== operator returned type %s)&rUrXrYisnanrndarrayr rshaperrrosetkeysitemsr"rsys version_infoziplisttuplewarningscatch_warnings __enter__ Exceptionr{AttributeError__exit__printrpboolbool_rr$asarrayallr) rrDaIsArrbIsArrrJra_itemb_itemv1v2catcherrjts rgr"r"as  Av!U 1e 4 ::a=TZZ]BJJ 2 3F BJJ 2 3F&d1ga0 &agg0AGGqww4F!Tz!T2 7d1g Q3q6!1 qvvx=CM )GGI DAqa1;  a %)9)9V)C"%aggi"; !&&)  !!dE]# 1tUm(D 7d1g Q3q6!1AY EBrb": / ..b9G     qD     T4 . QADy bhhAw Arzz "wq,'?ALLQ\D] ww!''!" A| $k)B99;??$ $557N6T!WEFF= G   '     T4 .   34 fc$q'lCF+ fc$q'lCF+     T4 .  sO2*N(N:"Q( N73N:6N77N::P> Q!AP>>QQQ c Vt|t|k7r tdt|t|k7r td|D]$}t|t|k7stdtttj |}t |tjst j|}t |tjst j|}t|fdt|zz|_ tjt|Dcgc]}td|c}}|tjdf|jtftjft|zzzj!d}||z }|Scc}w) zQReturn the array of coordinates used to sample data arrays in affineSlice(). z(shape and vectors must have same length.z&origin and axes must have same length.z(each vector must be same length as axes.rr.raxis)ror3r.maprceilrUr&rr'mgridr/slicenewaxis transposeEllipsisr)r'originvectorsaxesrragrids rgr#r#sZ 5zS\!BCC 6{c$i@AA H q6SY FG GH RWWe$ %E grzz *((7# fbjj )&!I<$s5z/1FL 88Eu5!51:56 7D bjjn  1 1 3XK2::-PSTYPZBZ4Z [ [``fg`hAKA H 6s'F& c t||||}tt|j} |D]} | j | t |t | z} |j | }|dkDr ddl} |jt|d} tjt || z|j}tj| D]2}tf|z}| j j"|||fd|i|||<4n?t td|jdz}t%||j ||}tt|j}g}tt'|D]M}| j)|t|t|z z}|j ||j+|Ot ||z}|j |}|r||fS|S#t$r tdwxYw) a Take a slice of any orientation through an array. This is useful for extracting sections of multi-dimensional arrays such as MRI images for viewing as 1D or 2D data. The slicing axes are aribtrary; they do not need to be orthogonal to the original data or even to each other. It is possible to use this function to extract arbitrary linear, rectangular, or parallelepiped shapes from within larger datasets. The original data is interpolated onto a new array of coordinates using either interpolateArray if order<2 or scipy.ndimage.map_coordinates otherwise. For a graphical interface to this function, see :func:`ROI.getArrayRegion ` ============== ==================================================================================================== **Arguments:** *data* (ndarray) the original dataset *shape* the shape of the slice to take (Note the return value may have more dimensions than len(shape)) *origin* the location in the original dataset that will become the origin of the sliced data. *vectors* list of unit vectors which point in the direction of the slice axes. Each vector must have the same length as *axes*. If the vectors are not unit length, the result will be scaled relative to the original data. If the vectors are not orthogonal, the result will be sheared relative to the original data. *axes* The axes in the original dataset which correspond to the slice *vectors* *order* The order of spline interpolation. Default is 1 (linear). See scipy.ndimage.map_coordinates for more information. *returnCoords* If True, return a tuple (result, coords) where coords is the array of coordinates used to select values from the original dataset. *All extra keyword arguments are passed to scipy.ndimage.map_coordinates.* -------------------------------------------------------------------------------------------------------------------- ============== ==================================================================================================== Note the following must be true: | len(shape) == len(vectors) | len(origin) == len(axes) == len(vectors[i]) Example: start with a 4D fMRI data set, take a diagonal-planar slice out of the last 3 axes * data = array with dims (time, x, y, z) = (100, 40, 40, 40) * The plane to pull out is perpendicular to the vector (x,y,z) = (1,1,1) * The origin of the slice will be at (x,y,z) = (40, 0, 0) * We will slice a 20x20 plane from each timepoint, giving a final shape (100, 20, 20) The call for this example would look like:: affineSlice(data, shape=(20,20), origin=(40,0,0), vectors=((-1, 1, 0), (-1, 0, 1)), axes=(1,2,3)) rrNz]Interpolating with order > 1 requires the scipy.ndimage module, but it could not be imported.rorderr)rS)r#r.rangendimremover/rL scipy.ndimage ImportErrorr'roremptyrndindexrMndimagemap_coordinatesr&minrr)datar'rNrOrPrS returnCoordsrratrAxaxtr1scipy extraShapeoutputindsrtrtrbitr2s rgr$r$s^ %$7A dii !D B +d #C >># D qy  ZZD + %,34::FJJ + \D+$C7%--77S 1[E[UZ[F3K \ 5AFF# $t +!$ BuE eFKK !B C 3t9 iilc%jT23 # 3 B-C  c "F{ 9 }~ ~ s 3G..Hctd|D}tj|f|dj}t |}t |D] \}}|||d|<|S)a Parameters ---------- args : numpy.ndarray series of 1D numpy arrays of the same length and dtype Returns ------- numpy.ndarray A numpy array with all the input numpy arrays interwoven Examples -------- >>> result = interweaveArrays(numpy.ndarray([0, 2, 4]), numpy.ndarray([1, 3, 5])) >>> result array([0, 1, 2, 3, 4, 5]) c34K|]}|jywr)size).0ras rg z#interweaveArrays..Qs$!qvv$srrN)rrrZrror)rrnresultrrrs rgr%r%<sc* $t$ $D XXtgT!W]] 3F D A!$! u uxax! Mrtc J|dvrtd|ztj}|j}|jd}||kDr t dt j|jddt}|dk(rt j|jt}t|D]7} |d| fdk\|d| f|j| d z kz} d|d| f| <|| z}9|tt|jdD cgc] } |d| f c} } nL|d k(rFt jtd|d zf|z} t j |jt}|d z}t j"|t j$df|t j$dfg}g}t|D]} |d| fdk\|d| f|j| d z kz} || z}| |d| f|j| kz} |d| f| | }d||dk<d|||j| k\<|j'|||t|}|t j(|f|jzt*}||z }t|D]} | | j-| | jd |jd z zz}||d| fzd |z d |d| fz zz}|j-|jd |jd z |jz zz}||| <t j.|d }||z} t|D]} | j1d } ||jdkDr| |<n |d ur| dd| Scc} w) a N-dimensional interpolation similar to scipy.ndimage.map_coordinates. This function returns linearly-interpolated values sampled from a regular grid of data. It differs from `ndimage.map_coordinates` by allowing broadcasting within the input array. ============== =========================================================================================== **Arguments:** *data* Array of any shape containing the values to be interpolated. *x* Array with (shape[-1] <= data.ndim) containing the locations within *data* to interpolate. (note: the axes for this argument are transposed relative to the same argument for `ndimage.map_coordinates`). *default* Value to return for locations in *x* that are outside the bounds of *data*. *order* Order of interpolation: 0=nearest, 1=linear. ============== =========================================================================================== Returns array of shape (x.shape[:-1] + data.shape[x.shape[-1]:]) For example, assume we have the following 2D image data:: >>> data = np.array([[1, 2, 4 ], [10, 20, 40 ], [100, 200, 400]]) To compute a single interpolated point from this data:: >>> x = np.array([(0.5, 0.5)]) >>> interpolateArray(data, x) array([ 8.25]) To compute a 1D list of interpolated locations:: >>> x = np.array([(0.5, 0.5), (1.0, 1.0), (1.0, 2.0), (1.5, 0.0)]) >>> interpolateArray(data, x) array([ 8.25, 20. , 40. , 55. ]) To compute a 2D array of interpolated locations:: >>> x = np.array([[(0.5, 0.5), (1.0, 2.0)], [(1.0, 1.0), (1.5, 0.0)]]) >>> interpolateArray(data, x) array([[ 8.25, 40. ], [ 20. , 55. ]]) ..and so on. The *x* argument may have any shape as long as ```x.shape[-1] <= data.ndim```. In the case that ```x.shape[-1] < data.ndim```, then the remaining axes are simply broadcasted as usual. For example, we can interpolate one location from an entire row of the data:: >>> x = np.array([[0.5]]) >>> interpolateArray(data, x) array([[ 5.5, 11. , 22. ]]) This is useful for interpolating from arrays of colors, vertexes, etc. rrz/interpolateArray requires order=0 or 1 (got %s)z3x.shape[-1] must be less than or equal to data.ndimNrr.rrDrEF)r{rProfilerrVr'rronesr7roundastyper\rUr/rIrJr] concatenaterKrrZrXreshapeprodr)r_radefaultrSprofndmd totalMaskxindsrbmaskrjrqfieldsxminxmaxindexes fieldInds axisIndex fieldDatarNdxf1saxs rgr&r&Ysz FJURSS >> D B B BwMNN D1I z ""3') B#b&MQ&5R=DJJrN11 2   Y ' ( y)*   HHbUY__,E : X) B##F2J$4$4tRWWQY7G$GHBr#b&z/QrTa3r6 l$;;C++cii$!&&(3882C*DDECAbE   GGAA Qr (AZZQZ'F ( F~~$ z  F1IF MiKs N cVtj||d}t|}|jdd}t |j ddd}|d}|dddD]}|j ||zt|ddd}tj|||z||jS)a Unpack a sub-array from *data* using the specified offset, shape, and stride. Note that *stride* is specified in array elements, not bytes. For example, we have a 2x3 array packed in a 1D array as follows:: data = [_, _, 00, 01, 02, _, 10, 11, 12, _] Then we can unpack the sub-array with this call:: subArray(data, offset=2, shape=(2, 3), stride=(4, 1)) ..which returns:: [[00, 01, 02], [10, 11, 12]] This function operates only on the first axis of *data*. So changing the input in the example above to have shape (10, 7) would cause the output to have shape (2, 3, 7). Nrrt)bufferr'stridesr) rascontiguousarrayr/r'r.rrr&r)r_offsetr'stridereritemsizerNs rgr'r's,    %fg .D %LEABJ4<<"%&Gr{H AErE]%x!|$%GDbDM"G ::Tz)97RVR\R\ ]]rtc$t|tjrtj|j |j |jg|j|j|jg|j|j|jggSt|tjr3tj|jj!ddSt#d)a Given a QTransform, return a 3x3 numpy array. Given a QMatrix4x4, return a 4x4 numpy array. Example: map an array of x,y coordinates through a transform:: ## coordinates to map are (1,5), (2,6), (3,7), and (4,8) coords = np.array([[1,2,3,4], [5,6,7,8], [1,1,1,1]]) # the extra '1' coordinate is needed for translation to work ## Make an example transform tr = QtGui.QTransform() tr.translate(3,4) tr.scale(2, 0.1) ## convert to array m = pg.transformToArray()[:2] # ignore the perspective portion of the transformation ## map coordinates through transform mapped = np.dot(m, coords) rz;Transform argument must be either QTransform or QMatrix4x4.)rUr QTransformrrm11m21m31m12m22m32m13m23m33 QMatrix4x4 copyDataTorzr3)rhs rgr(r(s4"e&&'xx"&&(BFFHbffh7"&&(BFFHbffh9WZ\Z`Z`ZbdfdjdjdlnpntntnvYwxyy B(( )xx (00155UVVrtc :|rB|j|jdz fttd|jdz z}|jd}t |t jr|}n t|}|d|jddz }|jdk(rE|dk(r@t jd}|ddddf|ddddf<|dddf|dddf<d|d<|}|jdk(r@|dk(r;t jd}|ddddf|ddddf<|dddf|dddf<|}|j|jd |jdz zz}|t jd f}|ddd f}|dddd f}tj5tjd t ||zj#d }ddd|z }|r1|jttd|jdz}|S#1swYCxYw)a Map a set of 2D or 3D coordinates through a QTransform or QMatrix4x4. The shape of coords must be (2,...) or (3,...) The mapping will _ignore_ any perspective transformations. For coordinate arrays with ndim=2, this is basically equivalent to matrix multiplication. Most arrays, however, prefer to put the coordinate axis at the end (eg. shape=(...,3)). To allow this, use transpose=True. rrNrrPrP)rPrrrrrD.rtignorerErT)rLrVr/rUr'rUrr&r(rrZrzrKr0r1 simplefilterRuntimeWarningr)rhcoordsrLr~rHm2 translatemappeds rgr)r)#s&!!6;;q="2U56;;q=;Q5R"RS aB"bjj!  R  mqwwqz!|  ww%B!G XXe_rr"1"uX2A2rr6 bqbdG2A2q5 3  ww%B!G XXe_RaRU81RaR4BQBqD'1Q3  !''D&++a-001A BJJO $F!B$I !SbS& A  "(h7F(Q'( iF!!%a (<"="DE M((s 0HHc ^ddl}g}||fD]}t|tjr9tjdt }|ddddf|ddddf<d|dddf<nctj tdDcgc];}||j||j||jdg=c}}|j|tjd}tdD].}|jj|d|ddd|f||<0|Scc}w) z Find a 3D transformation matrix that maps points1 onto points2. Points must be specified as either lists of 4 Vectors or (4, 3) arrays. rN)rrrrPrrr) numpy.linalgrUrr&rZrXrrUrarIzrrlinalgsolve)points1points2numpyptsinpArjmatrixs rgr*r*`s  C! c2:: &e,A!BQB$iAadGAacF5QR8Ta3q688:s1vxxz3q688:qATUA 1 XXe_F 1X<LL&&s1vs1vac{;q < MUs=AD* c Fddl}tjtdDcgc]O}||j ||j z||j ||j dgQc}}tjtdDcgc](}||j ||j g*c}}tj d}tdD](}|jj||dd|f||<*|Scc}wcc}w)a Find a bilinear transformation matrix (2x4) that maps points1 onto points2. Points must be specified as a list of 4 Vector, Point, QPointF, etc. To use this matrix to map a point [x,y]:: mapped = np.dot(matrix, [x*y, x, y, 1]) rNrr)rrr) rrrrUrarIrrr)rrrrjrBrs rgr+r+ys ^cde^fgYZ71:<<>'!*,,.0'!*,,.'!*,,.RSTghA E!HEq71:<<>71:<<>2EFAXXe_F 1X2LL&&q!AaC&1q 2 MhEs AD-Dc"||kr|S||kDr|S|S)z? convenience function to avoid using np.clip for scalar values r)rvminvmaxs rgr,r,s:4>3:4>3>rtcN||tj||||S|,tjjj |||S|,tjjj |||Stjjj||||S)Nout)rclipcoreumathminimummaximum)arrrrrs rgr-r-s  | wwsD$C00 |ww}}$$S$C$88 ww}}$$S$C$88ww}}!!#tTs!;;rt.r)rctj||}d}|jjdvr|jdvrtj|j}t |tj r|jdn|} ||j| z z||j| z zf} | d| dkr | d| df} tjtj} | j| dkxr| d| jk}|r0|.|D cgc]#} t| | j| j%}} tj||gddgd gd d ggd|gd d } | 5| D]P\}}||d<||z}||z}||r |jtj}n|}t||d|d|R ddd|Scc} w#1swY|SxYw)z(Refer to documentation for rescaleData()rFuirrN external_loopbufferedreadonly writeonly no_broadcastunsafei)flagsop_flags op_dtypescasting buffersize.r)r empty_likerkindiinforUryitemr^maxint32r,nditerrxr-)data_inscaler work_dtype out_dtyperdata_out fits_int32lim_inlo dst_boundslim32ritrarIyins rg_rescaleData_nditerrs}}WI6HJ}}T!inn&< '--()&")) (data-offset) * scale rrrT)copyrF)rrrrr^rrYtrunccan_castfloat32float64rget_array_modulerxr-rr.r) r_rrrrrlimrarcprnumba_fns rgr.r.ss }JJ HHUO ~~hhy! <77CGG#D47CGG$c$q'377&;;(,,! 1 ,, {{4$ZZ ZZ B b!!$'2-;;z;5FE   xa$q'x @yu55 "HD$##D%DII tUFJ 4 PP9-sFc 8|jjdvr|jt}t }|rI|j ||k(r5|j ||j|d|jddz dStj ||ddS)a Uses values in *data* as indexes to select values from *lut*. The returned data has shape data.shape + lut.shape[1:] Note: color gradient lookup tables can be generated using GradientWidget. Parameters ---------- data : np.ndarray lut : np.ndarray Either cupy or numpy arrays are accepted, though this function has only consistently behaved correctly on windows with cuda toolkit version >= 11.1. )rjrQrrrEr)rFmode) rrrxr\rrtakerr'r)r_lutrs rgr/r/s zzj({{3 B b!!$'2-wwsBGGD!SYYq\A-=>QwGGwwsDqv66rtc"d|d<t|i|S)z)Equivalent to makeARGB(..., useRGBA=True)TuseRGBA)r1)rrs rgr0r0.sDO T "T ""rtcF t}|r|j|nt}tj} |j dvr t d|j dk(r|jddkDr t d|'t||js|j|}||jjdk(r'|jd d|jd zzd z g}n~|jjd k(r-d|jd zd z z} |j| | d z g}n8|jjd k(r|jd d g}n tdt||js|j|}|j|j }|j d k(r|jd dk7rtd|j dk(rE||j d kDr td|j|jddfk7r,tdtdt#|jz| d|||jd }nd}| |j$} n!|j'|jd d z } d} |rk|jjdk(rR|j)|j+r3|j)|} |j dkDr|j-| d} |%t||jr|j dk(r|jd |jdk7r td|j/|jt0} t3|jdD]N}||\}}||k(r|j5|d|z}||z }|d k(rd n|}t7|d|f||z || | d|f<P| }nI|\}}|d k7s||k7r:||k(r|j5|d|z}||z }|d k(rd n|}t7|||z || }| d| t9||}nE|j|j$k7r,|j;|d dj|j$}| d|.|j/|jdddz|j$}n|}| d|rgd }nt<j>d!k(rgd"}ngd#}tA||||}|rn|j dk(rt3dD] }||d||f<n]|jdd k(rt3dD]}|d$|d||f<n-t3d |jdD]}|d|f|d||f<| d%|j dk(r|jddk(rd&}nd'}|s d|d|df<| Td&}||k(rCtCtEt0|jFjId(d)krd || dd|df<n d || |df<| d*||fS)+a Convert an array of values into an ARGB array suitable for building QImages, OpenGL textures, etc. Returns the ARGB array (unsigned byte) and a boolean indicating whether there is alpha channel data. This is a two stage process: 1) Rescale the data based on the values in the *levels* argument (min, max). 2) Determine the final output by passing the rescaled values through a lookup table. Both stages are optional. ============== ================================================================================== **Arguments:** data numpy array of int/float types. If levels List [min, max]; optionally rescale data before converting through the lookup table. The data is rescaled such that min->0 and max->*scale*:: rescaled = (clip(data, min, max) - min) * (*scale* / (max - min)) It is also possible to use a 2D (N,2) array of values for levels. In this case, it is assumed that each pair of min,max values in the levels array should be applied to a different subset of the input data (for example, the input data may already have RGB values and the levels are used to independently scale each channel). The use of this feature requires that levels.shape[0] == data.shape[-1]. scale The maximum value to which data will be rescaled before being passed through the lookup table (or returned if there is no lookup table). By default this will be set to the length of the lookup table, or 255 if no lookup table is provided. lut Optional lookup table (array with dtype=ubyte). Values in data will be converted to color by indexing directly from lut. The output data shape will be input.shape + lut.shape[1:]. Lookup tables can be built using ColorMap or GradientWidget. useRGBA If True, the data is returned in RGBA order (useful for building OpenGL textures). The default is False, which returns in ARGB order for use with QImage (Note that 'ARGB' is a term used by the Qt documentation; the *actual* order is BGRA). maskNans Enable or disable masking NaNs as transparent. ============== ================================================================================== rzdata must be 2D or 3DrPrrzdata.shape[2] must be <= 4NrQrrOrrjrDz1levels argument is required for float input typesz"levels argument must have length 2z 2rtz*levels must have shape (data.shape[-1], 2)z0levels argument must be 1D or 2D (got shape=%s).z check inputso@frEzzWhen rescaling multi-channel data, there must be the same number of levels as channels (data.shape[-1] == levels.shape[0])r.z apply levelsr@z apply lutrallocaterrrrPlittle)rrrrP)rrrPr).rzreorder channelsTFr)rrz alpha channel)%rrrrrurVrr'rUr&rrrrr3rxrreprubytemin_scalar_typer%r^anyrZr\rU nextafterr.r/rr+ byteordertry_fastpath_argbr/rG __version__split)r_rlevelsrrmaskNansrfrxpprofilerNrnanMasknewDatarjrbmaxValrngimgData dst_orderfastpathrs rgr1r14sR B&(  T "bBnnG yy/00 yyA~$**Q-!+455 z#rzz:hhsm ~ ::??c !XXq!dmmAo"6q"89:F ZZ__ #DMM!Oa'(AXXr1Q3i(F ZZ__ #XXqe_FOP P fbjj )&! ]]2:: &F {{a <<?a @A A   ?sxx!|Z[ [ <2GDJJOOs*rxx /C((4. 99q=ffW2f.G  fbjj )fkkQ.>||A$**R.0!]^^hhtzzh5G4::b>* \!'V#\\&!F(;FVm!8a!,T#a%[%#+vUZ![A  \D$NFF{foV#\\&!F(;FVm!8a"4sF%H N c* :: !774C(//9D K~((4::bq>$.bhh(? J ( "  !T7Grtc|tuxr*|j|jk(xr|jd}|sy|jdd\}}|j dk(rdn|jd}t jj}|dk(r |j} n|dk(r |j} n |j} |r |j} n |j} | | k(r||ddyd} t| |z |z } td| } d} | |kr~t| | z|}|| |d f}|| |d f}t j|||jd|j d| }|j#| }t%|dd |dd|} | |kr~y) N C_CONTIGUOUSFrrrPTir.)rrL)rrrrr'rVr QImageFormatFormat_Grayscale8 Format_RGB888Format_RGBA8888 Format_ARGB32r\rr^rconvertToFormatr3)r ainaoutr can_handlenrowsncolsnchansrin_fmtout_fmt npixels_chunkbatchrow_begrow_endain_view aout_viewqimgs rgrrsrQcii2883Q .8QJ 99Ra=LE5((a-QSYYq\F \\ F {)) 1%%''((&& QM  %. /E 5MEG E/gou-ww+,#-. ||HeX^^A-> APVW##G,#DuF !  E/ rtctjdr)ttjj |}n|}|j dd\}}|jd}tj|||||}||_ |S)z Low level function to encapsulate QImage creation differences between bindings. "arr" is assumed to be C-contiguous. PyQtNrr) r startswithr\rrvoidptrr'rr rr_)rrrimg_ptrrrK bytesPerLiner*s rgndarray_to_qimager1st bffnnS)* 99Ra=DAq;;q>L <<A|S 9DDI Krtctj}d}|jdk(r%tjj j }n|jdk(r||jddk(}|jddk(r_|durPtj|jdddz|j}||ddddddf<d |dddddf<|}d}n td |d |r%tjj j}n0tjj j}n td |r|jd }|j ds/|dur|rdnd}td|ztj"|}d}|d|dur|dur|j%}|dt'||S)a Turn an ARGB array into QImage. By default, the data is copied; changes to the array will not be reflected in the image. The image will be given a 'data' attribute pointing to the array which shares its data to prevent python freeing that memory while the image is in use. ============== =================================================================== **Arguments:** imgData Array of data to convert. Must have shape (height, width), (height, width, 3), or (height, width, 4). If transpose is True, then the first two axes are swapped. The array dtype must be ubyte. For 2D arrays, the value is interpreted as greyscale. For 3D arrays, the order of values in the 3rd axis must be (b, g, r, a). alpha If the input array is 3D and *alpha* is True, the QImage returned will have format ARGB32. If False, the format will be RGB32. By default, _alpha_ is True if array.shape[2] == 4. copy If True, the data is copied before converting to QImage. If False, the new QImage points directly to the data in the array. Note that the array must be contiguous for this to work (see numpy.ascontiguousarray). transpose If True (the default), the array x/y axes are transposed before creating the image. Note that Qt expects the axes to be in (height, width) order whereas pyqtgraph usually prefers the opposite. ============== =================================================================== FrrPNrTrrr@z>Array has only 3 channels; cannot make QImage without copying.zadd alpha channelz$Image array must have ndim = 2 or 3.rrrrz (try setting transpose=False)rSzs>nnG F||qLL''99   =]]1%*E == q t|XXgmmBQ/$6gmmL$1Qrr6 1Qq5  `aa#$  ++99I ++88I>??##I. == ( 5=8A4rEZ[``a a&&w/   t|%,,. FO Wi 00rtc|j}| td|j|j}}|j }|j }||zdz}t jdr|j||ztj|tjj||f}|ddd|f}|dvrtj}|dz} n%|dvrtj}|dz} n td||f} | d k7r| | fz} |j|j| } | S) NzNull QImage not supportedrOr,r)rO )r@rzUnsupported Image Typer)bitsr{heightrr0depthr r-setsizer frombufferrrzuint8uint16view) r*r/rrKbplr? logical_bplmemoryrnchanr'rs rgndarray_from_qimagerIs(iikG455 ;;=$**,qA    C JJLEe)q.K  C ]]7"(( 3 ; ;QH EF A| |O $F   (   122 qDE z  ++e  $ $U +C Jrtct|}|j}||jjk(rd|d<|r|j }|r|j dS|S)a_ Convert a QImage into numpy array. The image must have format RGB32, ARGB32, or ARGB32_Premultiplied. By default, the image is not copied; changes made to the array will appear in the QImage as well (beware: if the QImage is collected before the array, there may be trouble). The array will have shape (width, height, (b,g,r,a)). r@.rPr3)rIformatrr4rrL)imgrrLrrrs rgr3r3sY c "C **,C cjj%%%E  hhj}}W%% rtc>|jt}|jddk(rAtj|jdddz|j }||dddf<d|d <|}|jt}tj |jddd zt}|j}d D]A}|d|f}||}||kD}|||z d |z z |d|f|<||k} ||| z |z |d|f| <C|jd d z|d <|d dk\}d |d |z } d D]<}|d|f|||z | z||z|d|f|<|d |xx|d |d z zcc<>tj|ddjtjS)a Given an RGBA image in *data*, convert *color* to be transparent. *data* must be an array (w, h, 3 or 4) of ubyte values and *color* must be an array (3) of ubyte values. This is particularly useful for use with images that have a black or white background. Algorithm is taken from Gimp's color-to-alpha function in plug-ins/common/colortoalpha.c Credit: /* * Color To Alpha plug-in v1.0 by Seth Burgess, sjburges@gimp.org 1999/05/14 * with algorithm by clahey */ rtrPNrrr.r@rK)rPrrrrrErr) rxrXr'rrZrrrrrr) r_rr7rrfrjrLrGrimask corrections rgr4r4s ;;u D zz"~ XXdjj!nT) <3rr6 5  LL E HHTZZ^D( 6E YY[F 1 QK !H1ugkdQh7c!e TA 1U8|q0c!e U 1II1I%,F5M %=C Du d++J 8 &s1u d 3E!H < JeTUhVs1u du dtE{404778 7761c " ) )"(( 33rtc t}|r|j|nt}|j|r|f|jz}|j }||z }t |jD]^}||}|dk(rt|dz}|j| |} |j| dz d|dzzz } dg|jz} t| | |<| j| } |j||z} dt|d|jzdzzz } | |jj!|jj#|| ||jj#| | |z|z}t%dg|jz}t%|j||j|z dd||<|t'|}a||zS) z Drop-in replacement for scipy.ndimage.gaussian_filter. (note: results are only approximately equal to the output of gaussian_filter) rrrrrrrEN)rrrisscalarrVmeanrUr\arangeexprorzr'r[pifftirfftrfftrJr/)r_sigmarr baselinefilteredrbrNksizerakernelkshaper'rsls rgr5r5s B&(  T "bB {{5499$yy{HhHDII' "I 6 AE  IIufe $A1a4() ![r ' 2&s1v2553./266<< He" (M(* FE (K)L-/(11 Dk]TYY &x~~b)$**R.8dC2E"I&/'0 h rtcLd}t|dr2|jdr!|}|jtj}t|drIt|ds|gt |z}t t |D]}t|||||}|S|dkr|St|j||z }t|j}|||<|j|dz|tdg|jz}td||z||<|t|} t|| _ | j|dz} || S|j!} d| |vr:|dk(r| |ddd|d|| |d<n|d k(rt| |d|| |d<t#| | S) zDownsample by averaging points together across axis. If multiple axes are specified, runs once per axis. If a metaArray is given, then the axis values can be either subsampled or downsampled to match. Nr$r rrrr  subsampler6)info)rr$rDrr&rorUr6r\r'r.insertrJrVr/rTinfoCopyr ) r_rrFxvalsmarjnPtsrNrad1r7rds rgr6r6s Bl# (D yy$tYq)$CI As4y! 3AdAaD$q'2D 3 Av tzz$!# $D TZZAAdGHHT!VQ + "BQQBtH eBiBQxBH aB z {{} tDz ! #'+Dz(';CaC'@$'GT 8$,&'1$t*X2F'JT 8$$''rtc|}tjt|}d||<tjj ||tj |d}|t|kr||d||Sy)Nrtrr)rrUror accumulate searchsorted)rZrrfirsts rg_compute_backfill_indicesroKsl 9D ))CM "CCIJJ#3' OOC #E s8}FU  rtcz|jd}|dk(rtjSd}|rYtj|tj|z}|j s|j d}t|}|dkrtjSd}||zdz |z}d}||krt|} t| } ||| dddf<|| dddf<n||| dddf<||| dddf<tj} t| dr| j|| j| | Stj} t| dr| j|tj} d} t|D]+}t||zt!|dz|z|}|j"|j$z }|| j'k7rBt| dr| j)|n$| j+t-j.|t| }||||dddf<|||dddf<n||}|||dddf<|||dddf<| tj} | j| | j1| t| dr| j3*d} .| S) Nrri'rrPreserveresizeclear)r'r rrrZr:nonzerorocreate_qpolygonfndarray_from_qpolygonfrrq addPolygon QPolygonFrUrJr^stopstartrnrrfillr QPointF connectPathrs)rarI finiteCheckr finite_idxrZ chunksize numchunks minchunkspolyrrsubpolysubpathrracurrsizesubarrfivs rg_arrayToQPath_allr_s  AAv!!##J;;q>BKKN2||~!))+A.JJA1u!!##IY"y0II9"$T*  C1IC1I* C1I* C1I!!# 4 # LLO      DtY QooGGY 3y=#s1ui&7"; <77RXX% w||~ %w)x( V^^-x8'0  R5F1a4LR5F1a4LR.CS6F1a4LS6F1a4L ?((*G7# ! 7G $ MMOG/0 Krtc|jd}|dk(rtjS|+tj|tj|z}tj}t |dr|j |tj|ddz}tj||}tj||}tt||}td|D} t| t} t dr j} ntj ffd } |ddD]O\} } t#| }|dkr| || | d|df<| | d|df<| |dz | |dz <|j%Q|ddD]A\} } t#| }|dkr| || | d|df<| | d|df<|j%C|S) Nrrqrc32K|]}t|ywr)ro)rochunks rgrpz'_arrayToQPath_finite..s1U1srrc(j||Sr)r{)rrrs rgz&_arrayToQPath_finite..s Q8Jrtrtr)r'r rrrZrrqrtrr.r-rrurvrrr r|rorw)rarIrZrrsidxxchunksychunkschunksmaxlenrsubpoly_resizexchunkychunklcrs @rg_arrayToQPath_finiters  AAv!!##;;q>BKKN2    DtY Q ::xi  #a 'Dhhq$Ghhq$G #gw' (F11 1Fv&G #G ,Fw! &,^^%5J!"+ ! [ 7 rssAvssAvbd|r!t    !!+! [ 7 rssAvssAv  ! Krtc |jd}|dk(rtjSd}t|tj r|d}}d}|dk(rv|s t ||St j|t j|z}|t j|z }|dk(}|rd}d}n||z dkr t |||Sd}|}|dk(r t|||Stj} t| dr| j|t| dr.td r#d} tjj| |} nt!j"} | j%d |d zzd z| j'dd t)j*d || j'd |d zzd t)j*dddt j,| gd|d } d} |rO|@t j|t j|z}t j.|}s t1|} | || d<|| d<n|| | d<|| | d<|dk(rd| dddd<d| dddd<n$|dk(rd| ddd|dd| dddn t3dt| t j"rt!j4| } | | z | S)a Convert an array of x,y coordinates to QPainterPath as efficiently as possible. The *connect* argument may be 'all', indicating that each point should be connected to the next; 'pairs', indicating that each pair of points should be connected, or an array of int32 values (0 or 1) indicating connections. Parameters ---------- x : np.ndarray x-values to be plotted of shape (N,) y : np.ndarray y-values to be plotted, must be same length as `x` of shape (N,) connect : {'all', 'pairs', 'finite', (N,) ndarray}, optional Argument detailing how to connect the points in the path. `all` will have sequential points being connected. `pairs` generates lines between every other point. `finite` only connects points that are finite. If an ndarray is passed, containing int32 values of 0 or 1, only values with 1 will connect to the previous point. Def finiteCheck : bool, default True When false, the check for finite values will be skipped, which can improve performance. If nonfinite values are present in `x` or `y`, an empty QPainterPath will be generated. Returns ------- QPainterPath QPainterPath object to be drawn Raises ------ ValueError Raised when the connect argument has an invalid value placed within. Notes ----- A QPainterPath is generated through one of two ways. When the connect parameter is 'all', a QPolygonF object is created, and ``QPainterPath.addPolygon()`` is called. For other connect parameters a ``QDataStream`` object is created and the QDataStream >> QPainterPath operator is used to pass the data. The memory format is as follows numVerts(i4) 0(i4) x(f8) y(f8) <-- 0 means this vertex does not connect 1(i4) x(f8) y(f8) <-- 1 means this vertex connects to the previous vertex ... cStart(i4) fillRule(i4) see: https://github.com/qt/qtbase/blob/dev/src/gui/painting/qpainterpath.cpp All values are big endian--pack using struct.pack('>d') or struct.pack('>i') This binary format may change in future versions of Qt rNrfiniter:Fg{Gz?rqenableExperimentalrrOz>iz>ii))rGz>i4)ra>f8)rIr)rcountrrarIpairsrGrrrtz;connect argument must be "all", "pairs", "finite", or array)r'r rrUrr&rrZrrrrqrr internalsget_qpainterpath_element_arrayr QByteArrayrrreplacestructpackrAr:ror{ QDataStream)rarIconnectr~r connect_arrayrZ nonfinite_cnt all_isfiniter backstorer backfill_idxdss rgr7r7sn  AAv!!##M'2::&!('w H('1- -;;q>BKKN2BFF8,, $) GK Q  ('1h7 7G$M% A{33    DtY QtYO4H$I ll99$B%%' QrTA&!Q D! 45!AbD&!V[[1%=>mmI-WAL  {{1~ A6H66(+L4X>LCC\?C\?C'CACA G  C! $Sb)C VWW)V../    * d Krtctjj|jt |dzdzd}t j |t jjdS)NrrOTr)rtr) rcompatr.r_rorrArrz)polylinevps rgrvrvrsO   8==?CM!OA,=t DB ==2:: . 6 6w ??rtctj}t|dr|j||S|j t j ||S)Nrr)r rxrrrr{r r|)rnrs rgruruxsG Hx" O  fnn&- Ortc|j|jcxk(r/|jdcxk(r|jdk(stdtd|j}t|}t |}||dddf<||dddf<|S)u Utility function to convert two 1D-NumPy arrays representing curve data (X-axis, Y-axis data) into a single open polygon (QtGui.PolygonF) object. Thanks to PythonQwt for making this code available License/copyright: MIT License © Pierre Raybaut 2020. Parameters ---------- x : np.array x-axis coordinates for data to be plotted, must have have ndim of 1 y : np.array y-axis coordinates for data to be plotted, must have ndim of 1 and be the same length as x Returns ------- QPolygonF Open QPolygonF object that represents the path looking to be plotted Raises ------ ValueError When xdata or ydata does not meet the required criteria rz&Arguments must be 1D and the same sizeNr)rnr'r{rurv)rarIrnrrGs rgarrayToQPolygonFrs8 !&&4AGGAJ4!''!*4ABB 5ABB 66D%H #H -FF1a4LF1a4L OrtcT |durd}|rtj|jddz|jddzf|j}||ddddf<|d|dddf<|d|dddf<|dddf|dddf<|dddf|dddf<|d|d <|d |d <|d |d <|d|d<|}gddgddgddgddgddggdddgddggdddgddgddgddgddggg}dd gd dgddgddgg}g}||k} tj|jD cgc]} | dz  c} tj } tjdt } tddtddg} dD]G}dD]@}| | || |f| ||f<|d|zz}tj| | ||fd|zz| dBIt| jdD]}t| jdD]o}|| ||f}tdt|dD]H}|||dz}g}dD]$}|||d}|||d}|||dz||dzf}|||dz||dzf}||z ||z z }d|z }|d|z|d|zz|zdz|d|z|d|zz|zdzf}|rXt|jddz td|ddz t|jddz td|ddz f}|r:|||dk(rdndz|||dk(rdndz||dzf}|j||f|j|'|j|Kr|s|Si}|D]U\}} |d|vrg||d<||dj|| g| d|vrg|| d<|| dj| |gWt|jD]}! ||!}"|"D]}}#d} | |#ddk(rnI|#dd} | |!k(rn;|#dd}$|| }%|%ddD]"}&|&dd|$k7s|#j#|&dd$|| =U|#dd|#ddk(sm|"j%g}|j'D]L}#t|#dk(r|#dddddd|#dz}#n|#d}#|j|#Dcgc]}|d c}N|s|St)j*}|D]-}'|j,|'d|'ddD]}|j.|/|Scc} w#t $rYKwxYwcc}w)a Generate isocurve from 2D data using marching squares algorithm. ============== ========================================================= **Arguments:** data 2D numpy array of scalar values level The level at which to generate an isosurface connected If False, return a single long list of point pairs If True, return multiple long lists of connected point locations. (This is slower but better for drawing continuous lines) extendToEdge If True, extend the curves to reach the exact edges of the data. path if True, return a QPainterPath rather than a list of vertex coordinates. This forces connected=True. ============== ========================================================= This function is SLOW; plenty of room for optimization here. TrrrrrtNrs)rr)rrt)rrt)rtr)rtr)rt)rtrtrPr)rr)rrrrrrrrr)rrZr'rrrobjectrJaddrUror^rrr.r)rextendpopr r rrr)(r_level connected extendToEdgerr7 sideTableedgeKeylinesrrarrslicesrjj vertIndexsidesrMedgesrrHp1p2r?r@rfirfgridKeypointsrrDrJchainschainrIconnectsconnlines( rgr8r8s* t|  XXtzz!}Q 1 a8 K1R42:1g1ad7 Bx2qt8 1a4j1R47 ArE{1R48 S'3d84d84uI5  1 1 1 1 1 1 1 1 1 1 1 1 ! I(      G E % ""u{{1~& "AeAaCj)E1c%j!, "a! &A q*1-B q*1-Ba1gqAw./Ba1gqAw./Brbe,AqB1b2a57*Q.41b2a57*Q.4A$  1 aQ!Q@ 1 aQ!Q@!"#E!HaKqQ"?5QR8UV;a\]A^`efg`hij`j"j Aw<0 1 +&. S!5 " "">  F#! Q4v F1Q4Lqt QqE" Q4v F1Q4Lqt QqE" #&++-  AYF EAb ! $"IaL6"IaL!!9$QK/DAwqzQ T!"X./ 1IQx{eBil* )  < E, u:?!HQRL2&q1E!HE E*qad*+ ,     D T!Wab A DKKO  K[/B   B+s TT/ T%  T"!T"c|jdk(r |j}|tjtjdfj t }|dtjfj t }tj ||z }|jdk(r|jd}tj|d}g}t|jdD]}||k(j t }t|||f}t|ddd}tj} |D]-} | j| d | d d D]} | j | /|j#| |S) aY Convert an image to a set of QPainterPath curves. One curve will be generated for each item in *values*; each curve outlines the area of the image that is closer to its value than to any others. If image is RGB or RGBA, then the shape of values should be (nvals, 3/4) The parameter *smooth* is expressed in pixels. r.rrErtrT)rrrrN)rVTrrKrxrXr[rargminrUr'r5r8r rrrr) imager smoothdifflabelspathsrjrLrrrrfs rgr9r9 sT{{a BJJ C/ 0 7 7 >F #rzz/ " ) )% 0E 66%, D {{axxQx YYt! $F E 4::b> "  QY  u % 1vv. /C4dC!!# D DKKa !!"X  Q   T  Lrtcttjgdtj}gggdgdgdgdgdgd gd gd gd gd gdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgd gd!gd"gd#gd$gd%gd&gd'gd(gd)gd*gd+gd,gd-gd.gd/gd0gd1gd2gd3gd4gd5gd6gd7gd8gd9gd:gd;gd<gd=gd>gd?gd@gdAgdBgdCgdDgdEgdFgdGgdHgdIgdJgdKgdLgdMgdNgdOgdPgdQgdRgdSgdTgdUgdVgdWgdXgdYgdZgd[gd\gd]gd^gd_gd`gdagdbgdcgddgdegdfgdggdhgdigdjgdkgdlgdmgdngdogdpgdqgdrgdsgdtgdugdvgdwgdxgdygdzgd{gd|gd}gd~gdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgd¢gdâgdĢgdŢgdƢgdǢgdȢgdɢgdʢgdˢgd̢gd͢gd΢gdϢgdТgdѢgdҢgdӢgdԢgdբgd֢gdעgdآgd٢gdڢgdۢgdܢgdݢgdޢgdߢgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdgdg}tjgdgdgdgdgdgdgdgd gd gd gd gd g tj}tj|Dcgc]}t |dz c}tj }dg}t ddD]}tjt ||dzftj } tj||k(} tj| D cgc] } || d c} | | dddf<| jt ||df} |j|| ||||fan t\}}}}|jds td||k} tj|jD cgc]} | dz  c} tj }tjdt}t!ddt!ddg}dD]k}dD]c} dD][}| |||| ||f||| |f<|d| z|zz d| zzd|zz}tj"|||| |fd|zz|d]emtj|jD cgc]} | dz c} dgztj$}||}t'|ddD]j\}}t dD cgc](} t!|| |j| || dz z*}} ||d|d|d|dfxx|d|zzz cc<l|dkD}tj|}|ddddfj)tj*}|j|jd|jdz|jdz}tj,|jd||dddf|dddf|dddf|dddff<dD]}|dddf|k(}||ddf}|tj|j.dd|j0ztj2ddfzj5d}||}|||j.||j0zz}|||fxx||z ||z z z cc<||}|j5} tj| dftj$}!d}"tj|j.|j0z}#|j7}t ddD]=}tj||k(}$|$jddk(r1||$dddf|$dddf|$dddff}%|||%}&tj"|&dddf|$ddtj2tj2ddf|&dddfd|&j|&jd|zf|&jddz}&|&|#tj2tj2ddfzj5d}&||&}'|'jd}(|'|!|"|"|(z|"|(z }"@||!fScc}wcc} wcc} wcc} wcc} w(a Generate isosurface from volumetric data using marching cubes algorithm. See Paul Bourke, "Polygonising a Scalar Field" (http://paulbourke.net/geometry/polygonise/) *data* 3D numpy array of scalar values. Must be contiguous. *level* The level at which to generate an isosurface Returns an array of vertex coordinates (Nv, 3) and an array of per-face vertex indexes (Nf, 3) N(r          093:6?5<< 5 ?6 :39 0   `icjfoell e ofjc i ` r@   PYSZV_U\\U_ V Z S YP  rWrVrUrTrSrRrQrPrOrNrMrLrKrJrIrHrGrFrErDrCrBrAr@r?r>r=r<r;r:r9r8r7r6r5r4r3r2r1r0r/r.r@r-r,r+r*r)r(r'r&r%r$r#r"r!r rrrrrrrrrrrrrrrrrrr r r r r rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)rrOrP)rr )rrOrPrXrOr)rrr)rrOrPrrr)rXrrrrrX) rrOrPrrrOrrXrO)rP r)rrYrrOrYr)rrXrrrPrY) rrYrrrXrYrXrOrY)rPrrrYrrP) rrrrrOrrOrYr) rPrXrrPrYrXrYrrX)rXrOrrrOrY)rr"rO)rrPrr"rPr)rrrXrOrr") rrrXrr"rr"rPr)rrrrOrr") rPrr"rPrrrrr) rXrrrXrrrOrr") rrrXrrXr"rr"rPr"rXr)rOrr"rPrYr) rYrr"rYrrrrr) rXrrrOrr"rrPrY) rr"rYrXrrYrXrYrrXrr) rPrrrPrYrr"rOr) rrYrrrrYrrrr"rYr) rr"rOrXrrYrXrYrrYrrP) rr"rYrrYrXrXrYr)rXr)rXrZrrrOrP)rrZrrrZr) rOrZrrOrPrZrPrrZ)rrrrXrZr) rPrrOrrrrrXrZ) rZrrrZrrrrr) rrrZrPrrZrPrZrrPrrO)rXrZrrrPrY) rrYrrrOrYrrXrZ) rrZrrrrZrrPrY) rrrZrrZrOrrOrYrrOrZ) rrPrYrrrPrXrZr) rrXrZrrOrrOrrrOrYr) rZrrrZrrYrZrYrrYrrP) rZrrOrZrOrrrOrY)rXr"rOrZr"rX) rXrPrrXrZrPrZr"rP) rr"rOrrr"rrZr")rrZrPrPrZr") rXr"rOrXrZr"rrr) rrrrXrZrrZrPrrZr"rP) rOrrrOrrZrOrZr"rrZr) rrrZrrZrPrPrZr") r"rXrZr"rOrXrPrYr) rXrZr"rXr"rrXrrrr"rY) rrPrYrrrOrr"rOrrZr") rYrrrYrr"r"rrZ) rXrZrOrOrZr"rrrPrrPrY)rZr"rrZrrXr"rYrrrrrYrr)rYrrrYrrPrrZrrOrr"rZr"r)rYrrZr"rYrZ)rrrZ)rrOrPrZrr)rXrrrZrr) rrOrPrrXrOrZrr)rrrZrrr) rrrZrrrrPrrO) rXrrZrXrrrrr) rZrXrOrZrOrrZrrrPrrO)rrPrYrrrZ) rYrrOrYrrrrrZ) rrrXrrPrYrZrr) rZrrrrXrrXrYrrXrOrY) rrPrYrrZrPrZrrP) rrOrYrrYrZrrZrrZrYr) rPrYrrrPrrrrZrrZrX) rrZrXrrXrYrYrXrO)rZrrrr"rO) rrPrrr"rPrrZr) rrXrrZrrrOrr") rrrZrrXr"rr"rPr"rXr) rrrrrZrrr"rO) rrrZrZrrrPrrrPrr") rOrr"rXrrZrrrZrrr)r"rPrXr"rXrrPrrXrZrXrrrrX) rPrYrr"rOrrrrZ) rZrrrr"rrrrrr"rY) rrrXrr"rOrrPrYrZrr)rXrrrXrYrrXrrYr"rYrrZrr) rOrr"rPrYrZrPrZrrZrYr)rZrrYrZrYrrrrYr"rYrrrrY)rrZrXrrrZrrPrrYrrPrOrr") rrZrXrrXrYrr"rXr"rYrX)rrrXrrr) rrrrrXrrrOrP) rrrrrrrrr) rOrPrrOrrrOrrrrr) rrrXrrrrrr) rPrrOrrrXrrrXrrr)rrrrrr) rOrPrrOrrrrr) rrrXrrrrYrrP) rrOrrrOrYrrXrrrr) rPrYrrrrrrrrrr)rrrrrrrrOrrrrYrOrYr) rXrrrXrPrrXrrPrYrrP)rOrYrrOrrrYrrrXrrrrr) rPrYrrPrrrrr)rrrOrYrrO) r"rrr"rOrrOrXr) rr"rPrrr"rrXrrr"r) rrr"rrr"rr"rOrrOr) rrr"rr"rrr"rP) rrrrrrOrrOrXrOrr")rrrXrrXrrr"rXrrXrPr"rPrX) r"rOrr"rrrrr)r"rPrrr"r) rrPrYrrrOrrOrXrOrr")rrr"rr"rYrrXr"rr"rrXrr")rrOrrr"rOrrr"rr"rrrPrY) rYrrrYrr"rrrrr"r)rOrXrrOrr"rXrrrYrrPrrPr)rrXrrYrr") r"rOrr"rrrPrYrrYrr)r"rYr)r"rrY)rPrrOrYr"r)rrrXrYr"r) rOrrXrOrPrrYr"r)rrrrrYr") rrrrPrrOrrYr") rrXrrrrXrrYr") rrYr"rrrPrrOrPrrXrO)r"rrPrrr") r"rrOr"rrrrr) rr"rrrPr"rrrX) rrrrrOrrrXrOrOr"r) rr"rrrr"rrPr") rr"rrr"rrrOr"rrrO) rrPr"rr"rrrrXrrr") r"rrr"rrOrOrrX)rrOrrYrOr) rPrrYrPrrrrr) rOrrYrOrrrXrr) rXrrrXrrPrXrPrrYrPr) rrOrrrYrOrrr) rrrrPrrYrrrYrrr) rrYrOrrrYrrrXrrrX)rrXrPrrPrrXrrPrYrPrrrrP) rOrrPrOrrrrr)rrrrrr) rrXrrrPrrrrrrPrO) rrXrrrrrrr) rOrrPrOrrrOrrrrr) rrrrrrrrr)rrrPrrPrOrrrPrrPrXrrXrP)rrXrrrr)rrXrZr"rrY) rrOrPrrXrZrYr"r) rZrrrZrrr"rrY) rYr"rrOrPrrPrZrrPrrZ) rXrZrrrrr"rrY) rrYr"rrrrrOrPrrXrZ) r"rrYrZrrrrrrrr)rPrrOrPrZrrPrrZrrZrrYr"r) r"rrPr"rrrZrrX) rXrZrrrOrrrrrrOr") rPrrrPr"rrrZrrZrr)rrrOrrOr"rrrOrrOrZrrZrO) rXrZrrrrrr"rrrPr")rrrrr"rrrr"rOr"rrXrZr)rrrrrrZrrPrrrr"rPr"r) r"rrr"rrOrZrrrrOr) rrXrZrrYrXrYrOrX) rPrrYrrrPrrZrrrXrZ) rrYrOrrZrYrrrZrZrrY) rrYrPrrPrZrZrPr) rrrrXrZrYrXrYrOrYrZr)rrYrPrrrYrrXrrZrrXrrr)rYrOrZrYrZrrOrrZrrZrrrrZ) rrYrPrrPrZrrrPrrZrP) rZrOrXrZrrOrZrrrPrOr) rXrZrrXrrrrr)rrZrOrrOrrZrrOrPrOrrrrO)rrZrrrr)rrPrrrrrPrOrrZrrXrOrXr) rrrrrrrXrZrrZrr)rrPrOrZrr)rrZr)rYrZrr"rZrY) rYrZrrYr"rZrOrPr) rZrYr"rZrrYrrXr) rr"rZrrYr"rXrOrrOrPr) rYrrrYr"rr"rZr) rrOrPrrr"rr"rZr"rrY) rXr"rZrXrr"rXrrrrYr")r"rZrr"rrYrZrXrrPrrOrXrOr) rrZrrrPrZrPr"rZ) rOrrrOrZrrOr"rZrrrZ) rXrrrZrrPrZrPr"rPrr)rXrOrrXrrrOr"rrrrZr"rZr)rrPrZrPr"rZ) rrOr"rr"rrr"rZ) rXrrPrXrPrZrZrPr")rXrOr"rZrXr") rZrOrrZrrOrrYrO) rZrrrZrYrrZrrYrYrPr) rrrXrOrrrOrrYrrrZ)rrYrrrrZrYrPrrXrrrPrr) rrZrrrOrZrrYrOrrZrO)rrrYrrYrPrrZrYrrYrrZrrY)rrrZrrZrXrrYrZrrZrOrYrOrZ)rXrrZrrYrP) rrZrrPrZrrPrrZrPrOr) rZrrrZrrrrr)rPrrrPrZrrPrOrZrrZrOrrrX) rZrrrZrrrrXrrXrr) rOrrZrOrZrPrPrZr)rrrZrrrZ) rOrrZrOrZrPrXrrZrrPrZ)rXrrZ) rrYr"rrXrYrXrrY) rrOrPrrXr"rXrYr"rXrrY) rrrYrrYrrrrr"rrY)rPrrrPrrOrrrr"rrYrrYr) rrYr"rXrYrrXrrYrXrr)rXr"rrXrYr"rXrrYrrYrrrOrP) rYr"rrYrrrrr) rYr"rrYrrrOrPrrPrr) rrXrrr"rXrrPr"r"rrX)rXrr"rXr"rrrr"rOr"rrrr")rPr"rrPrrr"rrrrrrrr)rrrrOr"r) rrXrrrr"r"rrP) rrXrrrr"rrOrrOr"r)rrrPr"rrP)rrOr")rXrrOrrYrO) rPrrXrPrXrYrYrXr) rrrrrrOrOrrY)rPrrrYrPr) rrrYrrYrXrXrYrO) rPrrXrPrXrYrrrXrrYrX)rrrYrOrrY)rPrrY) rrPrOrrOrrrOrX)rXrrrrXr) rrPrOrrOrrrrOrrrO)rrr)rrPrOrXrrO)rrXr)rrPrO)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrr)rrrrrPrrrrz+isosurface input data must be c-contiguous.)rrrrtrsrrrr rOrE.)IsosurfaceDataCacherrrCrorrUrargwhererzrrrr'rZrrJruint32rrxrrUrrrKrflatten))r_r edgeTabletriTable edgeShiftsr nTableFacesfaceShiftTablesrj faceTableI faceTableIndsrrrarrrrJrcutEdgesrshiftrH vertexIndsvertexesdataFlatvimviviFlatr?r@nFacestotFacesfacesptrcscellscellIndsvertsvertIndsnvs) rgr:r: sI(" HH!BYYC! NA A A  A   A  A A  A  *A  A  !A  A  +A  "A  ,A  +A "!A " #A $ %A & 'A ( ()A * +A , )-A . )/A 0 21A 2 3A 4 *5A 6 )7A 8 49A : +;A < 5=A > 5?A @ ,AA B CA D EA F GA H (IA J KA L )MA N )OA P 2QA R SA T *UA V )WA X 2YA Z +[A \ 4]A ^ 5_A ` +aA b cA d (eA f (gA h iA j )kA l 2mA n 2oA p )qA r )sA t 2uA v 2wA x *yA z 4{A | >}A ~ >A @ "AA B CA D EA F GA H )IA J KA L (MA N (OA P 1QA R !SA T +UA V *WA X 4YA Z )[A \ 4]A ^ 2_A ` *aA b cA d )eA f )gA h 2iA j (kA l 1mA n 1oA p :qA r *sA t 3uA v 3wA x >yA z 3{A | ?}A ~ ;A @ 3AA B !CA D *EA F *GA H 2IA J (KA L 1MA N OA P (QA R +SA T 4UA V 3WA X =YA Z 2[A \ <]A ^ )_A ` aA b +cA d 4eA f 3gA h *iA j 1kA l :mA n (oA p qA r 4sA t =uA v =wA x 4yA z ;{A | }A ~ 3A @ AA B CA D EA F GA H )IA J !KA L *MA N *OA P 5QA R SA T (UA V (WA X 1YA Z *[A \ 3]A ^ 4_A ` +aA b cA d )eA f )gA h 2iA j *kA l 4mA n 4oA p =qA r (sA t uA v 1wA x (yA z 2{A | *}A ~ <A @ !AA B CA D )EA F )GA H 2IA J *KA L 3MA N 4OA P iA j 2kA l ?mA n IA J 4KA L =MA N *OA P 3QA R 2SA T Q;Y  ::n %EFF %QE"HB// 0. Fzz|H HHh]")) 4E C ("" #X%6%6 6B!H 1QZ FaK( ;;q>Q  qsU1Q3Zqs;< "8, uS!V}eAbjjA$=>E#bqb&M[cd u{{1~a/1%++ab/ABBJJ A566;;;CE? ^^A $c#b& r 36 U?s < 7^0/3Tsk7k  k k-kc tj|j|j|j |j |j |j|j|j|jg }d|_ tjj|}tj|j!j#S)N)rPrP)rrrrrrrrrrrr'rpinvr rraveltolist)rhrrzs rg_pinv_fallbackr} s ((BFFHbffhFFHbffhFFHbffh2 3CCI 99>># D   TZZ\002 33rtc |j}d|z }|j}||z}|S#t$rt|cYSwxYw)aCReturn a QTransform that is the inverse of *tr*. A pseudo-inverse is returned if tr is not invertible. Note that this function is preferred over QTransform.inverted() due to bugs in that method. (specifically, Qt has floating-point precision issues when determining whether a matrix is invertible) r) determinantadjointZeroDivisionErrorr})rhdetdetrinvs rgr;r; sO"nnSyjjl t  "b!!"s+.AAcT|dk(rt||||S|dk(rt||||Sy)aJReturn an array of position values needed to make beeswarm or column scatter plots. Used for examining the distribution of values in an array. Given an array of x-values, construct an array of y-values such that an x,y scatter-plot will not have overlapping points (it will look similar to a histogram). exact)spacingshufflebidir histogramN)_pseudoScatterExact_pseudoScatterHistogram)r_rrrmethods rgr<r< s="4'QVWW ; &tWgUZ[[ rtctjt|}|rtjj |||}|'dtj |zt|dzz }tj t|}|j}|j}t||z |z dz}tj|||} | d| dz } || dz | z jt} i} t| D]$\} }| j|ddz}|| |<||| <&|dur3t|D]%} || | k(xx| j| ddzzcc<'|tj|S)zWorks by binning points into a histogram and spreading them out to fill the bin. Faster method, but can produce blocky results. @rrrrtT)rrUrorandomrstdrZr^rr\linspacerxrrrUargsort)r_rrrrgyvalsdmindmaxnbinsbinsrdbins binCountsrjrrGs rgrr sp 99SY D $ :DRVVD\/#d)S.0 HHSY E 88:D 88:D dg% & *E ;;tT5 )D a47 BT!Wn " * *3 /EI! MM!R 1 $ ! a  }u 9A %(Oy}}Q2S8 8O 9 D! ""rtc$tjt|}|rtjj |||}|'dtj |zt|dzz }|dz}tj t|}t|dk(r|Sd|d<tdt|D];}||}|d|} |d|} d} | |z dz} | |k} | jdkDr|rddg}ndg}g}|D]}d} | | }||z dz}tj dt|f}| | |z |d<| | |z|d< |dkDr |d| k\}n|d| k}|dd|f}|d| k|d| kDz}|jdk(rn5|dkDr|dd|fj} n|dd|fj} y|j| |r|d |dkr|dn|d} n|d} | ||<>|tj|S)zWorks by stacking points up one at a time, searching for the lowest position available at each point. This method produces nice, smooth results but can be prohibitively slow for large datasets. Nrrrrrrt) rrUrorrrrZrUrrr^rr)r_rrrrgs2rrjrax0y0rIrxmaskdirsyopts directiondx2dylimitsrlimits2s rgrr sW 99SY D $ :DRVVD\/#d)S.0 !B HHSY E 4yA~ E!H 1SY - G "1X 2AY dQYR 99;?AwsE! i3h_1SW+.uINq uINq  1}%ayA~%ayA~$QtVnG$AJNwqzA~>DxxzQ 1}#AdFO//1#AdFO//1#$ Q3 4!&q E!H 4E!H%(!Ha[-^ D! ""rtc |j}t|jD]\}}|D] }||vsg||<|It}|j D]}|t|z}t|j |z }| t}g}g} |D]f} | |vrt d|| gz| |vr|j| | jt||| ||| gz|dz| j| h| S)uTopological sort. Arguments are: deps dictionary describing dependencies where a:[b,c] means "a depends on b and c" nodes optional, specifies list of starting nodes (these should be the nodes which are not depended on by any other nodes). Other candidate starting nodes will be ignored. Example:: # Sort the following graph: # # B ──┬─────> C <── D # │ │ # E <─┴─> A <─┘ # deps = {'a': ['b', 'c'], 'c': ['b', 'd'], 'e': ['b']} toposort(deps) => ['b', 'd', 'c', 'a', 'e'] zCyclic dependency detectedr)r?) rr.r*r(r r)r3rrr=r) depsnodesseenstackr?rJrremdepsortedrs rgr=r=8 s ( 99;DDJJL!! A}Q   }e;;= C 3s8OC DIIK 3& |u F  :8%1#+F F 9    xd1gtUA3YeAgNO a Mrtc |j|}|d}|rytj|}|y2#ttf$rd}Y/wxYw)aDisconnect a Qt signal from a slot. This method augments Qt's Signal.disconnect(): * Return bool indicating whether disconnection was successful, rather than raising an exception * Attempt to disconnect prior versions of the slot when using pg.reload TF)r>r RuntimeErrorr getPreviousVersion)signalslotsuccesss rgr>r>g sf  ''-G ((. <  <( G s4AAc"eZdZdZdZdZdZy)r?zClass used to temporarily block a Qt signal connection:: with SignalBlock(signal, slot): # do something that emits a signal; it will # not be delivered to slot c ||_||_yr)rr)rrrs rgrzSignalBlock.__init__ s  rtcPt|j|j|_|Sr)r>rr reconnectrs rgr2zSignalBlock.__enter__ s#DKK; rtch|jr&|jj|jyyr)rrrrrs rgr5zSignalBlock.__exit__ s$ >> KK   * rtN)rrr__doc__rr2r5rrtrgr?r? s +rtr?)}:T)rPrSTNrT)rrr)r)r)rXrr@rAihrr@r@)rNrrrPr)rF)rr)Fr)NN)NNNFTN)NTT)FT)rrc)r:T)FFF)r)NTFr)NTF)NNNr)qr __future__rrVrYrerr+r0 collectionsrrrrSrrrr metaarrayr r r r util.cupy_helperrutil.numba_helperr__all__rrr_r`rrUrorcompile FLOAT_REGEX INT_REGEXrrrrXrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r/rGr\rrrrr.r/r0r1rr1r2rIr3r4r5r6rorrr7rvrurr8r9r\r:r}r;r<rrr=r>rr?)rjs0rgrs   #00 %%%0 >0 a#c " aAc " c!Ac " aC $ c!C $ c#a $ a!C c#c# & c#c# & c#c# & c#c# & # 'uSEU?VW![^ac1W5WXCbjj~BMMPiij BJJ@;NQff g  FE<!4Un{4    DELL DDN(*7t7 bhh! " bhh! " bhh13 C5J$L!;F& 2,6_GD :Yx:CL ^FWB8z2.? <  S"..&&s+BQ/ 01W< J1h1Qh72# |~)X>M1`#L*+4Z&R)(X(DN<~KZ@ $zslFJZ4"$ \!#HB#L,^2+&+}aXs K?