def plot_function_and_solution(func, area, first_point, solution, meshgrid):
    fig = plt.figure(figsize=(14, 8))
    ax1 = fig.add_subplot(121)
    ax2 = fig.add_subplot(122, projection="3d")

    fig.suptitle("My Function", size=24)

    # Color mesh
    ax1.set_axis_bgcolor("white")
#    ax1.pcolormesh(X, Y, Z, cmap=cm.jet, norm=LogNorm())
    ax1.contour(*meshgrid, zdir='z', offset=0, stride=0.1, cmap=cm.coolwarm)
    ax1.scatter(*first_point, color="k")
    ax1.annotate('First Point', xy=first_point, xytext=(-0.5, 1.25),
                 arrowprops=dict(facecolor='black', shrink=0.05))
    ax1.scatter(solution[0], solution[1], color="g")
    ax1.annotate('Solution', xy=(solution[0], solution[1]), xytext=(-1, -3),
                 arrowprops=dict(facecolor='blue', shrink=0.05))

    # Surface plot
    ax2.set_axis_bgcolor("white")
    ax2.plot_surface(*meshgrid, norm = LogNorm(), cmap=cm.jet, linewidth=1)

    first_point_3d = (first_point[0], first_point[1], func(first_point))

    ax2.view_init(azim=65, elev=25)
    ax2.scatter(*first_point_3d, color="k")
    xa, ya, _ = proj3d.proj_transform(first_point_3d[0], first_point_3d[1], first_point_3d[2], ax2.get_proj())
    ax2.annotate("First Point", xy = (xa, ya), xytext = (20, 120),
                 textcoords = 'offset points', ha = 'right', va = 'bottom',
                 arrowprops=dict(facecolor='black', shrink=0.05))
    ax2.scatter(*solution, color="k")
    xa, ya, _ = proj3d.proj_transform(solution[0], solution[1], solution[2], ax2.get_proj())
    ax2.annotate("Solution", xy = (xa, ya), xytext = (0, 100),
                 textcoords = 'offset points', ha = 'right', va = 'bottom',
                 arrowprops=dict(facecolor='blue', shrink=0.05))

 def refresh(self):
     for l in self._labs:
         x, y, _ = proj3d.proj_transform(l[1][0], l[1][1], l[1][2], self.ax1.get_proj())
         x2, y2, _ = proj3d.proj_transform(l[2][0], l[2][1], l[2][2], self.ax1.get_proj())
         l[0].xytext = self._midp(x, y, x2, y2)
     
     for l in self._alabs:
         x, y, _ = proj3d.proj_transform(l[1][0], l[1][1], l[1][2], self.ax1.get_proj())
         l[0].xytext = (x+0.002,y+0.002)
     
     self.canvas.draw()

def plot_surface(ax, m, start, goal, title):
    t1 = np.arange(181)
    t2 = np.arange(361)
    X, Y = np.meshgrid(t1, t2, indexing='ij')
    surf = ax.plot_surface(X, Y, m, cmap=cm.jet)
    ax.set_title(title)
    ax.set_xlabel('theta1')
    ax.set_ylabel('theta2')
    x, y, _ = proj3d.proj_transform(start[0],start[1],m[start[0], start[1]], ax.get_proj())
    x2, y2, _ = proj3d.proj_transform(goal[0],goal[1],m[goal[0], goal[1]], ax.get_proj())
    l1 = ax.annotate('start', xy=(x, y))
    l2 = ax.annotate('goal', xy=(x2, y2))

        def update_position(e):
            for i, x, y, z, l in zip(i_s, xs, ys, zs, labels):
                x2, y2, _ = proj3d.proj_transform(x, y, z, ax.get_proj())
                l.xy = x2,y2
                l.update_positions(fig.canvas.renderer)

            fig.canvas.draw()

