
    voi(                     x    S SK rS SKrS SKJr  S SKJr  SSKJ	r	J
r
  SS jr    SSS.S jjrS	 rS
 rS rS rg)    N)linalg)SCIPY_GE_1_17_0_DEV0   )_ncut_ncut_cyc                    U(       d  UR                  5       nUR                  SS9 VVVs/ s H  u  pEofS   U:  d  M  XE4PM     nnnnUR                  U5        [        R                  " U5      n[
        R                  " U R                  5       S-   U R                  S9n	[        U5       H+  u  pU H   nUR                  U   S    H  nXU'   M	     M"     M-     X   $ s  snnnf )a-  Combine regions separated by weight less than threshold.

Given an image's labels and its RAG, output new labels by
combining regions whose nodes are separated by a weight less
than the given threshold.

Parameters
----------
labels : ndarray
    The array of labels.
rag : RAG
    The region adjacency graph.
thresh : float
    The threshold. Regions connected by edges with smaller weights are
    combined.
in_place : bool
    If set, modifies `rag` in place. The function will remove the edges
    with weights less that `thresh`. If set to `False` the function
    makes a copy of `rag` before proceeding.

Returns
-------
out : ndarray
    The new labelled array.

Examples
--------
>>> from skimage import data, segmentation, graph
>>> img = data.astronaut()
>>> labels = segmentation.slic(img)
>>> rag = graph.rag_mean_color(img, labels)
>>> new_labels = graph.cut_threshold(labels, rag, 10)

References
----------
.. [1] Alain Tremeau and Philippe Colantoni
       "Regions Adjacency Graph Applied To Color Image Segmentation"
       :DOI:`10.1109/83.841950`

Tdataweightr   dtypelabels)copyedgesremove_edges_fromnxconnected_componentsnparangemaxr   	enumeratenodes)r   ragthreshin_placexyd	to_removecomps	map_arrayir   nodelabels                 T/var/www/html/land-ocr/venv/lib/python3.13/site-packages/skimage/graph/_graph_cut.pycut_thresholdr&   	   s    R hhj (+yydy';U';GA!{f?T!';IU)$##C(E
 		&**,*&,,?Ie$D42#$%  3  %
  Vs
   CC)rngc                   [         R                  R                  U5      nU(       d  UR                  5       nUR	                  5        H  nUR                  XwUS9  M     [        XX65        [         R                  " U R                  5       S-   U R                  S9nUR	                  SS9 H  u  pU
S   XS   '   M     X   $ )a  Perform Normalized Graph cut on the Region Adjacency Graph.

Given an image's labels and its similarity RAG, recursively perform
a 2-way normalized cut on it. All nodes belonging to a subgraph
that cannot be cut further are assigned a unique label in the
output.

Parameters
----------
labels : ndarray
    The array of labels.
rag : RAG
    The region adjacency graph.
thresh : float
    The threshold. A subgraph won't be further subdivided if the
    value of the N-cut exceeds `thresh`.
num_cuts : int
    The number or N-cuts to perform before determining the optimal one.
in_place : bool
    If set, modifies `rag` in place. For each node `n` the function will
    set a new attribute ``rag.nodes[n]['ncut label']``.
max_edge : float, optional
    The maximum possible value of an edge in the RAG. This corresponds to
    an edge between identical regions. This is used to put self
    edges in the RAG.
rng : {`numpy.random.Generator`, int}, optional
    Pseudo-random number generator.
    By default, a PCG64 generator is used (see :func:`numpy.random.default_rng`).
    If `rng` is an int, it is used to seed the generator.

    The `rng` is used to determine the starting point
    of `scipy.sparse.linalg.eigsh`.

Returns
-------
out : ndarray
    The new labeled array.

Examples
--------
>>> from skimage import data, segmentation, graph
>>> img = data.astronaut()
>>> labels = segmentation.slic(img)
>>> rag = graph.rag_mean_color(img, labels, mode='similarity')
>>> new_labels = graph.cut_normalized(labels, rag)

References
----------
.. [1] Shi, J.; Malik, J., "Normalized cuts and image segmentation",
       Pattern Analysis and Machine Intelligence,
       IEEE Transactions on, vol. 22, no. 8, pp. 888-905, August 2000.

)r   r   r   Tr	   
ncut labelr   )
r   randomdefault_rngr   r   add_edge_ncut_relabelzerosr   r   )r   r   r   num_cutsr   max_edger'   r#   r!   nr   s              r%   cut_normalizedr2   G   s    ~ ))


$Chhj		T1  #x-)>I		t	$!"<	H+ %     c                 D   [        UR                  5       5       VVs/ s H  u  p#X   (       d  M  UPM     nnn[        UR                  5       5       VVs/ s H  u  p#X   (       a  M  UPM     nnnUR                  U5      nUR                  U5      nXg4$ s  snnf s  snnf )a"  Compute resulting subgraphs from given bi-partition.

Parameters
----------
cut : array
    A array of booleans. Elements set to `True` belong to one
    set.
rag : RAG
    The Region Adjacency Graph.

Returns
-------
sub1, sub2 : RAG
    The two resulting subgraphs from the bi-partition.
)r   r   subgraph)cutr   r"   r1   nodes1nodes2sub1sub2s           r%   partition_by_cutr;      s~    4 &ciik2=2DAcfa2F=%ciik2A2DA#&a2FA<<D<<D: >As   BBB(Bc                 \   [         R                  nU R                  5       nU R                  5       n[         R                  " U [
        S9n[         R                  " XV5      (       a  Xt4$ [         R                  " XVUSS9 H)  nX:  n	[        R                  " XU5      n
X:  d  M%  U	nU
nM+     Xt4$ )a  Threshold an eigenvector evenly, to determine minimum ncut.

Parameters
----------
ev : array
    The eigenvector to threshold.
d : ndarray
    The diagonal matrix of the graph.
w : ndarray
    The weight matrix of the graph.
num_cuts : int
    The number of evenly spaced thresholds to check for.

Returns
-------
mask : array
    The array of booleans which denotes the bi-partition.
mcut : float
    The value of the minimum ncut.
r   F)endpoint)
r   infminr   
zeros_likeboolallcloselinspacer   	ncut_cost)evr   wr/   mcutmnmxmin_masktmaskcosts              r%   get_min_ncutrN      s    * 66D	B	B
 }}Rt,H	{{2~ [[E:vt*;HD ; >r3   c                     [        U R                  5       5      nU R                  U   S   S   nU R                  SS9 H	  u  pEX5U'   M     g)aQ  Assign a unique integer to the given attribute in the RAG.

This function assumes that all labels in `rag` are unique. It
picks up a random label from them and assigns it to the `attr_name`
attribute of all the nodes.

rag : RAG
    The Region Adjacency Graph.
attr_name : string
    The attribute to which a unique integer is assigned.
r   r   Tr	   N)r?   r   )r   	attr_namer#   	new_labelr1   r   s         r%   
_label_allrR      sI     syy{D		$)!,I		t	$ ) %r3   c           
      *   [         R                  " U 5      u  pEUR                  S   nUS:  GaY  XE:g  R                  S:  GaF  UR	                  5       n[
        R                  " [
        R                  " UR                  UR                  S9UR                  S9Ul        XtU-
  -  U-  nUR                  UR                  S   5      n	[        (       a  SU0O0 n
[        R                  " U4SU	[        SUS-
  5      S.U
D6u  p[
        R                  " U5      [
        R                  " U5      p[        R                   " U5      nUSS2U4   n[#        XXR5      u  nnUU:  a)  [%        X5      u  nn['        UXU5        ['        UXU5        g[)        U S	5        g)
a  Perform Normalized Graph cut on the Region Adjacency Graph.

Recursively partition the graph into 2, until further subdivision
yields a cut greater than `thresh` or such a cut cannot be computed.
For such a subgraph, indices to labels of all its nodes map to a single
unique value.

Parameters
----------
rag : RAG
    The region adjacency graph.
thresh : float
    The threshold. A subgraph won't be further subdivided if the
    value of the N-cut exceeds `thresh`.
num_cuts : int
    The number or N-cuts to perform before determining the optimal one.
random_generator : `numpy.random.Generator`
    Provides initial values for eigenvalue solver.
r      )outr'   SMd   )whichv0kNr)   )r   DW_matricesshapennzr   r   
reciprocalsqrtr
   r*   r   r   eigshr?   realr   argmin2rN   r;   r-   rR   )r   r   r/   random_generatorr   rF   md2ArY   rng_kwvalsvectorsindex2rE   cut_maskrG   r9   r:   s                      r%   r-   r-      s_   ( S!DA	
A	AAF<<!# VVX --RWW =277K a%L2$$QWWQZ0 /C.B%)*QWdrSa!e_WPVW rwww'7g!!$'QY%bQ9$&= *(8JD$$2BC$2BC sL!r3   )T)gMbP?
   Tg      ?)networkxr   numpyr   scipy.sparser   skimage._shared.compatr    r   r   r&   r2   r;   rN   rR   r-    r3   r%   <module>rs      sQ       7 ;B M 	M` F)X!$G"r3   