class_docstr: This is an auxiliary class that enables Video Stabilization for vidgear with minimalistic latency, and at the expense
  of little to no additional computational requirements.
  
  The basic idea behind it is to tracks and save the salient feature array for the given number of frames and then uses
  these anchor point to cancel out all perturbations relative to it for the incoming frames in the queue. This class relies
  heavily on **Threaded Queue mode** for error-free & ultra-fast frame handling.
docstr: This method takes an unstabilized video frame, and returns a stabilized one.
  
  Parameters:
      frame (numpy.ndarray): inputs unstabilized video frames.
code: def stabilize(self, frame):
      """
      This method takes an unstabilized video frame, and returns a stabilized one.
  
      Parameters:
          frame (numpy.ndarray): inputs unstabilized video frames.
      """
      # check if frame is None
      if frame is None:
          # return if it does
          return
  
      # save frame size for zooming
      if self.__crop_n_zoom and self.__frame_size == None:
          self.__frame_size = frame.shape[:2]
  
      # initiate transformations capturing
      if not self.__frame_queue:
          # for first frame
          previous_gray = cv2.cvtColor(
              frame, cv2.COLOR_BGR2GRAY
          )  # convert to gray
          previous_gray = self.__clahe.apply(
              previous_gray
          )  # optimize gray frame
          self.__previous_keypoints = cv2.goodFeaturesToTrack(
              previous_gray,
              maxCorners=200,
              qualityLevel=0.05,
              minDistance=30.0,
              blockSize=3,
              mask=None,
              useHarrisDetector=False,
              k=0.04,
          )  # track features using GFTT
          self.__frame_height, self.frame_width = frame.shape[
              :2
          ]  # save input frame height and width
          self.__frame_queue.append(frame)  # save frame to deque
          self.__frame_queue_indexes.append(
              0
          )  # save frame index to deque
          self.__previous_gray = previous_gray[
              :
          ]  # save gray frame clone for further processing
  
      elif self.__frame_queue_indexes[-1] < self.__smoothing_radius - 1:
          # for rest of frames
          self.__frame_queue.append(frame)  # save frame to deque
          self.__frame_queue_indexes.append(
              self.__frame_queue_indexes[-1] + 1
          )  # save frame index
          self.__generate_transformations()  # generate transformations
      else:
          # start applying transformations
          self.__frame_queue.append(frame)  # save frame to deque
          self.__frame_queue_indexes.append(
              self.__frame_queue_indexes[-1] + 1
          )  # save frame index
          self.__generate_transformations()  # generate transformations
          # calculate smooth path once transformation capturing is completed
          for i in range(3):
              # apply normalized box filter to the path
              self.__smoothed_path[:, i] = self.__box_filter_convolve(
                  (self.__path[:, i]),
                  window_size=self.__smoothing_radius,
              )
          # calculate deviation of path from smoothed path
          deviation = self.__smoothed_path - self.__path
          # save smoothed transformation
          self.__frame_transforms_smoothed = (
              self.frame_transform + deviation
          )
          # return transformation applied stabilized frame
          return self.__apply_transformations()
  
file_path: vidgear/vidgear/gears/stabilizer.py
imports: import cv2
  import numpy
  import logging
  from collections import deque
  from .helper import logger_handler, check_CV_version, retrieve_best_interpolation, logcurr_vidgear_ver
label_desc: Use image node_id 2 for calling the Stabilizer obj's underlying member method code with example usage: obj.stabilize(frame) and returns: self