def update_position(e):
    for a in range(len(all_position)):
        x2, y2, _ = proj3d.proj_transform(all_position[a][0],all_position[a][1],all_position[a][2], ax.get_proj())
        all_label[a].xy = x2,y2

    label.update_positions(fig.canvas.renderer)
    fig.canvas.draw()

    def annotatePlot(X, index, annotes, button):
        """Create popover label in 3d chart

        Args:
            X (np.array) - array of points, of shape (numPoints, 3)
            index (int) - index (into points array X) of item which should be printed
        Returns:
            None
        """
        # If we have previously displayed another label, remove it first
        if hasattr(annotatePlot, 'label'):
            annotatePlot.label.remove()

        if button == 2:
            # Get data point from array of points X, at position index
            x2, y2, _ = proj3d.proj_transform(X[index, 0], X[index, 1], X[index, 2], ax.get_proj())

            annote = annotes[index]

            annotatePlot.label = plt.annotate(annote,
                                              xy=(x2, y2), xytext=(-20, 20), textcoords='offset points', ha='right',
                                              va='bottom',
                                              bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5),
                                              arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0'))
        # if we press another button (i.e. to pan the axis we need to create a dummy (blank) annotate
        # this is because the annotePlot still has an attribute (it has previously been called
        elif button != 2:
            annotatePlot.label = plt.annotate('', xy=(0, 0), xytext=(0, 0))

        fig.canvas.draw()

 def draw(self, renderer):
     #xs3d, ys3d, zs3d = self._verts3d
     for coords in self._verts3d:
         xs3d, ys3d, zs3d = coords[0], coords[1], coords[2]
         xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)
         self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
         FancyArrowPatch.draw(self, renderer)

    def LabelEvent(self, GraphicsObject, PlotOptions):
        EventTypeFormatted = self.EventType
        if EventTypeFormatted == 'upwr_flyby':
            EventTypeFormatted = 'unpowered flyby'
        elif EventTypeFormatted == 'pwr_flyby':
            EventTypeFormatted = 'powered flyby'
        elif EventTypeFormatted == 'chem_burn':
            EventTypeFormatted = 'chemical burn'
        elif EventTypeFormatted == 'LT_rndzvs':
            EventTypeFormatted = 'LT rendezvous'
        elif EventTypeFormatted == 'begin_spiral':
            EventTypeFormatted = 'begin spiral'
        elif EventTypeFormatted == 'end_spiral':
            EventTypeFormatted = 'end spiral'

        description = EventTypeFormatted + '\n' + self.Location + '\n' + self.GregorianDate

        #for launches a C3 and DLA are needed
        if self.EventType == 'launch':
            description += '\nC3 = ' + "{0:.3f}".format(self.C3) + ' $km^2/s^2$'
            #add the LV to the description?
            description += '\nDLA = ' + "{0:.1f}".format(self.Declination) + '$^{\circ}$'

        #for non-launch departures only the C3 is needed
        if self.EventType == 'departure':
            description += '\nC3 = ' + "{0:.3f}".format(self.C3) + ' $km^2/s^2$'

        #for spirals output only the delta-v
        if self.EventType == 'begin_spiral' or self.EventType == 'end_spiral':
            description += '\n$\Delta v$ = ' + "{0:.3f}".format(self.DVmagorThrottle) + ' $km/s$'

        #for other events, output v-infinity and DLA
        if self.EventType == 'upwr_flyby' or self.EventType == 'pwr_flyby' or self.EventType == 'intercept' or self.EventType == 'interface' or self.EventType == 'insertion':
            description += '\n$v_\infty$ = ' + "{0:.3f}".format(math.sqrt(self.C3)) + ' $km/s$'
            description += '\nDEC = ' + "{0:.1f}".format(self.Declination) + '$^{\circ}$'

        #for flybys, altitude should be outputed
        if self.EventType == 'upwr_flyby' or self.EventType == 'pwr_flyby':
            description += '\naltitude = ' + "{0:.0f}".format(self.Altitude) + ' $km$'


        #for propulsive events, a deltaV is needed
        if self.EventType == 'departure' or self.EventType == 'pwr_flyby' or self.EventType == 'insertion' or self.EventType == 'chem_burn' or self.EventType == 'rendezvous':
                description += '\n$\Delta v$ = ' + "{0:.3f}".format(self.DVmagorThrottle) + ' $km/s$'

        #always append the spacecraft Mass
        description += '\nm = ' + "{0:.0f}".format(self.Mass) + ' $kg$'

        #draw the text
        #note, do not draw anything for chemical burns below 10 m/s
        if not (self.EventType == "chem_burn" and self.DVmagorThrottle < 0.001):
            x2D, y2D, _ = proj3d.proj_transform(self.SpacecraftState[0],self.SpacecraftState[1],self.SpacecraftState[2], GraphicsObject.get_proj())

            self.eventlabel = plt.annotate(description, xycoords = 'data', xy = (x2D, y2D), xytext = (20, 20), textcoords = 'offset points', ha = 'left', va = 'bottom',
                                           bbox = dict(boxstyle = 'round,pad=0.5', fc = 'white', alpha = 0.5), arrowprops = dict(arrowstyle = '->',
                                           connectionstyle = 'arc3,rad=0'), size=PlotOptions.FontSize)

            self.AnnotationHelper = self.eventlabel.draggable(use_blit=True)
            self.pcid = GraphicsObject.figure.canvas.mpl_connect('button_press_event', self.ClickAnnotation)
            self.rcid = GraphicsObject.figure.canvas.mpl_connect('button_release_event', self.ReleaseAnnotation)

