docs: def draw_interpretations(self):
          """
          draw the specimen interpretations on the zijderveld, the specimen
          equal area, and the M/M0 plots
  
          Alters
          ------
          fit.lines, fit.points, fit.eqarea_data, fit.mm0_data,
          zijplot, specimen_eqarea_interpretation, mplot_interpretation
          """
  
          problems = {}
  
          if self.s in self.pmag_results_data['specimens'] and \
                  self.pmag_results_data['specimens'][self.s] != []:
              #            self.zijplot.collections=[] # delete fit points
              self.specimen_EA_xdata = []  # clear saved x positions on specimen equal area
              self.specimen_EA_ydata = []  # clear saved y positions on specimen equal area
  
          # check to see if there's a results log or not
          if not (self.s in list(self.pmag_results_data['specimens'].keys())):
              self.pmag_results_data['specimens'][self.s] = []
  
          for fit in self.pmag_results_data['specimens'][self.s]:
  
              pars = fit.get(self.COORDINATE_SYSTEM)
  
              if (fit.tmin == None or fit.tmax == None or not pars):
                  if 'no bounds' not in list(problems.keys()):
                      problems['no bounds'] = []
                  problems['no bounds'].append(fit)
                  continue
  
              for line in fit.lines:
                  if line in self.zijplot.lines:
                      self.zijplot.lines.remove(line)
              for point in fit.points:
                  if point in self.zijplot.collections:
                      self.zijplot.collections.remove(point)
  
              PCA_type = fit.PCA_type
  
              tmin_index, tmax_index = self.get_indices(fit)
  
              marker_shape = 'o'
              SIZE = 20
              if fit == self.current_fit:
                  marker_shape = 'D'
              if pars['calculation_type'] == "DE-BFP":
                  marker_shape = 's'
                  if "bfv" in self.plane_display_box.GetValue():
                      marker_shape = '>'
              if fit in self.bad_fits:
                  marker_shape = (4, 1, 0)
                  SIZE = 30*self.GUI_RESOLUTION
  
              # Zijderveld plot
  
              ymin, ymax = self.zijplot.get_ylim()
              xmin, xmax = self.zijplot.get_xlim()
  
              for i in range(1):
                  if (len(self.CART_rot[:, i]) <= tmin_index or
                          len(self.CART_rot[:, i]) <= tmax_index):
                      self.Add_text()
  
              self.zijplot.scatter([self.CART_rot[:, 0][tmin_index], self.CART_rot[:, 0][tmax_index]], [-1 * self.CART_rot[:, 1][tmin_index], -
                                                                                                        1 * self.CART_rot[:, 1][tmax_index]], marker=marker_shape, s=40, facecolor=fit.color, edgecolor='k', zorder=100, clip_on=False)
              self.zijplot.scatter([self.CART_rot[:, 0][tmin_index], self.CART_rot[:, 0][tmax_index]], [-1 * self.CART_rot[:, 2][tmin_index], -
                                                                                                        1 * self.CART_rot[:, 2][tmax_index]], marker=marker_shape, s=40, facecolor=fit.color, edgecolor='k', zorder=100, clip_on=False)
              fit.points[0] = self.zijplot.collections[-1]
              fit.points[1] = self.zijplot.collections[-2]
  
              if pars['calculation_type'] in ['DE-BFL', 'DE-BFL-A', 'DE-BFL-O']:
  
                  # rotated zijderveld
                  if self.COORDINATE_SYSTEM == 'geographic' and len(self.Data[self.s]['zdata_geo']) > 0:
                      first_data = self.Data[self.s]['zdata_geo'][0]
                  elif self.COORDINATE_SYSTEM == 'tilt-corrected' and len(self.Data[self.s]['zdata_tilt']) > 0:
                      first_data = self.Data[self.s]['zdata_tilt'][0]
                  else:
                      first_data = self.Data[self.s]['zdata'][0]
                      if self.COORDINATE_SYSTEM != 'specimen':
                          self.on_menu_change_speci_coord(-1)
                          pars = fit.get(self.COORDINATE_SYSTEM)
  
                  if self.ORTHO_PLOT_TYPE == 'N-S':
                      rotation_declination = 0.
                  elif self.ORTHO_PLOT_TYPE == 'E-W':
                      rotation_declination = 90.
                  elif self.ORTHO_PLOT_TYPE == 'PCA_dec':
                      if 'specimen_dec' in list(pars.keys()) and type(pars['specimen_dec']) != str:
                          rotation_declination = pars['specimen_dec']
                      else:
                          rotation_declination = pmag.cart2dir(first_data)[0]
                  else:  # Zijderveld
                      rotation_declination = pmag.cart2dir(first_data)[0]
  
                  PCA_dir = [pars['specimen_dec'], pars['specimen_inc'], 1]
                  PCA_dir_rotated = [PCA_dir[0] -
                                     rotation_declination, PCA_dir[1], 1]
                  PCA_CART_rotated = pmag.dir2cart(PCA_dir_rotated)
  
                  slop_xy_PCA = -1*PCA_CART_rotated[1]/PCA_CART_rotated[0]
                  slop_xz_PCA = -1*PCA_CART_rotated[2]/PCA_CART_rotated[0]
  
                  # Center of mass rotated for plotting
                  CM_x = mean(self.CART_rot_good[:, 0][tmin_index:tmax_index+1])
                  CM_y = mean(self.CART_rot_good[:, 1][tmin_index:tmax_index+1])
                  CM_z = mean(self.CART_rot_good[:, 2][tmin_index:tmax_index+1])
  
                  # intercpet from the center of mass
                  intercept_xy_PCA = -1*CM_y - slop_xy_PCA*CM_x
                  intercept_xz_PCA = -1*CM_z - slop_xz_PCA*CM_x
  
                  xx = array([self.CART_rot[:, 0][tmax_index],
                              self.CART_rot[:, 0][tmin_index]])
                  yy = slop_xy_PCA*xx+intercept_xy_PCA
                  zz = slop_xz_PCA*xx+intercept_xz_PCA
  
                  if (pars['calculation_type'] in ['DE-BFL-A']):  # CHECK
                      xx = [0.] + xx
                      yy = [0.] + yy
                      zz = [0.] + zz
  
                  self.zijplot.plot(xx, yy, '-', color=fit.color,
                                    lw=3, alpha=0.5, zorder=0)
                  self.zijplot.plot(xx, zz, '-', color=fit.color,
                                    lw=3, alpha=0.5, zorder=0)
  
                  fit.lines[0] = self.zijplot.lines[-2]
                  fit.lines[1] = self.zijplot.lines[-1]
  
              # Equal Area plot
              self.toolbar2.home()
  
              # delete old interpretation data
              for d in fit.eqarea_data:
                  if d in self.specimen_eqarea.lines:
                      self.specimen_eqarea.lines.remove(d)
                  if d in self.specimen_eqarea.collections:
                      self.specimen_eqarea.collections.remove(d)
  
              if pars['calculation_type'] == 'DE-BFP' and \
                 self.plane_display_box.GetValue() != "poles":
  
                  # draw a best-fit plane
                  ymin, ymax = self.specimen_eqarea.get_ylim()
                  xmin, xmax = self.specimen_eqarea.get_xlim()
  
                  D_c, I_c = pmag.circ(
                      pars["specimen_dec"], pars["specimen_inc"], 90)
                  X_c_up, Y_c_up = [], []
                  X_c_d, Y_c_d = [], []
                  for k in range(len(D_c)):
                      XY = pmag.dimap(D_c[k], I_c[k])
                      if I_c[k] < 0:
                          X_c_up.append(XY[0])
                          Y_c_up.append(XY[1])
                      if I_c[k] > 0:
                          X_c_d.append(XY[0])
                          Y_c_d.append(XY[1])
  
                  if self.plane_display_box.GetValue() == "u. hemisphere" or \
                     self.plane_display_box.GetValue() == "whole plane" or \
                     "wp" in self.plane_display_box.GetValue():
                      self.specimen_eqarea.plot(X_c_d, Y_c_d, 'b')
                  if self.plane_display_box.GetValue() == "l. hemisphere" or \
                     self.plane_display_box.GetValue() == "whole plane" or \
                     "wp" in self.plane_display_box.GetValue():
                      self.specimen_eqarea.plot(X_c_up, Y_c_up, 'c')
                  eqarea_x = XY[0]
                  eqarea_y = XY[1]
                  z = 1
                  fit.eqarea_data[0] = self.specimen_eqarea.lines[-1]
                  fit.eqarea_data[1] = self.specimen_eqarea.lines[-2]
  
                  if "bfv" in self.plane_display_box.GetValue():
                      if 'bfv_dec' not in list(pars.keys()) or 'bfv_inc' not in list(pars.keys()):
                          self.calculate_best_fit_vectors()
                          pars = fit.get(self.COORDINATE_SYSTEM)
                      try:
                          CART = pmag.dir2cart(
                              [pars['bfv_dec'], pars['bfv_inc'], 1])
                          x = CART[0]
                          y = CART[1]
                          z = CART[2]
                          R = array(sqrt(1-abs(z))/sqrt(x**2+y**2))
                          eqarea_x = y*R
                          eqarea_y = x*R
                      except KeyError:
                          print(("specimen %s fit %s is marked bad or there was an error calculating bfv pole will be displayed instead" % (
                              element, fit.name)))
  
              else:
                  CART = pmag.dir2cart(
                      [pars['specimen_dec'], pars['specimen_inc'], 1])
                  x = CART[0]
                  y = CART[1]
                  z = CART[2]
                  R = array(sqrt(1-abs(z))/sqrt(x**2+y**2))
                  eqarea_x = y*R
                  eqarea_y = x*R
  
              self.specimen_EA_xdata.append(eqarea_x)
              self.specimen_EA_ydata.append(eqarea_y)
              if z > 0:
                  FC = fit.color
                  EC = '0.1'
              else:
                  FC = (1, 1, 1)
                  EC = fit.color
              self.specimen_eqarea.scatter([eqarea_x], [
                                           eqarea_y], marker=marker_shape, edgecolor=EC, facecolor=FC, s=SIZE, lw=1, clip_on=False)
              fit.eqarea_data[0] = self.specimen_eqarea.collections[-1]
  
              # M/M0 plot (only if C or mT - not both)
              for d in fit.mm0_data:
                  if d in self.mplot.collections:
                      self.mplot.collections.remove(d)
                  elif d in self.mplot_af.collections:
                      self.mplot_af.collections.remove(d)
              temp_data_exists = any(
                  ['C' in step for step in self.Data[self.s]['zijdblock_steps']])
              af_data_exists = any(
                  ['T' in step for step in self.Data[self.s]['zijdblock_steps']])
              if "C" in fit.tmin and temp_data_exists:
                  tmin_ax = self.mplot
              elif af_data_exists:
                  tmin_ax = self.mplot_af
              else:
                  tmin_ax = self.mplot
              if "C" in fit.tmax and temp_data_exists:
                  tmax_ax = self.mplot
              elif af_data_exists:
                  tmax_ax = self.mplot_af
              else:
                  tmax_ax = self.mplot
              tmin_ymin, tmin_ymax = tmin_ax.get_ylim()
              tmin_xmin, tmin_xmax = tmin_ax.get_xlim()
              tmax_ymin, tmax_ymax = tmax_ax.get_ylim()
              tmax_xmin, tmax_xmax = tmax_ax.get_xlim()
              fit.mm0_data[0] = tmin_ax.scatter([self.Data[self.s]['zijdblock'][tmin_index][0]], [self.Data[self.s]['zijdblock'][tmin_index][3] /
                                                                                                  self.Data[self.s]['zijdblock'][0][3]], marker=marker_shape, s=30, facecolor=fit.color, edgecolor='k', zorder=10000, clip_on=False)
              fit.mm0_data[1] = tmax_ax.scatter([self.Data[self.s]['zijdblock'][tmax_index][0]], [self.Data[self.s]['zijdblock'][tmax_index][3] /
                                                                                                  self.Data[self.s]['zijdblock'][0][3]], marker=marker_shape, s=30, facecolor=fit.color, edgecolor='k', zorder=10000, clip_on=False)
              tmin_ax.set_xlim(tmin_xmin, tmin_xmax)
              tmin_ax.set_ylim(tmin_ymin, tmin_ymax)
              tmax_ax.set_xlim(tmax_xmin, tmax_xmax)
              tmax_ax.set_ylim(tmax_ymin, tmax_ymax)
  
              # logger
              if fit == self.current_fit:
                  for item in range(self.logger.GetItemCount()):
                      if item >= tmin_index and item <= tmax_index:
                          self.logger.SetItemBackgroundColour(item, "LIGHT BLUE")
                      else:
                          self.logger.SetItemBackgroundColour(item, "WHITE")
                      try:
                          relability = self.Data[self.s]['measurement_flag'][item]
                      except IndexError:
                          relability = 'b'
                      if relability == 'b':
                          self.logger.SetItemBackgroundColour(item, "red")
  
          if problems != {}:
              if 'no bounds' in list(problems.keys()):
                  text = "Fits "
                  for problem in problems['no bounds']:
                      text += fit.name + ' '
                  text += " for the current specimen are missing bounds and will not be displayed."
  
          self.canvas1.draw()
          self.canvas2.draw()
          self.canvas3.draw()