
"""simple docstring"""






# 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 					__a     ( __a       ):



							'''simple docstring'''







							_lowerCamelCase					:			Union[str, Any]          =   (
							    """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					:			Union[str, Any]          =   """CIDAS/clipseg-rd64-refined"""
							_lowerCamelCase					:			Optional[int]          =   """image_segmenter"""
							_lowerCamelCase					:			Any          =   CLIPSegForImageSegmentation

							_lowerCamelCase					:			List[str]          =   ["""image""", """text"""]
							_lowerCamelCase					:			List[str]          =   ["""image"""]
							def __init__(     self  ,    *_lowerCamelCase  ,    **_lowerCamelCase       )			->							int:




										'''simple docstring'''
										requires_backends(self  ,    ["vision"]       )
										super().__init__(*_lowerCamelCase  ,    **_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							Union[str, Any]:




										'''simple docstring'''
										return self.pre_processor(text=[label]  ,    images=[image]  ,    padding=_lowerCamelCase  ,    return_tensors="pt"       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase       )			->							Dict:




										'''simple docstring'''
										with torch.no_grad():
													__lowercase       =       self.model(**_lowerCamelCase       ).logits
										return logits





							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase       )			->							Union[str, Any]:




										'''simple docstring'''
										__lowercase       =       outputs.cpu().detach().numpy()
										__lowercase       =       0
										__lowercase       =       1
										return Image.fromarray((array * 255).astype(np.uinta       )       )







"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowercase							=				{
    '''configuration_mask2former''': [
        '''MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Mask2FormerConfig''',
    ],
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				['''Mask2FormerImageProcessor''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				[
					    '''MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''Mask2FormerForUniversalSegmentation''',
					    '''Mask2FormerModel''',
					    '''Mask2FormerPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_maskaformer import MaskaFormerImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_maskaformer import (
										    MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MaskaFormerForUniversalSegmentation,
										    MaskaFormerModel,
										    MaskaFormerPreTrainedModel,
										)


else:
					import sys

					_lowercase							=				_LazyModule(__name__, globals()['''__file__'''], _import_structure)





