+
    …°ñjæL  ã            
       óâ   € R t ^ RIt^ RIHt ^ RIt^ RIHu Ht ^ RI	H
t
 ^ RItRR ltRR ltR tR tR tR	 tR
 tR tR tR tR t ! R R4      t ! R R4      tR^RRR^R^ RR/R R lltR# )u)  
Optical-flow-warped noise for VOID Pass 2 refinement.

Adapted from RyannDaGreat/CommonSource (MIT License, Ryan Burgert):
  https://github.com/RyannDaGreat/CommonSource
  - noise_warp.py  (NoiseWarper / warp_xyÏ‰c / regaussianize / get_noise_from_video)
  - raft.py        (RaftOpticalFlow)

Only the code paths that ``comfy_extras/nodes_void.py::VOIDWarpedNoise`` actually
uses (torch THWC uint8 input, no background removal, no visualization, no disk
I/O, default warp/noise params) have been inlined.  External ``rp`` utilities
have been replaced with equivalents from torch.nn.functional / einops.  The
RAFT optical-flow model itself is loaded offline via ``OpticalFlowLoader`` in
``nodes_void.py`` and passed into ``get_noise_from_video`` by the caller; this
module never downloads weights at runtime.
N)ÚOptional)Ú	rearrangec                ó  € V P                   ^8w  d"   \        R\        V P                  4       24      hV P                  w  rEp\	        V\
        \        34      '       dN   \	        V\        4      '       g8   \        ^\        WQ,          4      4      p\        ^\        Wa,          4      4      pMVw  rxWx3WV38X  d   V'       d   V P                  4       # T # / p	VR9   d   RV	R&   \        P                  ! V R,          3RWx3RV/V	B ^ ,          p
V
# )a  Resize a CHW tensor.

