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()