class_docstr: Wrapper around ``multiprocessing.Pool`` for multicore augmentation.
  
  Parameters
  ----------
  augseq : imgaug.augmenters.meta.Augmenter
      The augmentation sequence to apply to batches.
  
  processes : None or int, optional
      The number of background workers, similar to the same parameter in
      multiprocessing.Pool. If ``None``, the number of the machine's CPU
      cores will be used (this counts hyperthreads as CPU cores). If this is
      set to a negative value ``p``, then ``P - abs(p)`` will be used,
      where ``P`` is the number of CPU cores. E.g. ``-1`` would use all
      cores except one (this is useful to e.g. reserve one core to feed
      batches to the GPU).
  
  maxtasksperchild : None or int, optional
      The number of tasks done per worker process before the process is
      killed and restarted, similar to the same parameter in
      multiprocessing.Pool. If ``None``, worker processes will not be
      automatically restarted.
  
  seed : None or int, optional
      The seed to use for child processes. If ``None``, a random seed will
      be used.
code: def __init__(
      self, augseq, processes=None, maxtasksperchild=None, seed=None
  ):
      # make sure that don't call pool again in a child process
      assert Pool._WORKER_AUGSEQ is None, (
          "_WORKER_AUGSEQ was already set when calling Pool.__init__(). "
          "Did you try to instantiate a Pool within a Pool?"
      )
      assert processes is None or processes != 0, (
          'Expected `processes` to be `None` ("use as many cores as '
          'available") or a negative integer ("use as many as available '
          'MINUS this number") or an integer>1 ("use exactly that many '
          'processes"). Got type %s, value %s instead.'
          % (type(processes), str(processes))
      )
  
      self.augseq = augseq
      self.processes = processes
      self.maxtasksperchild = maxtasksperchild
  
      if seed is not None:
          assert (
              iarandom.SEED_MIN_VALUE <= seed <= iarandom.SEED_MAX_VALUE
          ), (
              "Expected `seed` to be either `None` or a value between "
              "%d and %d. Got type %s, value %s instead."
              % (
                  iarandom.SEED_MIN_VALUE,
                  iarandom.SEED_MAX_VALUE,
                  type(seed),
                  str(seed),
              )
          )
      self.seed = seed
  
      # multiprocessing.Pool instance
      self._pool = None
  
      # Running counter of the number of augmented batches. This will be
      # used to send indexes for each batch to the workers so that they can
      # augment using SEED_BASE+SEED_BATCH and ensure consistency of applied
      # augmentation order between script runs.
      self._batch_idx = 0
  
imports: from __future__ import print_function, division, absolute_import
  import sys
  import multiprocessing
  import threading
  import traceback
  import time
  import random
  import platform
  import numpy
  import cv2
  import imgaug.imgaug
  import imgaug.random
  from imgaug.augmentables.batches import Batch, UnnormalizedBatch
label_desc: Use image node_id 1 to create a new Pool object from inherited base classes: object with example: obj = Pool(augseq, processes, maxtasksperchild, seed)