code: def _one_diamond_one_square(
      img: Tensor,
      random_scale: Union[float, Tensor],
      random_fn: Callable[..., Tensor] = torch.rand,
      diamond_kernel: Optional[Tensor] = None,
      square_kernel: Optional[Tensor] = None,
  ) -> Tensor:
      """Doubles the image resolution by applying a single diamond square steps.
  
      Recursive application of this method creates plasma fractals.
  
      Attention! The function is differentiable and gradients are computed as well.
  
      If this function is run in the usual sense, it is more efficient if it is run in a no_grad()
  
      Args:
          img: a 4D tensor where dimensions are Batch, Channel, Width, Height. Width and Height must both be 2^N+1 and
              Batch and Channels should in the usual case be 1.
          random_scale: a float  number in [0,1] controlling the randomness created pixels get. I the usual case, it is
              halved at every application of this function.
          random_fn: the random function to generate the image seed.
          diamond_kernel: the 3x3 kernel to perform the diamond step.
          square_kernel: the 3x3 kernel to perform the square step.
  
      Return:
          A tensor on the same device as img with the same channels as img and width, height of 2^(N+1)+1.
      """
      KORNIA_CHECK_SHAPE(img, ["B", "C", "H", "W"])
      # TODO (anguelos) test multi channel and batch size > 1
  
      if diamond_kernel is None:
          diamond_kernel = Tensor([default_diamond_kernel]).to(
              img
          )  # 1x3x3
      if square_kernel is None:
          square_kernel = Tensor([default_square_kernel]).to(
              img
          )  # 1x3x3
  
      batch_sz, _, height, width = img.shape
      new_img: Tensor = torch.zeros(
          [batch_sz, 1, 2 * (height - 1) + 1, 2 * (width - 1) + 1],
          device=img.device,
          dtype=img.dtype,
      )
      new_img[:, :, ::2, ::2] = img
  
      factor: float = 1.0 / 0.75
      pad_compencate = torch.ones_like(new_img)
      pad_compencate[:, :, :, 0] = factor
      pad_compencate[:, :, :, -1] = factor
      pad_compencate[:, :, 0, :] = factor
      pad_compencate[:, :, -1, :] = factor
  
      random_img: Tensor = (
          random_fn(new_img.size(), device=img.device, dtype=img.dtype)
          * random_scale
      )
  
      # TODO(edgar): use kornia.filter2d
      # diamond
      diamond_regions = filter2d(new_img, diamond_kernel)
      diamond_centers = (diamond_regions > 0).to(img.dtype)
      # TODO (anguelos) make sure diamond_regions*diamond_centers is needed
      new_img = (
          new_img
          + (1 - random_scale) * diamond_regions * diamond_centers
          + diamond_centers * random_img
      )
  
      # square
      square_regions = filter2d(new_img, square_kernel) * pad_compencate
      square_centers = (square_regions > 0).to(img.dtype)
  
      # TODO (anguelos) make sure square_centers*square_regions is needed
      new_img = (
          new_img
          + square_centers * random_img
          + (1 - random_scale) * square_centers * square_regions
      )
  
      return new_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 2 for calling a global function with example usage: _one_diamond_one_square(img, random_scale, random_fn, diamond_kernel, square_kernel) and returns: new_img