``size`` is either a scalar factor or a (h, w) tuple.  ``interp`` is one
of ``"bilinear"``, ``"nearest"``, ``"area"``.  When ``copy`` is False and
the requested size matches the input, returns the input tensor as is
(faster but callers must not mutate the result).
z5_torch_resize_chw expects a 3D CHW tensor, got shape FÚalign_cornersNÚsizeÚmode)ÚbilinearÚbicubic)ÚndimÚ
ValueErrorÚtupleÚshapeÚ
isinstanceÚintÚfloatÚboolÚmaxÚcloneÚFÚinterpolate)Úimager   ÚinterpÚcopyÚ_Úin_hÚin_wÚnew_hÚnew_wÚkwargsÚouts   &&&&       Ú@C:\Ai_Coding\apps\studio\ComfyUI\comfy_extras\void_noise_warp.pyÚ_torch_resize_chwr!       sî   € ð ‡z�z�Q„ÜØCÄEÈ%Ï+É+ÓDVÐCWÐXó
ð 	
ð —K‘K�M€AˆTÜ�$œœe˜×%Ò%¬j¸¼t×.DÒ.DÜ�A”s˜4�;Ó'Ó(ˆÜ�A”s˜4�;Ó'Ó(‰à‰ˆà€~˜$˜Ô%ß $ˆu�{‰{‹}Ð/¨%Ð/à€FØÐ(Ô(Ø"'ˆˆÑÜ
�-Š-˜˜d�Ñ
P¨5¨.Ð
P¸vÐ
PÈÑ
PÐQRÕ
S€CØ€Jó    c                ó<  € V P                   ^8w  d"   \        R\        V P                  4       24      hVP                  VP                  8w  d8   \        R\        VP                  4       R\        VP                  4       24      hV P                  w  rEpV\        P
                  ! WaP                  VP                  R7      ,           pV\        P
                  ! WRP                  VP                  R7      R
,          ,           pWv^,
          ,          ^,          ^,
          p	W…^,
          ,          ^,          ^,
          p
\        P                  ! Wš.RR7      R,          P                  V P                  4      p\        P                  ! V R,          W³RRR	7      ^ ,          pV# )zÓRelative remap of a CHW image via ``F.grid_sample``.

Equivalent to ``rp.torch_remap_image(image, dx, dy, relative=True, interp=interp)``
for ``interp`` in {"bilinear", "nearest"}.  Out-of-bounds samples are 0.
z9_torch_remap_relative expects a 3D CHW tensor, got shape z1_torch_remap_relative: dx and dy must match, got ú vs ©ÚdeviceÚdtypeN©ÚdimTÚzeros)r   r   Úpadding_mode©:NNNNéÿÿÿÿ)r
   r   r   r   ÚtorchÚaranger&   r'   ÚstackÚtor   Úgrid_sample)r   ÚdxÚdyr   r   ÚhÚwÚx_absÚy_absÚx_normÚy_normÚgridr   s   &&&&         r    Ú_torch_remap_relativer<   =   s@  € ð ‡z�z�Q„ÜØGÌÈeÏkÉkÓHZÐG[Ð\ó
ð 	
ð 
‡x�x�2—8‘8ÔÜØ?ÄÀbÇhÁhÃÐ?PÐPTÔUZÐ[]×[cÑ[cÓUdÐTeÐfó
ð 	
ð �k‰k�G€Aˆ!à”—’˜a¯	©	¸¿¹ÔBÕB€EØ”—’˜a¯	©	¸¿¹ÔBÀ7ÕKÕK€Eà˜1•u�o Õ" QÕ&€FØ˜1•u�o Õ" QÕ&€Fä�;Š;˜Ð'¨RÔ0°Õ6×9Ñ9¸%¿+¹+ÓF€DÜ
�-Š-Øˆd��T°dÈôàõ	€Cð €Jr"   c                óâ  € V P                   ^8w  d"   \        R\        V P                  4       24      hV P                  w  r4pVP                  WE38w  g   VP                  WE38w  d>   \        RV RV R\        VP                  4       R\        VP                  4       24      hVP	                  4       \
        P                  ! WQP                  \
        P                  R7      ,           pVP	                  4       \
        P                  ! WBP                  \
        P                  R7      R,          ,           pV^ 8¬  Wt8  ,          V^ 8¬  ,          We8  ,          P                  R4      pWu,          V,           P                  R4      V,          p	\        V R4      V,          p
\
        P                  ! WE,          V3V P                  V P                  R7      pVP                  ^ Wš4       \        VR	WER
7      # )zÈScatter-add a CHW image using relative floor-rounded (dx, dy) offsets.

Equivalent to ``rp.torch_scatter_add_image(image, dx, dy, relative=True,
interp='floor')``.  Out-of-bounds targets are dropped.
z?_torch_scatter_add_relative expects a 3D CHW tensor, got shape z,_torch_scatter_add_relative: dx/dy must be (ú, z
), got dx=z dy=r%   úc h w -> (h w) c©r'   r&   ú(h w) c -> c h w©r5   r6   r,   r-   )r
   r   r   r   Úlongr.   r/   r&   Úreshaper   r*   r'   Ú
index_add_)r   r3   r4   Úin_cr   r   ÚxÚyÚvalidÚindicesÚ
flat_imager   s   &&&         r    Ú_torch_scatter_add_relativerL   Z   s„  € ð ‡z�z�Q„ÜØMÌeÐTY×T_ÑT_ÓN`ÐMaÐbó
ð 	
ð —{‘{Ñ€D�Ø	‡x�x�D�<Ô 2§8¡8°¨|Ô#;ÜØ:¸4¸&ÀÀ4À&ð IÜ˜BŸH™H“oÐ& d¬5°·±«?Ð*;ð=ó
ð 	
ð
 	�‰‹	”E—L’L ¯i©i¼u¿z¹zÔJÕJ€AØ
�‰‹	”E—L’L ¯i©i¼u¿z¹zÔJÈ7ÕSÕS€Aà�1‰f˜™Õ" a¨1¡fÕ-°±Õ:×CÑCÀBÓG€EØ�x˜!�|×$Ñ$ RÓ(¨Õ/€Gä˜5Ð"4Ó5°eÕ<€JÜ
�+Š+�t•{ DÐ)°·±ÀUÇ\Á\Ô
R€CØ‡N�N�1�gÔ*Ü�SÐ,°Ô=Ð=r"   c                ó˜   € V P                   w  rp\        V R4      p\        P                  ! V^ RRRR7      w  rVp\        VRW#R7      pWWV3# )z¼Find unique pixel values in a CHW tensor.

Returns ``(unique_colors [U, C], counts [U], index_matrix [H, W])`` where
``index_matrix[i, j]`` is the index of the unique color at that pixel.
r?   TF)r)   Úreturn_inverseÚreturn_countsÚsortedz(h w) -> h wrB   )r   r   r.   Úunique)	r   r   r5   r6   ÚflatÚunique_colorsÚinverse_indicesÚcountsÚindex_matrixs	   &        r    Úunique_pixelsrW   {   sW   € ð �k‰k�G€Aˆ!Ü�UÐ.Ó/€DÜ-2¯\ª\Ø�! D¸ÀUô.Ñ*€M Fô ˜_¨nÀÔG€LØ ,Ð.Ð.r"   c                óZ  € V P                   w  r#p\        VP                  4       P                  4       4      ^,           p\	        V R4      p\
        P                  ! WVP                   ^,          3VP                  VP                  R7      pVP                  ^ VP                  R4      V4       V# )z>For each unique index, sum the CHW image values at its pixels.r?   r@   r-   )r   r   r   Úitemr   r.   r*   r'   r&   rE   Úview)r   rV   r   r5   r6   ÚurR   r   s   &&      r    Úsum_indexed_valuesr\   Š   s‚   € à�k‰k�G€Aˆ!ÜˆL×ÑÓ×#Ñ#Ó%Ó&¨Õ*€AÜ�UÐ.Ó/€DÜ
�+Š+�qŸ*™* Q�-Ð(°·
±
À4Ç;Á;Ô
O€CØ‡N�N�1�l×'Ñ'¨Ó+¨TÔ2Ø€Jr"   c                óh   € V P                   w  r#WP                  R4      ,          p\        VRW#R7      # )z@Build a CHW image from an index matrix and a (U, C) color table.rA   rB   r-   )r   rZ   r   )rV   rS   r5   r6   rR   s   &&   r    Úindexed_to_imager^   ”   s2   € à×Ñ�D€AØ×*Ñ*¨2Ó.Õ/€DÜ�TÐ-°Ô8Ð8r"   c                ó2  € V P                   w  rp\        V R,          4      w  rp\        P                  ! V 4      p\	        We4      p\        WW\        VR4      ,          4      pWh,
          p	\        V\        VR4      4      p
W
R,          ,          V	,           pWº3# )a7  Variance-preserving re-sampling of a CHW noise tensor.

Wherever the noise contains groups of identical pixel values (e.g. after
a nearest-neighbor warp that duplicated source pixels), adds zero-mean
foreign noise within each group and scales by ``1/sqrt(count)`` so the
output is unit-variance gaussian again.
ºNé   Nzu -> u 1ç      à?)r   rW   r.   Ú
randn_liker\   r^   r   )Únoiser   ÚhsÚwsrU   rV   Úforeign_noiseÚsummedÚmeanedÚzeroed_foreignÚcounts_imageÚoutputs   &           r    Úregaussianizerm   ›   sŠ   € ð —‘�I€Aˆ2Ü+¨E°"­IÓ6Ñ€Aˆ|ä×$Ò$ UÓ+€MÜ Ó<€FÜ˜l´Y¸vÀzÓ5RÕ,RÓS€FØ"Õ+€Nä# L´)¸FÀJÓ2OÓP€Là SÕ(Õ(¨>Õ9€FØÐÐr"   c           	     ó,  € V P                   w  rp\        P                  ! \        P                  ! W P                  V P
                  R7      \        P                  ! W0P                  V P
                  R7      RR7      w  rE\        P                  ! WT.4      # )zIReturn a (2, H, W) tensor of (x, y) pixel coordinates matching ``image``.r%   Úij)Úindexing)r   r.   Úmeshgridr/   r&   r'   r0   )r   r   r5   r6   rH   rG   s   &     r    Úxy_meshgrid_like_imagerr   ±   sa   € à�k‰k�G€Aˆ!Ü�>Š>Ü�Š�QŸ|™|°5·;±;Ô?Ü�Š�QŸ|™|°5·;±;Ô?Øô�D€Aô
 �;Š;˜�vÓÐr"   c                ó¦   € \         P                  ! V R,          4      p\         P                  ! V R,          4      p\         P                  ! WW .4      # )uT   Pack a (C, H, W) noise tensor into a state tensor (3+C, H, W) = [dx, dy, Ï‰, noise].r`   )r.   Ú
zeros_likeÚ	ones_likeÚcat)rd   r*   Úoness   &  r    Únoise_to_staterx   ¼   s<   € ä×Ò˜U 2�YÓ'€EÜ�?Š?˜5 �9Ó%€DÜ�9Š9�e DÐ0Ó1Ð1r"   c                ó   € V R,          # )z.Unpack the noise channels from a state tensor.:é   NN© )Ústates   &r    Ústate_to_noiser}   Ã   s   € à��9Ðr"   c           
     ó	  a€ VP                   V P                   8w  d&   \        RVP                    RV P                    24      hV P                  ^8w  d"   \        R\        V P                  4       24      hV P                  w  r#pVP                  ^W438w  d(   \        RV RV R\        VP                  4       24      hV P                   p^ ^rv^p^p	^p
W),
          pW(,
          pV^ 8:  d   \        RV R24      hW
,          ^ 8„  P                  4       '       g   \        R	4      h\        V 4      p\        P                  ! V 4      p^ VR
V% ^Wê&   ^ Wë) R
% \        P                  ! V 4      p\        V R
V V^ ,          ) V^,          ) R4      VR
V% \        W) R
 V^ ,          ) V^,          ) R4      Wü) R
