
    9i'                     l    S SK rS SK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   )_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                 X/var/www/html/land-doc-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_normalizedr1   F   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!   r0   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_ncutrM      s    * 66D	B	B
 }}Rt,H	{{2~ [[E:vt*;HD ; >r2   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_labelr0   r   s         r$   
_label_allrQ      sI     syy{D		$)!,I		t	$ ) %r2   c           
         [         R                  " U 5      u  pEUR                  S   nUS:  GaB  XE:g  R                  S:  Ga/  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	[        R                  " USU	[        SUS-
  5      S9u  p[
        R                  " U
5      [
        R                  " U5      p[        R                  " U
5      nUSS2U4   n[!        XXR5      u  pX:  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      )outSMd   )whichv0kNr(   )r   DW_matricesshapennzr   r   
reciprocalsqrtr	   r)   r   eigshr>   realr   argmin2rM   r:   r,   rQ   )r   r   r.   random_generatorr   rE   md2ArX   valsvectorsindex2rD   cut_maskrF   r8   r9   s                     r$   r,   r,      s=   ( S!DA	
A	AAF<<!# VVX --RWW =277K a%L2$$QWWQZ0QdrSa!e_M rwww'7g!!$'QY%bQ9= *(8JD$$2BC$2BC sL!r2   )T)gMbP?
   Tg      ?)networkxr   numpyr   scipy.sparser    r   r   r%   r1   r:   rM   rQ   r,    r2   r$   <module>rp      sN       ;B M 	M` F)X!$C"r2   