def plot_emotions(emotions, X, Y, Z, plot_labels = True):
    emos = emotions
    import matplotlib
    matplotlib.use('TkAgg')
    from matplotlib import pyplot as plt 
    from mpl_toolkits.mplot3d import Axes3D
    from mpl_toolkits.mplot3d import proj3d
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')    
    ax.scatter(X, Y, Z)
    ax.set_xlabel('Serotonin')
    ax.set_ylabel('Noradrenaline')
    ax.set_zlabel('Dopamine')
    
    if plot_labels:
        labels = []
        for i in range(len(X)):
            x2, y2, _ = proj3d.proj_transform(X[i],Y[i],Z[i], ax.get_proj())
            label = plt.annotate(
                emos[i], 
                xy = (x2, y2), xytext = (-5, 5),
                textcoords = 'offset points', ha = 'right', va = 'bottom',
                bbox = dict(boxstyle = 'round,pad=0.1', fc = 'yellow', alpha = 0.5),
                arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'))
            labels.append(label)
        
        def update_position(e):
            for i in range(len(X)):
                x2, y2, _ = proj3d.proj_transform(X[i],Y[i],Z[i], ax.get_proj())
                labels[i].xy = (x2, y2)
                labels[i].update_positions(fig.canvas.renderer)
            fig.canvas.draw()
        fig.canvas.mpl_connect('button_release_event', update_position)
    plt.tight_layout()
    plt.show()

 def draw(self, renderer):
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
         xs3d, ys3d, zs3d = self._verts3d
         xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)
         self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
         FancyArrowPatch.draw(self, renderer)

def annotatedScatter3d(labels,xs,ys,zs):
    """3d scatter plot, sadly rotating breaks the association of dots and annotations"""
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    sc = ax.scatter(xs,ys,zs)
    for txt, x, y, z in zip(labels, xs, ys, zs):
        x2, y2, _ = proj3d.proj_transform(x,y,z, ax.get_proj())
        label = plt.annotate(txt, xy = (x2, y2))

 def draw(self, renderer):
     xs3d, ys3d, zs3d = self._verts3d
     xs, ys, zs = proj3d.proj_transform(xs3d, 
                                        ys3d, 
                                        zs3d, 
                                        renderer.M)
     self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
     mp.FancyArrowPatch.draw(self, renderer)

def update_position(e):
    global fig
    global ax
    global labels_and_points
    for label, x, y, z in labels_and_points:
        x2, y2, _ = proj3d.proj_transform(x, y, z, ax.get_proj())
        label.xy = x2,y2
        label.update_positions(fig.canvas.renderer)
    fig.canvas.draw()

