
    79j(                     r    d dl Zd dlZd dlmZ d dlmZ ddlm	Z	m
Z
 ddZ	 	 	 	 ddddZd	 Zd
 Zd Zd Zy)    N)linalg)SCIPY_GE_1_17_0_DEV0   )_ncut_ncut_cyc                    |s|j                         }|j                  d      D cg c]  \  }}}|d   |k\  s||f }}}}|j                  |       t        j                  |      }t        j                  | j                         dz   | j                        }	t        |      D ](  \  }
}|D ]  }|j                  |   d   D ]  }|
|	|<   	   * |	|    S c c}}}w )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/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/skimage/graph/_graph_cut.pycut_thresholdr&   	   s    R hhj (+yydy';UUGAq!q{f?T!QUIU)$##C(E
 		&**,*&,,?Ie$ %5 	%D42 %#$	% %	%%
 V Vs
   CC)rngc                   t         j                  j                  |      }|s|j                         }|j	                         D ]  }|j                  |||        t        ||||       t        j                  | j                         dz   | j                        }|j	                  d      D ]  \  }	}
|
d   ||
d   <    ||    S )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		 2T412 #vx-)>I		t	$ 11!"<	!H+1 V    c                 *   t        |j                               D cg c]  \  }}| |   s| }}}t        |j                               D cg c]  \  }}| |   r| }}}|j                  |      }|j                  |      }||fS c c}}w c c}}w )aR  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=DAqc!fa=F=%ciik2ADAq#a&aAFA<<D<<D: >As   B	B	BBc                 \   t         j                  }| j                         }| j                         }t        j                  | t
              }t        j                  ||      r||fS t        j                  |||d      D ](  }| |kD  }	t        j                  |	||      }
|
|k  s%|	}|
}* ||fS )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	{{2r~ [[RE: AvtQ*$;HD T>r3   c                     t        | j                               }| j                  |   d   d   }| j                  d      D ]
  \  }}|||<    y)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      sR     syy{D		$)!,I		t	$ !1 )!r3   c           
      ,   t        j                  |       \  }}|j                  d   }|dkD  r[||k7  j                  dkD  rH|j	                         }t        j                  t        j                  |j                  |j                        |j                        |_        |||z
  z  |z  }|j                  |j                  d         }	t        rd|ini }
t        j                  |fd|	t        d|dz
        d|
\  }}t        j                  |      t        j                  |      }}t        j                   |      }|dd|f   }t#        ||||      \  }}||k  r,t%        ||       \  }}t'        ||||       t'        ||||       yt)        | d	       y)
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-      sp   ( S!DAq	
A	AAF<<!# VVX --RWW =277K !a%L2$$QWWQZ0 /C%)*QWdrSa!e_WPVWg rwww'7g!!$'QY%b!Q9$&= *(C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   