code: def slow_test_fixed_params_laplacian():
      batch_size = 10
      window_size_cases = {
          1: [None, 3, 5, 9, 21],
          2: [None, [3, 3], 11, [9, 5], [3, 17]],
          3: [None, [3, 5, 7], [3, 3, 3], 11, [23, 7, 11]],
      }
      smoothing_size_cases = {
          1: [None, 1, 3, 11, 21],
          2: [None, [1, 3], 1, 11, [9, 5]],
          3: [None, [3, 5, 7], 1, 11, [9, 7, 1]],
      }
  
      def window_scales(window_sizes, smoothing_sizes, axes):
          window_sizes = (
              np.array([])
              if window_sizes is None
              else np.array(window_sizes)
          )
          smoothing_sizes = (
              np.array([])
              if smoothing_sizes is None
              else np.array(smoothing_sizes)
          )
          all_sizes = get_window_sizes(
              window_sizes, smoothing_sizes, axes
          )
          scales = [
              2.0 ** (-sum(sizes) + axes + 2) for sizes in all_sizes
          ]
          cases = [scales]
          if all(scales[0] == s for s in scales):
              cases.append([scales[0]])
          return [
              [v * factor for v in case]
              for case in cases
              for factor in [1 / 16, 4.0]
          ]
  
      for device in ["cpu", "gpu"]:
          for in_type in [np.uint8, np.int32, np.int64, np.float32]:
              for out_type in [None, np.float32]:
                  if in_type == out_type:
                      continue
                  for shape, layout, axes in shape_layout_axes_cases:
                      for window_sizes in window_size_cases[axes]:
                          for smooth_sizes in smoothing_size_cases[
                              axes
                          ]:
                              for normalize in [True, False]:
                                  if normalize:
                                      scale_cases = [None]
                                  else:
                                      scale_cases = window_scales(
                                          window_sizes,
                                          smooth_sizes,
                                          axes,
                                      )
                                  for scales in scale_cases:
                                      yield (
                                          check_fixed_param_laplacian,
                                          device,
                                          batch_size,
                                          in_type,
                                          out_type,
                                          shape,
                                          layout,
                                          axes,
                                          window_sizes,
                                          smooth_sizes,
                                          scales,
                                          normalize,
                                      )
  
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 24 for calling a global function with example usage: slow_test_fixed_params_laplacian() and returns: unknown