

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import torch

from ..models.clipseg import CLIPSegForImageSegmentation
from ..utils import is_vision_available, requires_backends
from .base import PipelineTool


if is_vision_available():
       from PIL import Image







class 						__magic_name__			(							lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__ :	str    =   (
       'This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image.'
       'It takes two arguments named `image` which should be the original image, and `label` which should be a text '
       'describing the elements what should be identified in the segmentation mask. The tool returns the mask.'
   )
   lowerCamelCase__ :	int    =   'CIDAS/clipseg-rd64-refined'
   lowerCamelCase__ :	List[Any]    =   'image_segmenter'
   lowerCamelCase__ :	str    =   CLIPSegForImageSegmentation

   lowerCamelCase__ :	Any    =   ['image', 'text']
   lowerCamelCase__ :	Tuple    =   ['image']



   def __init__(				self,    *lowercase_,    **lowercase_       )							->    int:






     """simple docstring"""






     requires_backends(self,    ['''vision''']       )
     super().__init__(*lowercase_,    **lowercase_       )



   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_       )							->    str:






     """simple docstring"""






     return self.pre_processor(text=[label],    images=[image],    padding=lowercase_,    return_tensors='''pt'''       )



   def  _UpperCAmelCase (				self,    lowercase_       )							->    int:






     """simple docstring"""






     with torch.no_grad():
       a__  =self.model(**lowercase_       ).logits
     return logits



   def  _UpperCAmelCase (				self,    lowercase_       )							->    Optional[int]:






     """simple docstring"""






     a__  =outputs.cpu().detach().numpy()
     a__  =0
     a__  =1
     return Image.fromarray((array * 255).astype(np.uinta       )       )



from __future__ import annotations




def 			UpperCAmelCase__				(			_A      : float	,      _A      : float	,      _A      : float	,      ):





  '''simple docstring'''







  if (stress, tangential_force, area).count(0							) != 1:
    raise ValueError('''You cannot supply more or less than 2 values'''							)
  elif stress < 0:
    raise ValueError('''Stress cannot be negative'''							)
  elif tangential_force < 0:
    raise ValueError('''Tangential Force cannot be negative'''							)
  elif area < 0:
    raise ValueError('''Area cannot be negative'''							)
  elif stress == 0:
    return (
        "stress",
        tangential_force / area,
    )
  elif tangential_force == 0:
    return (
        "tangential_force",
        stress * area,
    )
  else:
    return (
        "area",
        tangential_force / stress,
    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()
