class_docstr: Generic abstract class for the graphers
class_docstr_tok: ["Generic","abstract","class","for","the","graphers"]
code: def draw_peaks_contour(self):
      contour = self.contour.copy()
      contour = smooth(contour, window_len=16)
      contour = normalize(contour)
  
      # Scaling
      # ratio = numpy.mean(contour)/numpy.sqrt(2)
      ratio = 1
      contour = normalize(numpy.expm1(contour / ratio)) * (1 - 10**-6)
  
      # Spline
      # contour = cspline1d(contour)
      # contour = cspline1d_eval(contour, self.x, dx=self.dx1, x0=self.x[0])
  
      if self.symetry:
          height = int(self.image_height / 2)
      else:
          height = self.image_height
  
      # Multicurve rotating
      for i in range(0, self.ndiv):
          self.previous_x, self.previous_y = None, None
  
          bright_color = int(255 * (1 - float(i) / (self.ndiv * 2)))
          bright_color = 255 - bright_color + self.color_offset
          # line_color = self.color_lookup[int(self.centroids[j]*255.0)]
          line_color = (bright_color, bright_color, bright_color)
  
          # Linear
          # contour = contour*(1.0-float(i)/self.ndiv)
          # contour = contour*(1-float(i)/self.ndiv)
  
          # Cosinus
          contour = (
              contour
              * numpy.arccos(float(i) / self.ndiv)
              * 2
              / numpy.pi
          )
          # contour = self.contour*(1-float(i)*numpy.arccos(float(i)/self.ndiv)*2/numpy.pi/self.ndiv)
          # contour = contour + ((1-contour)*2/numpy.pi*numpy.arcsin(float(i)/self.ndiv))
  
          curve = (height - 1) * contour
          # curve = contour*(height-2)/2+height/2
  
          for x in self.x:
              x = int(x)
              y = curve[x]
              if not x == 0:
                  if not self.symetry:
                      self.draw.line(
                          [self.previous_x, self.previous_y, x, y],
                          line_color,
                      )
                      self.draw_anti_aliased_pixels(x, y, y, line_color)
                  else:
                      self.draw.line(
                          [
                              self.previous_x,
                              self.previous_y + height,
                              x,
                              y + height,
                          ],
                          line_color,
                      )
                      self.draw_anti_aliased_pixels(
                          x, y + height, y + height, line_color
                      )
                      self.draw.line(
                          [
                              self.previous_x,
                              -self.previous_y + height,
                              x,
                              -y + height,
                          ],
                          line_color,
                      )
                      self.draw_anti_aliased_pixels(
                          x, -y + height, -y + height, line_color
                      )
              else:
                  if not self.symetry:
                      self.draw.point((x, y), line_color)
                  else:
                      self.draw.point((x, y + height), line_color)
              self.previous_x, self.previous_y = x, y
  
imports: import math
  import numpy
  from timeside.core import Processor, implements, interfacedoc, abstract
  from timeside.core.processor import FixedSizeInputAdapter
  from timeside.core.api import IGrapher
  from timeside.plugins.grapher.utils import smooth, im_watermark, normalize
  import timeside.plugins.analyzer
label_desc: Use image node_id 11 for calling the Grapher obj's underlying member method code with example usage: obj.draw_peaks_contour() without return types