TiOzdZddlZddlZdZdZd$dZdZdZej fdZ ej fd Z ej d d ge Zd$d Zej fdZej fdZej fdZdZej fdZej fdZej fdZdZdZdZdZdZd$dZdZdZdZdZ dZ!d Z"ej fd!Z#d"Z$d#Z%dS)%a8 Numpy encode/decode/utility implementations for run length encodings. # Run Length Encoded Features Encoding/decoding functions for run length encoded data. We include code for two variations: * run length encoding (RLE) * binary run length encdoing (BRLE) RLE stores sequences of repeated values as the value followed by its count, e.g. ```python dense_to_rle([5, 5, 3, 2, 2, 2, 2, 6]) == [5, 2, 3, 1, 2, 4, 6, 1] ``` i.e. the value `5` is repeated `2` times, then `3` is repeated `1` time, `2` is repeated `4` times and `6` is repeated `1` time. BRLE is an optimized form for when the stored values can only be `0` or `1`. This means we only need to save the counts, and assume the values alternate (starting at `0`). ```python dense_to_brle([1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0]) == [0, 2, 4, 7, 2] ``` i.e. the value zero occurs `0` times, followed by `2` ones, `4` zeros, `7` ones and `2` zeros. Sequences with counts exceeding the data type's maximum value have to be handled carefully. For example, the `uint8` encoding of 300 zeros (`uint8` has a max value of 255) is: * RLE: `[0, 255, 0, 45]` (`0` repeated `255` times + `0` repeated `45` times) * BRLE: `[255, 0, 45, 0]` (`255` zeros + `0` ones + `45` zeros + `0` ones) This module contains implementations of various RLE/BRLE operations. Nc*tj|S)z6Optimized implementation of `len(brle_to_dense(brle))`npsumbrles Q/DATA/AppData/hermes/venv/lib/python3.11/site-packages/trimesh/voxel/runlength.py brle_lengthr 1s 6$<<c<tj|dddS)zAOptimized implementation of `len(rle_to_dense(rle_to_brle(rle)))`Nr)rles r rle_lengthr6s 6#add)  r cdd}dg}d}tj|dD]X\}}||z }|dvrtd||kr|dxx|z cc<4|t ||}Yt |dzr|d|t ||}|S) a: Convert run length encoded (RLE) value/counts to BRLE. RLE data is stored in a rank 1 array with each pair giving: (value, count) e.g. the RLE encoding of [4, 4, 4, 1, 1, 6] is [4, 3, 1, 2, 6, 1]. Parameters ---------- rle : (n,) int Run length encoded data Returns ---------- equivalent binary run length encoding. a list if dtype is None, otherwise brle_to_brle is called on that list before returning. Raises ---------- ValueError If any of the even counts of `rle` are not zero or 1. rr)rr z2Invalid run length encoding for conversion to BRLErrNdtype)rreshape ValueErrorappendintlen brle_to_brle)rrcurr_valoutaccvaluecounts r rle_to_brler!;s0H #C C 300 u u    QRR R H   GGGu GGGG JJs5zz " " "HH 3xx!| 1  3e,,, Jr ch|ds|drtj|ddgdS|ddS)a Get the BRLE encoding of the `logical_not`ed dense form of `brle`. Equivalent to `dense_to_brle(np.logical_not(brle_to_dense(brle)))` but highly optimized - just pads brle with a 0 on each end (or strips is existing endpoints are both zero). Parameters ---------- brle: rank 1 int array of binary run length encoded data Returns ---------- rank 1 int array of binary run length encoded data corresponding to element-wise not of the input. rrr constantmode)rpadrs r brle_logical_notr'fsD" Aw$r(vdQF4444AbDzr ct|dkrgSt|dg}d}|ddD]B}|r|dxx|z cc<d}|dkrd} |t|C|S)z#Inverse of split_long_brle_lengths.rFr NrT)rrr)lengthsr accumulatinglengths r merge_brle_lengthsr,}s 7||q wqz?? CL!""+((  ( GGGv GGG LL{{#  3v;;'''' Jr c8tj|}tjj|k}tj|rt |}tj|z}|z}tjfdt||D}| tj |dz|zf}|S|j kr|S|S)a3 Split lengths that exceed max dtype value. Lengths `l` are converted into [max_val, 0] * l // max_val + [l % max_val] e.g. for dtype=np.uint8 (max_value == 255) ``` split_long_brle_lengths([600, 300, 2, 6], np.uint8) == [255, 0, 255, 0, 90, 255, 0, 45, 2, 6] ``` cTg|]$\}}tjdg|z|gz%S)rr)rarray).0repeat remainderrmax_vals r z+split_long_brle_lengths..sL   %FI'1.)>EEeLL %  ~~e$$$r c|jtkrtdt|jdkrtdt|}t jdt j|dd|ddkdzf}t jt j||f}t||}|drt j |ddgd }|S) aX Get the binary run length encoding of `dense_data`. Parameters ---------- dense_data: rank 1 bool array of data to encode. dtype: numpy int type. Returns ---------- Binary run length encoded rank 1 array of dtype `dtype`. Raises ---------- ValuError if dense_data is not a rank 1 bool array. z`dense_data` must be boolr z`dense_data` must be rank 1.rNrrr#r$) rboolrrshaperr_ flatnonzerodiffr@r&) dense_datarnstartsr)s r dense_to_brlerJs"44555 : !!7888 JA U1bnZ^z#2#%FGG!KK LFgbeFAI&''G%gU;;;G!};&1a&z::: Nr FTrc|t}n6tj|}|jdkrt d|jtjttjddft|dzdzd}tj|dt|tj|tS) aDecode binary run length encoded data to dense. Parameters ---------- brle_data: BRLE counts of False/True values vals: if not `None`, a length 2 array/list/tuple with False/True substitute values, e.g. brle_to_dense([2, 3, 1, 0], [7, 9]) == [7, 7, 9, 9, 9, 7] Returns ---------- rank 1 dense data of dtype `bool if vals is None else vals.dtype` Raises ---------- ValueError if vals it not None and shape is not (2,) N)rzvals.shape must be (2,), got r rraxisr) _ftrr5rCrr1newaxisrflattenr) brle_datavalsfts r brle_to_denserTs" |z$ :  ITZIIJJ J 3rz111}%I(:q'@q I I I Q Q S SB 9R(#i..()2:is+K+K+K L L T T V VVr c Btjtj|ddd\}}|tj||} tjtj|dtj|dt}n#t$rutjtj|tj dtj|td}YnwxYw|S)zAGet the dense decoding of the associated run length encoded data.rrrrLNr) rsplitr asanyarrayr1squeezer9r TypeErrorint64)rle_datarvaluescountsresults r rle_to_denser_sXbj7;;QRHHHNFF vU333   JvB ' ' 'F)D)D)D)K)KC)P)P       Jv}}RX..R 8 8 8 Jv}}S)) 3 3 3   MsABAr2s r rara s(%$Jj111G#G{{}} (Q;&&s++j( 67++(3w<tt||S)\ Almost the identity function. Checks for possible merges and required splits. r)r@r,)rrs r rrIs ##5d#;#;5 I I IIr ctj|dj\}}t||\}}t |||\}}tj||fdS)rsrrr rL)rrTrmrarbrP)rrr\r)s r rprpRsm jg..0OFG'88OFG,VWEJJJOFG 8VW%A . . . 6 6 8 88r ct|tjstj|d}tj||dfd }|S)NFcopyctjt|pt|dd}t ||<|S)Nrr)rrergetattrtuple)datarr^orderordered_indicessorted_gather_fns r fz_unsorted_gatherer..fdsR#e**E,QWT7D5Q5QRRR..t_EEFFu  r N) isinstancerndarrayr/argsort)indicesrrr}r~s ` @@r _unsorted_gathererr^st grz * *0(7/// Jw  EenO Hr c#Kt|}t|} t|}n#t$rYdSwxYwd} ||krH t|}|t|z }n#t$rtd||wxYw||kH ||kr|Vt|}||kn#t$rYdSwxYw)a Gather brle_data at ordered_indices. This is equivalent to `rle_to_dense(brle_data)[ordered_indices]` but avoids the decoding. Parameters ---------- brle_data: iterable of run-length-encoded data. ordered_indices: iterable of ints in ascending order. Returns ---------- `brle_data` iterable of values at the dense indices, same length as ordered indices. NrT-Index %d out of range of raw_values length %diternext StopIteration IndexError)r[r~ data_iter index_iterindexstartrs r sorted_rle_gather_1drls#"XIo&&JZ    Eunn Yi(     CUE  unn %-- Z((%--    EE s,2 AA !A//B B55 CCc#Kt|}t|} t|}t|}n#t$rYdSwxYwt|D]}t|}|r|VY)a! Perform masking of the input run-length data. Parameters ---------- rle_data: iterable of run length encoded data mask: iterable of bools corresponding to the dense mask. Returns ---------- iterable of dense values of rle_data wherever mask is True. TNrrrranger[maskr mask_iterrr _ms r rle_maskrsXIT I  OOEOOEE    EE u  AYA   sA AAc#Kt|}t|}d} | }t|}n#t$rYdSwxYwt|D]}t|}|r|VM)a. Perform masking of the input binary run-length data. Parameters ---------- brle_data: iterable of binary run length encoded data mask: iterable of bools corresponding to the dense mask. Returns ---------- iterable dense values of brle_data wherever mask is True. TNrrs r brle_maskrsXIT I E  IEOOEE    EE u  AYA   s8 AAc,t|tS)a8 Get a gather function at the given indices. Because gathering on RLE data requires sorting, for instances where gathering at the same indices on different RLE data this can save the sorting process. If only gathering on a single RLE iterable, use `rle_gather_1d`. Parameters ---------- indices: iterable of integers Returns ---------- gather function, mapping `(rle_data, dtype=None) -> values`. `values` will have the same length as `indices` and dtype provided, or rle_data.dtype if no dtype is provided. )rrrs r rle_gatherer_1drs( g'; < < values`. `values` will have the same length as `indices` and dtype provided, or rle_data.dtype if no dtype is provided. r) functoolspartialrrrBrs r brle_gatherer_1dr&s.(  7$9::$   r c2t||S)a Gather BRLE data values at the provided dense indices. This is equivalent to `rle_to_dense(rle_data)[indices]` but the implementation does not require the construction of the dense array. If indices is known to be in order, use `sorted_brle_gather_1d`. Parameters ---------- rle_data: run length encoded data indices: dense indices Returns ---------- numpy array, dense data at indices, same length as indices and dtype as rle_data )r)rQrs r brle_gather_1dr?s& % G $ $Y / //r ct|dzdkrtj|dggd}|ddkrdnd}|d|dS)z>Equivalent to dense_to_brle(brle_to_dense(brle_data)[-1::-1]).rrrLrN)rrr:)rQends r brle_reverserUs[ 9~~QNIs#3!<<< " """"C RBY r ct|tjstj|d}tj|d}|ddd}tj|dS)z1Get the rle encoding of the reversed dense array.FrwrrNr)rrrr/r)r[s r rle_reverser]s] h + +28H5111z(G,,HBH :h & &&r c0g}g}t|}d} t|}tt|}||z}|r\|t j||tj|t j|||}#t$rYnwxYwt|dkrt|dksJ||fSt j |}t j ||j }||fS)z,Get dense indices associated with non-zeros.rTr) rrrrrarangerZr1rrr:r)r[rr\itrrr]rs r rle_to_sparserfs#G F hB E   HHEb]]F&.C 8ry28DDDEEE biv66777E        7||q6{{anW%%G ^F(. 9 9 9F F?sBB)) B65B6ctj|}fdt|ddd|dddD}tj|S)NcDg|]\}}tj||S)r)rr)r0sers r r4z"brle_to_sparse..s.SSS1ryAU+++SSSr rr )rrgr;r:)rQrendsrs ` r brle_to_sparsersY 9Y  DSSSSD1ItADqDz8R8RSSSG >' " ""r c~tj|d}d}t|}t|D]\}\}}|r |dkr|}n||z }d}t|}t|dddD]\}\}}|r |dkr|}n||z }|||dkrdn| d}|||ffS)a! Remove leading and trailing zeros. Parameters ---------- rle_data: run length encoded data Returns ---------- (stripped_rle_data, padding) stripped_rle_data: rle data without any leading or trailing zeros padding: 2-element dense padding rrNrr)rrr enumerate) r[rfinal_iivalr rfinal_jjs r rle_striprsz(G,,H E(mmG$X..rs))V  ((((V.&,.8    F%'H<bht}D)))WWWW6"$$$&835(!!!!H###"HRRRR XJJJJ( 9 9 9 9    '''T68===.;;;;.(((V2000,   '''4%'H#### """"""J%#%#%#%#%#r