code: def interpolate(self, factor, minLayer, maxLayer, round=True,
                      suppressError=True):
          
          factor = normalizers.normalizeInterpolationFactor(factor)
          if not isinstance(minLayer, BaseLayer):
              raise TypeError(("Interpolation to an instance of %r can not be "
                               "performed from an instance of %r.")
                              % (self.__class__.__name__, minLayer.__class__.__name__))
          if not isinstance(maxLayer, BaseLayer):
              raise TypeError(("Interpolation to an instance of %r can not be "
                               "performed from an instance of %r.")
                              % (self.__class__.__name__, maxLayer.__class__.__name__))
          round = normalizers.normalizeBoolean(round)
          suppressError = normalizers.normalizeBoolean(suppressError)
          self._interpolate(factor, minLayer, maxLayer,
                            round=round, suppressError=suppressError)
docs: Interpolate all possible data in the layer. ::
  
              >>> layer.interpolate(0.5, otherLayer1, otherLayer2)
              >>> layer.interpolate((0.5, 2.0), otherLayer1, otherLayer2, round=False)
  
          The interpolation occurs on a 0 to 1.0 range where **minLayer**
          is located at 0 and **maxLayer** is located at 1.0. **factor**
          is the interpolation value. It may be less than 0 and greater
          than 1.0. It may be a :ref:`type-int-float` or a tuple of
          two :ref:`type-int-float`. If it is a tuple, the first
          number indicates the x factor and the second number indicates
          the y factor. **round** indicates if the result should be
          rounded to integers. **suppressError** indicates if incompatible
          data should be ignored or if an error should be raised when
          such incompatibilities are found.