code: def diamond_square(
      output_size: Tuple[int, int, int, int],
      roughness: Union[float, Tensor] = 0.5,
      random_scale: Union[float, Tensor] = 1.0,
      random_fn: Callable[..., Tensor] = torch.rand,
      normalize_range: Optional[Tuple[float, float]] = None,
      device: Optional[torch.device] = None,
      dtype: Optional[torch.dtype] = None,
  ) -> Tensor:
      """Generates Plasma Fractal Images using the diamond square algorithm.
  
      See: https://en.wikipedia.org/wiki/Diamond-square_algorithm
  
      Args:
          output_size: a tuple of integers with the BxCxHxW of the image to be generated.
          roughness: the scale value to apply at each recursion step.
          random_scale: the initial value of the scale for recursion.
          random_fn: the callable function to use to sample a random tensor.
          normalize_range: whether to normalize using min-max the output map. In case of a
              range is specified, min-max norm is applied between the provided range.
          device: the torch device to place the output map.
          dtype: the torch dtype to place the output map.
  
      Returns:
          A tensor with shape :math:`(B,C,H,W)` containing the fractal image.
      """
      KORNIA_CHECK(
          len(output_size) == 4, "output_size must be (B,C,H,W)"
      )
      if not isinstance(random_scale, Tensor):
          random_scale = Tensor([[[[random_scale]]]]).to(device, dtype)
          random_scale = random_scale.expand(
              [output_size[0] * output_size[1], 1, 1, 1]
          )
      else:
          KORNIA_CHECK_IS_TENSOR(random_scale)
          random_scale = random_scale.view(-1, 1, 1, 1)
          random_scale = random_scale.expand(
              [output_size[0], output_size[1], 1, 1]
          )
          random_scale = random_scale.reshape([-1, 1, 1, 1])
  
      if not isinstance(roughness, Tensor):
          roughness = Tensor([[[[roughness]]]]).to(device, dtype)
          roughness = roughness.expand(
              [output_size[0] * output_size[1], 1, 1, 1]
          )
      else:
          roughness = roughness.view(-1, 1, 1, 1)
          roughness = roughness.expand(
              [output_size[0], output_size[1], 1, 1]
          )
          roughness = roughness.reshape([-1, 1, 1, 1])
  
      width, height = output_size[-2:]
      num_samples: int = 1
      for x in output_size[:-2]:
          num_samples *= x
  
      # compute the image seed
      p2_width: float = 2 ** math.ceil(math.log2(width - 1)) + 1
      p2_height: float = 2 ** math.ceil(math.log2(height - 1)) + 1
      recursion_depth: int = int(
          min(math.log2(p2_width - 1) - 1, math.log2(p2_height - 1) - 1)
      )
      seed_width: int = (p2_width - 1) // 2**recursion_depth + 1
      seed_height: int = (p2_height - 1) // 2**recursion_depth + 1
      img: Tensor = random_scale * _diamond_square_seed(
          num_samples, seed_width, seed_height, random_fn, device, dtype
      )
  
      # perform recursion
      scale = random_scale
      for _ in range(recursion_depth):
          scale = scale * roughness
          img = _one_diamond_one_square(img, scale, random_fn)
  
      # slice to match with the output size
      img = img[..., :width, :height]
      img = img.view(output_size)
  
      # normalize the output in the range using min-max
      if normalize_range is not None:
          min_val, max_val = normalize_range
          img = normalize_min_max(img.contiguous(), min_val, max_val)
      return img
  
file_path: kornia/kornia/contrib/diamond_square.py
imports: import math
  from typing import Callable, List, Optional, Tuple, Union
  import torch
  from kornia.core import Tensor
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_IS_TENSOR, KORNIA_CHECK_SHAPE
  from kornia.enhance import normalize_min_max
  from kornia.filters import filter2d
label_desc: Use image node_id 3 for calling a global function with example usage: diamond_square(output_size, roughness, random_scale, random_fn, normalize_range, device, dtype) and returns: img