% ^Wú,          Wú,          ^ 8H  &   V P                  4       pVR
V;;; V,          uuu% VVR
V ,           P                  4       pVV,          ^ 8¬  VV,          V8  ,          VV,          ^ 8¬  ,          VV,          V8  ,          p\        P                  ! VR
,          ( VV4      pVR
V P                  4       oVR
V;;; S,          uuu% ^ VR
V% V3R lpV! \        P                  ! ^W4V P                  VR7      4      ^ 8„  p\        P                  ! VWï4      p\        P                  ! VV.^R7      p\!        VV) R
 4      w  VV) R
% pVV
,          V^ ,          ,          VV
&   VV
,          P#                  4       VV
&   \        P$                  ! V^^R7      w  pp\        P                  ! V4      pV! VV
,          R
,          4      ^ ,          VV
&   V! VR
V VV
,          R
,          ,          4      VV
,          R
,          ,          VR
V% V! VV) R
 VV
,          R
,          ,          4      V! VV
,          R
,          ^,          4      P'                  4       ,          VV) R
% \        P                  ! VVV4      pVV
,          VV
,          P)                  4       ,          VV
&   VV
;;,          R,          uu&   VV
;;,          R,          uu&   V# )u³   Warp a noise-warper state tensor along the given optical flow.