def update_position(e):
    print "In update"
    x2, y2, _ = proj3d.proj_transform(x, y, z, ax.get_proj())
    for i in range(0, np.size(z)):
        if i % 800 == 0:
            labels[(i / 800)].xy = x2[i], y2[i]
            labels[(i / 800)].update_positions(fig.canvas.renderer)

    fig.canvas.draw()

 def update_position(e):
     x2, y2, _ = proj3d.proj_transform(data3N[:, 0], data3N[:, 1],
                                       data3N[:, 2], ax.get_proj())
     
     for i in range(len(data3N[:, 0])):
         label = Labels[i]
         label.xy = x2[i],y2[i]
         label.update_positions(fig.canvas.renderer)
     fig.canvas.draw()

						def update_position(e):
							print('update')
							#Transform co-ordinates to get new 2D projection
							Tx, Ty, _ = proj3d.proj_transform(xp, yp, zp, ax.get_proj())
							for i in range(len(xp)):
								label = label_list[i]
								label.xy = Tx[i],Ty[i]
								label.update_positions(fig.canvas.renderer)
							fig.canvas.draw()
							return

    def _load_residue(self, event):
        r = self._ligands[self.res_type.GetValue()]
        
        self.ax1.cla()
        self.ax1.mouse_init()
        self.ax1.set_frame_on(False)
        self.ax1.set_axis_off()
        
        for a in (self.ax1.w_xaxis, self.ax1.w_yaxis, self.ax1.w_zaxis):
            a.line.set_visible(False)
            a.pane.set_visible(False)
            a.set_major_locator(ticker.NullLocator())
        
        self.ax1.scatter3D(r['c'][:,0], r['c'][:,1], r['c'][:,2], c=r['col'], s=400)
        
        m = max([max(r['c'][:,i])-min(r['c'][:,i]) for i in range(3)])

        for i,ax in enumerate(['set_xlim', 'set_ylim', 'set_zlim']):
            mid = min(r['c'][:,i])+((max(r['c'][:,i]) - min(r['c'][:,i]))/2)
            getattr(self.ax1, ax)(mid-(m/2), mid+(m/2))
                
        self._labs = []
        self._alabs = []
        for i,a in enumerate(r['at']):
            ac = r['c'][i]
            x2, y2, _ = proj3d.proj_transform(ac[0],ac[1],ac[2], self.ax1.get_proj())
            for j,b in enumerate(r['at']):
                if a is not b:
                    bc = r['c'][j]
                    if a.distance(b) < 1.8:
                        std = ''
                        
                        n = a.name.strip()+'-'+b.name.strip()
                        if n in r['stdevs']:
                            std = ' (' + str(r['stdevs'][n]) + ')'
                        
                        self.ax1.plot([ac[0], bc[0]], [ac[1], bc[1]], [ac[2], bc[2]], 'k-')
                        x3, y3, _ = proj3d.proj_transform(bc[0],bc[1],bc[2], self.ax1.get_proj())
                        self._labs.append([self.ax1.annotate('%.2f' % a.distance(b) + std, xy=self._midp(x2,y2,x3,y3), size=6), ac, bc])
            
            self._alabs.append([self.ax1.annotate(a.name.strip(), xy=(x2+0.002,y2+0.002), size=7), ac])

        self.canvas.draw()

 def flatten3DPoint(self, px, py, pz):
     """project a point in 3D space onto a 2D screen"""
     # convert 3D spave to 2D space
     x2, y2, _ = proj3d.proj_transform(px, py, pz, self.threeDAx.get_proj())
     # convert 2d space to screen space
     [x2,y2] = self.threeDAx.transData.transform((x2, y2))
     # adjust for image dimensions
     x2 = x2/self.twoDImgWidth
     y2 = y2/self.twoDImgHeight
     return [x2, y2]

    def update_position(self, e):

        labels = self.labels

        for ii, c in enumerate(self.points):

            x_proj, y_proj, _ = proj3d.proj_transform(c[0], c[1], c[2], self.ax.get_proj())
            labels[ii].xy = x_proj, y_proj

            labels[ii].update_positions(self.fig.canvas.renderer)

        self.fig.canvas.draw()

def update_position(e):
    """
    A callback handler to update positions of the labels projected into 2d space
    when the graph is rotated
    """
    for k in LABELS_MAP:
        x1, y1, z1 = LABELS_MAP[k][0:3]
        x2, y2, _ = proj3d.proj_transform(x1, y1, z1, AXES.get_proj())
        annotation = LABELS_MAP[k][3]
        annotation.xy = x2, y2
        annotation.update_positions(FIG.canvas.renderer)
    FIG.canvas.draw()