
    |h'                     f    d dl Zd dl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   )_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                 W/var/www/html/test/engine/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_normalizedr1   F   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!   r0   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_ncutrM      s    * 66D	B	B
 }}Rt,H	{{2r~ [[RE: AvtQ*$;HD T>r2   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_labelr0   r   s         r$   
_label_allrQ      sR     syy{D		$)!,I		t	$ !1 )!r2   c           
         t        j                  |       \  }}|j                  d   }|dkD  rN||k7  j                  dkD  r;|j	                         }t        j                  t        j                  |j                  |j                        |j                        |_        |||z
  z  |z  }|j                  |j                  d         }	t        j                  |d|	t        d|dz
              \  }
}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      )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,      sU   ( S!DAq	
A	AAF<<!# VVX --RWW =277K !a%L2$$QWWQZ0QdrSa!e_Mg rwww'7g!!$'QY%b!Q9$&= *(C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   