``state`` has shape ``(3+c, h, w)`` (= dx, dy, Ï‰, c noise channels).
``flow`` has shape ``(2, h, w)`` (= dx, dy).
z@warp_state: flow and state must be on the same device, got flow=z state=z4warp_state: state must be 3D (3+C, H, W), got shape z%warp_state: flow must have shape (2, r>   z), got zDwarp_state: state has no noise channels (expected 3+C with C>0, got z
 channels)z/warp_state: all weights in state[2] must be > 0NÚnearestc                 ó:   <€ \        V S^ ,          S^,          4      # )é    )rL   )ÚtensorÚscat_xys   &€r    ÚscatÚwarp_state.<locals>.scat  s   ø€ Ü*¨6°7¸1µ:¸wÀq½zÓJÐJr"   r@   r(   )Úchunksr)   gñhãˆµøä>g§èH.ÿï?)r&   r   r
   r   r   Úallrr   r.   Ú
empty_liker<   r   ÚroundÚwhererw   r'   rv   rm   Ú
nan_to_numÚchunkÚsqrtÚmean)r|   ÚflowÚxyocr5   r6   r&   Úx_chÚy_chÚxyÚxywÚw_chÚcÚocr;   ÚinitÚ
pre_expandÚ
pre_shrinkÚposÚ	in_boundsr„   Úshrink_maskÚconcatrk   ÚexpandÚshrinkrl   rƒ   s   &&                        @r    Ú
warp_stater¡   È   sJ  ø€ ð ‡{�{�e—l‘lÔ"ÜðØŸ™�} G¨E¯L©L¨>ð;ó
ð 	
ð ‡z�z�Q„ÜØBÄ5ÈÏÉÓCUÐBVÐWó
ð 	
ð —‘�J€DˆQØ‡z�z�a˜�YÔÜØ3°A°3°b¸¸¸7Ä5ÈÏÉÓCTÐBUÐVó
ð 	
ð �\‰\€Fà�Aˆ$Ø	
€BØ
€CØ€DØ�
€AØ	�€BØˆA„vÜØRÐSWÐRXÐXbÐcó
ð 	
ð �K˜!‰O× Ñ ×"Ò"ÜÐJÓKÐKä! %Ó(€Dä×Ò˜EÓ"€DØ€Dˆˆ"€IØ€D�JØ€Dˆˆ€Iô ×!Ò! %Ó(€JÜ+¨E°#°2¨J¸¸a½¸À4ÈÅ7À(ÈIÓV€Jˆs�€OÜ,¨U°3°4¨[¸4À½7¸(ÀTÈ!ÅWÀHÈiÓX€JˆsˆtÐØ./€JÕ�ZÕ%¨Ñ*Ñ+ð —‘“€JØˆs�ƒO�tÕƒOà�*˜S˜b�/Õ!×
(Ñ
(Ó
*€CØ�T•˜a‘ C¨¥I°¡MÕ2°c¸$µiÀ1±nÕEÈÈTÍÐUVÉÕW€IÜ—’˜i¨�oÐ-¨t°ZÓ@€Jà˜˜"ˆo×#Ñ#Ó%€GØˆs�ƒO�wÕƒOØ€Jˆs�€OõKñ
 ”u—z’z ! Q°·±ÀVÔLÓMÐPQÑQ€Kô —’˜[¨$Ó;€Jô �YŠY˜
 JÐ/°QÔ7€FÜ -¨f°a°R°S¨kÓ :Ñ€FˆAˆ2ˆ3€K�Ø˜$•< ,¨q¥/Õ1€Fˆ4�LØ˜$•<×*Ñ*Ó,€Fˆ4�LÜŸš V°A¸1Ô=Ñ€J�ä×Ò˜jÓ)€FÙ˜
 4Õ(¨Õ.Ó/°Õ2€Fˆ4�LÙ�z # 2�¨°DÕ)9¸$Õ)?Õ?Ó@À6È$Å<ÐPTÕCUÕU€Fˆ3ˆB€KÙ�z 1 " #�¨°DÕ)9¸$Õ)?Õ?Ó@Á4Ø�4Õ˜Õ !Õ#óDç
�dƒfõ€FˆAˆ2ˆ3€Kô �[Š[˜ f¨fÓ5€FØ˜$•< &¨¥,×"3Ñ"3Ó"5Õ5€Fˆ4�LØ
ˆ4‡L�DÕƒLØ
ˆ4‡L�VÕƒLØ€Mr"   c                   óZ   a € ] tR tRt o Rt]P                  3R lt]R 4       t	R t
RtV tR# )ÚNoiseWarperi$  a  Maintain a warpable noise state and emit gaussian noise per frame.

Simplified from RyannDaGreat/CommonSource/noise_warp.py::NoiseWarper:
``scale_factor``, ``post_noise_alpha``, ``progressive_noise_alpha``, and
``warp_kwargs`` are all dropped since VOIDWarpedNoise always uses defaults.
c                óæ   € V^ 8:  g   V^ 8:  g   V^ 8:  d   \        RV RV RV 24      hWn        W n        W0n        W@n        WPn        \        P                  ! WW5VR7      p\        V4      V n	        R# )r�   z/NoiseWarper: c/h/w must all be positive, got c=z h=z w=r@   N)
r   r–   r5   r6   r&   r'   r.   Úrandnrx   Ú_state)Úselfr–   r5   r6   r&   r'   rd   s   &&&&&& r    Ú__init__ÚNoiseWarper.__init__,  sq   € Ø�Œ6�Q˜!”V˜q AœvÜØAÀ!ÀÀCÈÀsÈ#ÈaÈSÐQóð ð ŒØŒØŒØŒØŒ
ä—’˜A !¸Ô@ˆÜ$ UÓ+ˆŽr"   c                óš   € \        V P                  4      pV P                  R ,          pW,          V^,          P                  4       ,          # ):é   rz   N)r}   r¦   r�   )r§   ÚnÚweightss   &  r    rd   ÚNoiseWarper.noise:  s:   € ô
 ˜4Ÿ;™;Ó'ˆØ—+‘+˜cÕ"ˆØ�{˜g¨�l×0Ñ0Ó2Õ2Ð2r"   c                óJ  € VP                   VP                   8w  d8   \        R \        VP                   4       R\        VP                   4       24      h\        P                  ! W.4      P                  V P                  V P                  4      pVP                   w  rEp\        W0P                  V P                  3RRR7      pVP                   RR w  rxV^ ;;,          Wu,          ,          uu&   V^;;,          W†,          ,          uu&   \        V P                  V4      V n        V # )z'NoiseWarper: dx and dy must match, got r$   r   T©r   Néþÿÿÿ)r   r   r   r.   r0   r1   r&   r'   r!   r5   r6   r¡   r¦   )	r§   r3   r4   r�   r   ÚoflowhÚoflowwÚflowhÚflowws	   &&&      r    Ú__call__ÚNoiseWarper.__call__C  sÞ   € Ø�8‰8�r—x‘xÔÜØ9¼%ÀÇÁ»/Ð9JÈ$ÌuÐUW×U]ÑU]ËÐN_Ð`óð ô �{Š{˜B˜8Ó$×'Ñ'¨¯©°T·Z±ZÓ@ˆØ ŸJ™JÑˆ�6ä  ¯©°·±Ð'7¸È$ÔOˆØ—z‘z " #�‰ˆð
 	ˆQ��5•>Õ!‹ØˆQ��5•>Õ!‹ä  §¡¨dÓ3ˆŒØˆr"   )r¦   r–   r&   r'   r5   r6   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r.   Úfloat32r¨   Úpropertyrd   r¶   Ú__static_attributes__Ú__classdictcell__©Ú__classdict__s   @r    r£   r£   $  s6   ø‡ € ñð /4¯m©mô ,ð ñ3ó ð3÷ð r"   r£   c                   ó:   a € ] tR tRt o RtRR ltR tR tRtV t	R# )	ÚRaftOpticalFlowi\  aU  RAFT-large wrapper around a pre-loaded torchvision model.

``model`` must be the ``torchvision.models.optical_flow.raft_large`` module
with its weights already populated; this class is load-agnostic so the
caller owns downloading/offload concerns (see ``OpticalFlowLoader`` in
``nodes_void.py``).  ``__call__`` returns a ``(2, H, W)`` flow.
Nc                ó  € Vf   \         P                  P                  4       p\        V\        P
                  4      '       g   \        P
                  ! V4      MTpVP                  V4      pVP                  4        W n        Wn        R # ©N)	ÚcomfyÚmodel_managementÚget_torch_devicer   r.   r&   r1   ÚevalÚmodel)r§   rË   r&   s   &&&r    r¨   ÚRaftOpticalFlow.__init__e  s]   € ØŠ>Ü×+Ñ+×<Ñ<Ó>ˆFÜ-7¸ÄÇÁ×-MÒ-M”—’˜fÔ%ÐSYˆà—‘˜Ó ˆØ�
‰
ŒØŒØŽ
r"   c                ó  € VP                  V P                  \        P                  4      pVP                  w  r4pV^,          ^,          pV^,          ^,          p\        W&V3RRR7      pV^,          ^,
          pVR,          # )é   r   Fr°   N)r1   r&   r.   r½   r   r!   )r§   Ú	image_chwr   r   r5   r6   r   r   s   &&      r    Ú_preprocessÚRaftOpticalFlow._preprocesso  sj   € Ø—‘˜TŸ[™[¬%¯-©-Ó8ˆØ—+‘+‰ˆˆaØ�a•˜1•ˆØ�a•˜1•ˆÜ! %°¨¸È%ÔPˆØ˜•	˜A•ˆØ�T�{Ðr"   c           	     ó  € VP                   VP                   8w  d8   \        R\        VP                   4       R\        VP                   4       24      hVP                   w  r4p\        P                  ! 4       ;_uu_ 4        V P                  V4      pV P                  V4      pV P                  Wg4      pVR,          ^ ,          p	V	P                   RR WE38w  d   \        W”V3RRR7      p	RRR4       V	#   + '       g   i     X	# ; i)	z:``from_image``, ``to_image``: CHW float tensors in [0, 1].z9RaftOpticalFlow: from_image and to_image must match, got r$   Nr   Fr°   r-   r±   )r   r   r   r.   Úno_gradrÐ   rË   r!   )
r§   Ú
from_imageÚto_imager   r5   r6   Úimg1Úimg2Úlist_of_flowsr�   s
   &&&       r    r¶   ÚRaftOpticalFlow.__call__x  sç   € à×Ñ˜xŸ~™~Ô-ÜðÜ˜Z×-Ñ-Ó.Ð/¨t´E¸(¿.¹.Ó4IÐ3JðLóð ð ×"Ñ"‰ˆˆaÜ�]Š]�_�_Ø×#Ñ# JÓ/ˆDØ×#Ñ# HÓ-ˆDØ ŸJ™J tÓ2ˆMØ  Õ$ QÕ'ˆDØ�z‰z˜"˜#ˆ 1 &Ô(Ü(¨°1¨v°zÈÔN�÷ ð ˆ÷ Ž_ð ˆús   Á?A)C2Ã2D	)r&   rË   rÆ   )
r¸   r¹   rº   r»   r¼   r¨   rÐ   r¶   r¿   rÀ   rÁ   s   @r    rÄ   rÄ   \  s   ø‡ € ñôò÷ð r"   rÄ   Únoise_channelsÚresize_framesrb   Úresize_flowÚdownscale_factorr&   c                óÊ   € V ^8„  d   QhR\         P                  R\        R\        R\        R\        R\        R\
        \         P                  ,          R\         P                  /# )	r«   Úvideo_framesÚraftrÚ   rÛ   rÜ   rÝ   r&   Úreturn)r.   ÚTensorrÄ   r   r   r   r&   )Úformats   "r    Ú__annotate__rä   Ž  ss   € ÷ `ñ `Ü—,‘,ð`ä
ð`ô ð	`ô
 ð`ô ð`ô ð`ô ”U—\‘\Õ"ð`ô ‡\�\ñ`r"   c          	     ó:  a€ \        V\        4      '       d   V^8  d   \        RV: 24      hV P                  ^8w  g   V P                  R,          ^8w  d"   \        R\        V P                  4       24      hV P                  \        P                  8w  d   \        RV P                   24      hVf   \        P                  P                  4       p\        V\        P                  4      '       g   \        P                  ! V4      MTpVP                  R8X  d   \        P                   ! R4       V P                  ^ ,          pV P#                  V4      P%                  ^ ^^^4      P#                  \        P&                  4      R,          pVR8w  du   \)        ^\        VP                  ^,          V,          4      4      p	\)        ^\        VP                  ^,          V,          4      4      p
\*        P,                  ! W‰V
3R	R
7      pVP                  w   r¼pWL,          pWM,          pVS,          '       g   VS,          '       d   \        P                   ! RWïS4       \        P.                  ! 4       ;_uu_ 4        \1        W.WöR7      pVP2                  S,          pVP4                  S,          p\        P6                  ! VVVV3\        P&                  VR7      pV3R lpV! VP8                  4      P%                  ^^^ 4      V^ &   V^ ,          p\;        ^V4       Fc  pVV,          pV! VV4      P#                  V4      pV! V^ ,          V^,          4       V! VP8                  4      P%                  ^^^ 4      VV&   TpKe  	  RRR4       V#   + '       g   i     X# ; i)a  Produce optical-flow-warped gaussian noise from a video.

Args:
    video_frames: ``(T, H, W, 3)`` uint8 torch tensor.
    raft: Pre-loaded RAFT optical-flow wrapper (see ``RaftOpticalFlow``).
    noise_channels: Channels in the output noise.
    resize_frames: Pre-RAFT frame scale factor.
    resize_flow: Post-flow up-scale factor applied to the optical flow;
        the internal noise state is allocated at
        ``(resize_flow * resize_frames * H, resize_flow * resize_frames * W)``.
    downscale_factor: Area-pool factor applied to the noise before return;
        should evenly divide the internal noise resolution.
    device: Target device.  Defaults to ``comfy.model_management.get_torch_device()``.

Returns:
    ``(T, H', W', noise_channels)`` float32 noise tensor on ``device``.
z>get_noise_from_video: resize_flow must be a positive int, got zEget_noise_from_video: video_frames must have shape (T, H, W, 3), got zHget_noise_from_video: video_frames must be uint8 in [0, 255], got dtype NÚcpuz€VOIDWarpedNoise: running get_noise_from_video on CPU; this will be slow (minutes for ~45 frames).  Use CUDA for interactive use.g     ào@ç      ð?Úarea)r   r   ztVOIDWarpedNoise: internal noise size %dx%d is not divisible by downscale_factor %d; output noise may have artifacts.)r–   r5   r6   r&   r@   c                 óB   <€ \        V R S,          RRR7      pVS,          # )rç   rè   Fr°   )r!   )Ú	noise_chwÚdownrÝ   s   & €r    Ú	downscaleÚ'get_noise_from_video.<locals>.downscaleÝ  s(   ø€ ô % Y°Ð6FÕ0FÈÐUZÔ[ˆDØÐ*Õ*Ð*r"   r-   )r   r   r   r
   r   r   r'   r.   Úuint8Ú	TypeErrorrÇ   rÈ   rÉ   r&   ÚtypeÚloggingÚwarningr1   Úpermuter½   r   r   r   rÓ   r£   r5   r6   Úemptyrd   Úrange)rß   rà   rÚ   rÛ   rÜ   rÝ   r&   ÚTÚframesr   r   r   ÚHÚWÚ
internal_hÚ
internal_wÚwarperÚdown_hÚdown_wrl   rì   ÚprevÚiÚcurrr�   s   &&$$$d$                  r    Úget_noise_from_videor  Ž  s  ø€ ô6 �k¤3×'Ò'¨;¸¬?ÜØLÈ[ÉOÐ\ó
ð 	
ð ×Ñ˜AÔ ×!3Ñ!3°BÕ!7¸1Ô!<ÜðÜ˜×+Ñ+Ó,Ð-ð/ó
ð 	
ð ×ÑœUŸ[™[Ô(ÜðØ%×+Ñ+Ð,ð.ó
ð 	
ð
 ‚~Ü×'Ñ'×8Ñ8Ó:ˆÜ)3°F¼E¿L¹L×)IÒ)IŒU�\Š\˜&Ô!Èv€Fà‡{�{�eÔÜ�ŠðLô	
ð
 	×Ñ˜1Õ€AØ�_‰_˜VÓ$×,Ñ,¨Q°°1°aÓ8×;Ñ;¼E¿M¹MÓJÈUÕR€FØ˜ÔÜ�A”s˜6Ÿ<™<¨�?¨]Õ:Ó;Ó<ˆÜ�A”s˜6Ÿ<™<¨�?¨]Õ:Ó;Ó<ˆÜ—’˜v°E¨NÀÔHˆà—‘�J€A€qˆQØ•€JØ•€JØÐ$×$Ô$¨
Ð5E×(EÔ(EÜ�ŠðDàÐ$4ô	
ô 
�Š��ÜØ¨jô
ˆð —‘Ð-Õ-ˆØ—‘Ð-Õ-ˆÜ—’Ø�˜ Ð/´u·}±}ÈVô
ˆõ	+ñ ˜fŸl™lÓ+×3Ñ3°A°q¸!Ó<ˆˆq‰	à�a�yˆÜ�q˜!–ˆAØ˜!•9ˆDÙ˜˜dÓ#×&Ñ& vÓ.ˆDÙ�4˜•7˜D �GÔ$Ù! &§,¡,Ó/×7Ñ7¸¸1¸aÓ@ˆF�1‰IØŠDñ ÷) 
ð6 €M÷7 
Žð6 €Mús   É8DN	Î	N	)T)r   )r¼   rñ   Útypingr   r.   Útorch.nn.functionalÚnnÚ
functionalr   Úeinopsr   Úcomfy.model_managementrÇ   r!   r<   rL   rW   r\   r^   rm   rr   rx   r}   r¡   r£   rÄ   r  r{   r"   r    Ú<module>r	     s´   ðñó" Ý ã ß Ð Ý ã ôô:ò:>òB/òò9ò ò,ò2òò
Y÷x1ñ 1÷p+ñ +ðd`ð ð	`ð
 ð`ð ð`ð ð`ð &*÷`ñ `r"   