o 0j~7@sddlmZmZmZmZmZddlZddlm Z m Z ddl m Z e dr(ddl Z e je dGdd d Ze jGd d d Ze jGd d d Ze je dGdddZe jGdddZe jGdddZdS))ListOptionalSequenceTupleUnionN)class_requires_depsis_dep_available) benchmarkzopencv-contrib-pythonc seZdZdZ   ddededeedfded df fd d Zd ee j d ee j fd dZ dee j d ee j fddZ Z S)Scalez Scale images.TNF short_size fixed_ratio keep_ratiodo_roundreturncs:t||_|r |r|rJd||_||_||_dS)a Initializes the Scale class. Args: short_size (int): The target size for the shorter side of the image. fixed_ratio (bool): Whether to maintain a fixed aspect ratio of 4:3. keep_ratio (Union[bool, None]): Whether to keep the aspect ratio. Cannot be True if fixed_ratio is True. do_round (bool): Whether to round the scaling factor. z:fixed_ratio and keep_ratio cannot be true at the same timeN)super__init__r rrr)selfr rrr __class__y/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddlex/inference/models/video_classification/processors.pyr s  zScale.__init__videoc Cs|}g}tt|D]}||}t|tjr|j\}}}nt||kr(||jks1||kr7||jkr7||q ||kr|j} |j rKt |jdd} ny|j durT|j} np|j|} |j rft |t | dnt ||j|} |j r|t |t | dn|j} nD|j} |j rt |jdd} n4|j dur|j} n+|j|} |j rt |t | dn|j} |j rt |t | dnt ||j|} |tj|| | ftjdq |}|S)aZ Performs resize operations on a sequence of images. Args: video (List[np.ndarray]): List where each item is an image, as a numpy array. For example, [np.ndarray0, np.ndarray1, np.ndarray2, ...] Returns: List[np.ndarray]: List where each item is a np.ndarray after scaling. g@g@Fg?) interpolation)rangelen isinstancenpndarrayshapeNotImplementedErrorr appendrintrrfloatcv2resizeZ INTER_LINEAR) rrimgsZ resized_imgsiimghw_owZohZ scale_factorrrrscale9sX  $     z Scale.scalevideoscfdd|DS)a6 Apply the scaling operation to a list of videos. Args: videos (List[np.ndarray]): A list of videos, where each video is a sequence of images. Returns: List[np.ndarray]: A list of videos after scaling, where each video is a list of images. cg|]}|qSr)r..0rrrr z"Scale.__call__..rrr/rr4r__call__|s zScale.__call__)TNF)__name__ __module__ __qualname____doc__r#boolrrrrrr.r8 __classcell__rrrrr s$ &Cr csleZdZdZddededdffdd Zd eej deej fd d Z d eej deej fd dZ Z S) CenterCropzCenter crop images.T target_sizerrNcst||_||_dS)z Initializes the CenterCrop class. Args: target_size (int): The size of the cropped area. do_round (bool): Whether to round the crop coordinates. N)rrr@r)rr@rrrrrs  zCenterCrop.__init__r'c Csg}|j|j}}|D]S}|j\}}}||jkr||jks'Jd|||j|jr4tt||dn||d} |jrGtt||dn||d} ||| | || | |fq |S)a Performs center crop operations on images. Args: imgs (List[np.ndarray]): A sequence of images (a numpy array). Returns: List[np.ndarray]: A list of images after center cropping or a cropped numpy array. z>image width({}) and height({}) should be larger than crop sizeg@)r@r formatrr#roundr") rr'Z crop_imgsthZtwr)r*r+r,x1y1rrr center_crops    &&$zCenterCrop.center_cropr/cr0)a Apply the center crop operation to a list of videos. Args: videos (List[np.ndarray]): A list of videos, where each video is a sequence of images. Returns: List[np.ndarray]: A list of videos after center cropping. cr1r)rGr2r4rrr5r6z'CenterCrop.__call__..rr7rr4rr8 zCenterCrop.__call__)T) r9r:r;r<r#r=rrrrrGr8r>rrrrr?s  &r?csheZdZdZddededdffdd Zd eej dej fd d Z d eej deej fddZ Z S) Image2ArrayzJConvert a sequence of images to a numpy array with optional transposition.Ttchw transpose data_formatrNcs0t|dvsJd|||_||_dS)aC Initializes the Image2Array class. Args: transpose (bool): Whether to transpose the resulting numpy array. data_format (str): The format to transpose to, either 'tchw' or 'cthw'. Raises: AssertionError: If data_format is not one of the allowed values. )rJZcthwz0Target format must in ['tchw', 'cthw'], but got N)rrrKrL)rrKrLrrrrs  zImage2Array.__init__r'cCsDt|d}|jr |jdkr|gd}|S|gd}|S)a Converts a sequence of images to a numpy array and optionally transposes it. Args: imgs (List[np.ndarray]): A list of images to be converted to a numpy array. Returns: np.ndarray: A numpy array representation of the images. float32rJ)rr rA)r rrNrA)rstackastyperKrL)rr'Zt_imgsrrr img2arrays  zImage2Array.img2arrayr/cr0)a" Apply the image to array conversion to a list of videos. Args: videos (List[Sequence[np.ndarray]]): A list of videos, where each video is a sequence of images. Returns: List[np.ndarray]: A list of numpy arrays, one for each video. cr1r)rQr2r4rrr5r6z(Image2Array.__call__..rr7rr4rr8rHzImage2Array.__call__)TrJ) r9r:r;r<r=strrrrrrQr8r>rrrrrIs &rIc seZdZdZgddfdeedeedeededd f fd d Zd e j de j fd dZ de e j de e j fddZ ZS)NormalizeVideoz` Normalize video frames by subtracting the mean and dividing by the standard deviation. )r rNrNFmeanstd tensor_shapeinplacerNcstt||_|s&t||tj|_t||tj|_ dStj|tjd|_tj|tjd|_ dS)aw Initializes the NormalizeVideo class. Args: mean (Sequence[float]): The mean values for each channel. std (Sequence[float]): The standard deviation values for each channel. tensor_shape (Sequence[int]): The shape of the mean and std tensors. inplace (bool): Whether to perform normalization in place. dtypeN) rrrWrarrayreshaperPrMrTrU)rrTrUrVrWrrrrs zNormalizeVideo.__init__r'c Cs|jrRt|}|dj\}}}tj||||ftjd}t|D]\}}|||<q|D]&}t|j dd} dt|j dd} t || |t || |q*n|}|d}||j8}||j }|}tj|dd}|S)z Normalizes a sequence of images. Args: imgs (np.ndarray): A numpy array of images to be normalized. Returns: np.ndarray: The normalized images as a numpy array. rrXrNgo@axis)rWrr remptyrM enumerateZfloat64rTr[rUr%subtractmultiplyZ expand_dimscopy) rr'nr*r+cZ norm_imgsr(r)rTZstdinvrrrnormalize_videos&    zNormalizeVideo.normalize_videor/cr0)a  Apply normalization to a list of videos. Args: videos (List[np.ndarray]): A list of videos, where each video is a numpy array of images. Returns: List[np.ndarray]: A list of normalized videos as numpy arrays. cr1r)rfr2r4rrr5Br6z+NormalizeVideo.__call__..rr7rr4rr88rHzNormalizeVideo.__call__)r9r:r;r<rr$r#r=rrrrfrr8r>rrrrrSs"&!rSc seZdZdZddeeeeefddffdd Z de j de j fdd Z deeeeefdee fd d Z dd e j dedee j ee j eeeffddZZS) VideoClasTopkzCApplies a top-k transformation on video classification predictions.N class_idsrcst|||_dS)z Initializes the VideoClasTopk class. Args: class_ids (Optional[Sequence[Union[str, int]]]): A list of class labels corresponding to class indices. N)rr_parse_class_id_map class_id_map)rrhrrrrIs zVideoClasTopk.__init__datacCs2tj|ddd}t||}|tj|dddS)z Applies the softmax function to an array of data. Args: data (np.ndarray): An array of data for which to compute softmax. Returns: np.ndarray: The softmax-transformed data. r\T)r^Zkeepdims)rmaxexpsum)rrkZx_maxZe_xrrrsoftmaxSs zVideoClasTopk.softmaxcCs"|durdSddt|D}|S)aB Parses a list of class IDs into a mapping from class index to class label. Args: class_ids (Optional[Sequence[Union[str, int]]]): A list of class labels. Returns: Optional[dict]: A dictionary mapping class indices to labels, or None if no class_ids are provided. NcSsi|] \}}|t|qSr)rR)r3idZlbrrr osz5VideoClasTopk._parse_class_id_map..)r`)rrhrjrrrrias z!VideoClasTopk._parse_class_id_mappredstopkcs|d|d<|djdddd| dfdddddfd}ddt|d|D}fd d|D}|||fS) a Selects the top-k predictions from the classification output. Args: preds (np.ndarray): A 2D array of prediction scores. topk (int): The number of top predictions to return. Returns: Tuple[np.ndarray, List[np.ndarray], List[List[str]]]: A tuple containing: - An array of indices of the top-k predictions. - A list of arrays of scores for the top-k predictions. - A list of lists of label names for the top-k predictions. rrNr]Nr\Zint32cSs&g|]\}}ttj||ddqS)rr)Zdecimals)listraround)r3predindexrrrr5sz*VideoClasTopk.__call__..csg|] }fdd|DqS)csg|]}j|qSr)rj)r3r(r4rrr5r6z5VideoClasTopk.__call__...r)r3rxr4rrr5s)roZargsortrPzip)rrsrtZindexesZscoresZ label_namesrr4rr8rs:  zVideoClasTopk.__call__)N)rr)r9r:r;r<rrrrRr#rrrrodictrirrr8r>rrrrrgEs"(  rgc@s.eZdZdZdeejdeejfddZdS)ToBatchzA class for batching videos.r/rcCstj|ddjtjddgS)zCall method to stack videos into a batch. Args: videos (list of np.ndarrays): List of videos to process. Returns: list of np.ndarrays: List containing a stacked tensor of the videos. rr]F)rYrc)rZ concatenaterPrMr7rrrr8s zToBatch.__call__N)r9r:r;r<rrrr8rrrrr{s"r{)typingrrrrrnumpyrZ utils.depsrr Zutils.benchmarkr r%Ztimeitr r?rIrSrgr{rrrrs( m55MF