






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





	"""simple docstring"""






	UpperCamelCase__								=      (
	    "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."
	)
	UpperCamelCase__								=      "CIDAS/clipseg-rd64-refined"
	UpperCamelCase__								=      "image_segmenter"
	UpperCamelCase__								=      CLIPSegForImageSegmentation

	UpperCamelCase__								=      ["image", "text"]
	UpperCamelCase__								=      ["image"]

	def __init__(							self       ,    *UpperCAmelCase       ,    **UpperCAmelCase    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							with torch.no_grad():
													_UpperCAmelCase									=			self.model(**UpperCAmelCase    ).logits
							return logits

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







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

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:

   if not grid or not grid[0]:
      raise TypeError('''The grid does not contain the appropriate information''' )

   for cell_n in range(1       ,    len(grid[0] ) ):
      grid[0][cell_n] += grid[0][cell_n - 1]
   lowercase__:   Tuple					=      grid[0]

   for row_n in range(1       ,    len(__UpperCAmelCase ) ):
      lowercase__:   Tuple					=      grid[row_n]
      lowercase__:   Dict					=      fill_row(__UpperCAmelCase       ,    __UpperCAmelCase )
      lowercase__:   Union[str, Any]					=      grid[row_n]

   return grid[-1][-1]



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase       ,    __UpperCAmelCase )  ->  list:
   current_row[0] += row_above[0]
   for cell_n in range(1       ,    len(__UpperCAmelCase ) ):
      current_row[cell_n] += min(current_row[cell_n - 1]       ,    row_above[cell_n] )

   return current_row


if __name__ == "__main__":
       import doctest

       doctest.testmod()
