class_docstr: Vector decomposition and normalization, refer Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields
  for more details.
  
  Args:
      thresh(float): Threshold value for selecting candidate vector, default is 0.05.
code: def __call__(
      self,
      candA: list,
      candB: list,
      nA: int,
      nB: int,
      score_mid: np.ndarray,
      oriImg: np.ndarray,
  ):
      connection_candidate = []
      for i in range(nA):
          for j in range(nB):
              vec = np.subtract(candB[j][:2], candA[i][:2])
              norm = math.sqrt(vec[0] * vec[0] + vec[1] * vec[1]) + 1e-5
              vec = np.divide(vec, norm)
  
              startend = list(
                  zip(
                      np.linspace(candA[i][0], candB[j][0], num=10),
                      np.linspace(candA[i][1], candB[j][1], num=10),
                  )
              )
  
              vec_x = np.array(
                  [
                      score_mid[
                          int(round(startend[I][1])),
                          int(round(startend[I][0])),
                          0,
                      ]
                      for I in range(len(startend))
                  ]
              )
              vec_y = np.array(
                  [
                      score_mid[
                          int(round(startend[I][1])),
                          int(round(startend[I][0])),
                          1,
                      ]
                      for I in range(len(startend))
                  ]
              )
  
              score_midpts = np.multiply(vec_x, vec[0]) + np.multiply(
                  vec_y, vec[1]
              )
              score_with_dist_prior = sum(score_midpts) / len(
                  score_midpts
              ) + min(0.5 * oriImg.shape[0] / norm - 1, 0)
              criterion1 = len(
                  np.nonzero(score_midpts > self.thresh)[0]
              ) > 0.8 * len(score_midpts)
              criterion2 = score_with_dist_prior > 0
              if criterion1 and criterion2:
                  connection_candidate.append(
                      [
                          i,
                          j,
                          score_with_dist_prior,
                          score_with_dist_prior
                          + candA[i][2]
                          + candB[j][2],
                      ]
                  )
      return connection_candidate
  
imports: import base64
  import math
  from typing import Callable
  import cv2
  import numpy
  from scipy.ndimage import gaussian_filter
label_desc: Use image node_id 2 for calling the CalculateVector obj's underlying member method code with example usage: obj.__call__(candA, candB, nA, nB, score_mid, oriImg) and returns: connection_candidate