code: def check_fixed_param_laplacian(
      device,
      batch_size,
      in_type,
      out_type,
      shape,
      layout,
      axes,
      window_size,
      smoothing_size,
      scales,
      normalize,
  ):
      iterator = RandomlyShapedDataIterator(
          batch_size, max_shape=shape, dtype=in_type
      )
  
      @pipeline_def
      def pipeline():
          data = fn.external_source(iterator, layout=layout)
          if out_type != np.float32:
              dtype_arg = {}
          else:
              dtype_arg = {"dtype": types.FLOAT}
          if device == "gpu":
              data = data.gpu()
          edges = fn.laplacian(
              data,
              window_size=window_size,
              smoothing_size=smoothing_size,
              scale=scales,
              normalized_kernel=normalize,
              **dtype_arg,
          )
          return edges, data
  
      pipe = pipeline(
          device_id=0, num_threads=4, batch_size=batch_size, seed=42
      )
      pipe.build()
  
      for _ in range(test_iters):
          edges, data = pipe.run()
          if device == "gpu":
              edges = edges.as_cpu()
              data = data.as_cpu()
          edges = to_batch(edges, batch_size)
          data = to_batch(data, batch_size)
          baseline = []
          for i in range(batch_size):
              skip_axes = count_skip_axes(layout)
              window_size = (
                  np.array([])
                  if window_size is None
                  else np.array(window_size, dtype=np.int32)
              )
              smoothing_size = (
                  np.array([])
                  if smoothing_size is None
                  else np.array(smoothing_size, dtype=np.int32)
              )
              if normalize:
                  all_sizes = get_window_sizes(
                      window_size, smoothing_size, axes
                  )
                  scales = [
                      2.0 ** (-sum(sizes) + axes + 2)
                      for sizes in all_sizes
                  ]
              scales = np.array(scales, dtype=np.float32)
              sample = laplacian_baseline(
                  data[i],
                  out_type or in_type,
                  window_size,
                  smoothing_size,
                  scales,
                  axes,
                  skip_axes,
              )
              baseline.append(sample)
          if out_type == np.float32:
              max_error = 1e-3
          else:
              max_error = 1
          check_batch(
              edges,
              baseline,
              batch_size,
              max_allowed_error=max_error,
              expected_layout=layout,
          )
  
imports: from nvidia.dali.pipeline import pipeline_def
  import nvidia.dali.types
  import nvidia.dali.fn
  import numpy
  import cv2
  from scipy.ndimage import convolve1d, filters
  import os
  from nose_utils import assert_raises
  from nose.plugins.attrib import attr
  from sequences_test_utils import video_suite_helper, ArgCb
  from test_utils import get_dali_extra_path, check_batch, RandomlyShapedDataIterator
label_desc: Use image node_id 23 for calling a global function with example usage: check_fixed_param_laplacian(device, batch_size, in_type, out_type, shape, layout, axes, window_size, smoothing_size, scales, normalize) and returns: edges,  data