class_docstr: Select candidate for body pose estimation.
  
  Args:
      mapIdx(list): Part Affinity Fields map index, default is None.
      limbSeq(list): Peak candidate map index, default is None.
code: def __call__(
      self, all_peaks: list, connection_all: list, special_k: list
  ):
      subset = -1 * np.ones((0, 20))
      candidate = np.array(
          [item for sublist in all_peaks for item in sublist]
      )
      for k in range(len(self.mapIdx)):
          if k not in special_k:
              partAs = connection_all[k][:, 0]
              partBs = connection_all[k][:, 1]
              indexA, indexB = np.array(self.limbSeq[k]) - 1
  
              for i in range(
                  len(connection_all[k])
              ):  # = 1:size(temp,1)
                  found = 0
                  subset_idx = [-1, -1]
                  for j in range(len(subset)):  # 1:size(subset,1):
                      if (
                          subset[j][indexA] == partAs[i]
                          or subset[j][indexB] == partBs[i]
                      ):
                          subset_idx[found] = j
                          found += 1
  
                  if found == 1:
                      j = subset_idx[0]
                      if subset[j][indexB] != partBs[i]:
                          subset[j][indexB] = partBs[i]
                          subset[j][-1] += 1
                          subset[j][-2] += (
                              candidate[partBs[i].astype(int), 2]
                              + connection_all[k][i][2]
                          )
                  elif (
                      found == 2
                  ):  # if found 2 and disjoint, merge them
                      j1, j2 = subset_idx
                      membership = (
                          (subset[j1] >= 0).astype(int)
                          + (subset[j2] >= 0).astype(int)
                      )[:-2]
                      if (
                          len(np.nonzero(membership == 2)[0]) == 0
                      ):  # merge
                          subset[j1][:-2] += subset[j2][:-2] + 1
                          subset[j1][-2:] += subset[j2][-2:]
                          subset[j1][-2] += connection_all[k][i][2]
                          subset = np.delete(subset, j2, 0)
                      else:  # as like found == 1
                          subset[j1][indexB] = partBs[i]
                          subset[j1][-1] += 1
                          subset[j1][-2] += (
                              candidate[partBs[i].astype(int), 2]
                              + connection_all[k][i][2]
                          )
  
                  # if find no partA in the subset, create a new subset
                  elif not found and k < 17:
                      row = -1 * np.ones(20)
                      row[indexA] = partAs[i]
                      row[indexB] = partBs[i]
                      row[-1] = 2
                      row[-2] = (
                          sum(
                              candidate[
                                  connection_all[k][i, :2].astype(int),
                                  2,
                              ]
                          )
                          + connection_all[k][i][2]
                      )
                      subset = np.vstack([subset, row])
      # delete some rows of subset which has few parts occur
      deleteIdx = []
      for i in range(len(subset)):
          if subset[i][-1] < 4 or subset[i][-2] / subset[i][-1] < 0.4:
              deleteIdx.append(i)
      subset = np.delete(subset, deleteIdx, axis=0)
  
      return candidate, subset
  
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 Candidate obj's underlying member method code with example usage: obj.__call__(all_peaks, connection_all, special_k) and returns: candidate,  subset