code: def _analyse_regions(self):
      # if there are less than 3 regions
      if len(self.skin_regions) < 3:
          self.message = (
              "Less than 3 skin regions ({_skin_regions_size})".format(
                  _skin_regions_size=len(self.skin_regions)
              )
          )
          self.result = False
          return self.result
  
      # sort the skin regions
      self.skin_regions = sorted(
          self.skin_regions, key=lambda s: len(s), reverse=True
      )
  
      # count total skin pixels
      total_skin = float(
          sum([len(skin_region) for skin_region in self.skin_regions])
      )
  
      # check if there are more than 15% skin pixel in the image
      if total_skin / self.total_pixels * 100 < 15:
          # if the percentage lower than 15, it's not nude!
          self.message = (
              "Total skin percentage lower than 15 (%.3f%%)"
              % (total_skin / self.total_pixels * 100)
          )
          self.result = False
          return self.result
  
      # check if the largest skin region is less than 35% of the total skin count
      # AND if the second largest region is less than 30% of the total skin count
      # AND if the third largest region is less than 30% of the total skin count
      if (
          len(self.skin_regions[0]) / total_skin * 100 < 35
          and len(self.skin_regions[1]) / total_skin * 100 < 30
          and len(self.skin_regions[2]) / total_skin * 100 < 30
      ):
          self.message = (
              "Less than 35%, 30%, 30% skin in the biggest regions"
          )
          self.result = False
          return self.result
  
      # check if the number of skin pixels in the largest region is
      # less than 45% of the total skin count
      if len(self.skin_regions[0]) / total_skin * 100 < 45:
          self.message = (
              "The biggest region contains less than 45 (%.3f%%)"
              % (len(self.skin_regions[0]) / total_skin * 100)
          )
          self.result = False
          return self.result
  
      # TODO:
      # build the bounding polygon by the regions edge values:
      # Identify the leftmost, the uppermost, the rightmost, and the lowermost
      # skin pixels of the three largest skin regions.
      # Use these points as the corner points of a bounding polygon.
  
      # TODO:
      # check if the total skin count is less than 30% of the total number of pixels
      # AND the number of skin pixels within the bounding polygon is
      # less than 55% of the size of the polygon if this condition is True, it's not nude.
  
      # TODO: include bounding polygon functionality
      # if there are more than 60 skin regions and the average intensity
      # within the polygon is less than 0.25 the image is not nude
      if len(self.skin_regions) > 60:
          self.message = (
              "More than 60 skin regions ({_skin_regions_size})".format(
                  _skin_regions_size=len(self.skin_regions)
              )
          )
          self.result = False
          return self.result
  
      # otherwise it is nude
      self.message = "Nude!!"
      self.result = True
      return self.result
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import copy
  import math
  import time
  from io import IOBase
  from PIL import Image
  from skin_classifier import skin_classifier, Skin
label_desc: Use image node_id 8 for calling the Nude obj's underlying member method code with example usage: obj._analyse_regions() and returns: self, self, self, self, self, self