Exemple #1
0
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))
Exemple #2
0
def update_position(e):
    x2, y2, _ = proj3d.proj_transform(xposition[0], yposition[0], zposition[0], ax.get_proj())
    start_label.xy = x2,y2
    start_label.update_positions(fig.canvas.renderer)
    x2, y2, _ = proj3d.proj_transform(xposition[len(xposition)-1], yposition[len(yposition)-1], zposition[len(zposition)-1], ax.get_proj())
    end_label.xy = x2,y2
    end_label.update_positions(fig.canvas.renderer)
    fig.canvas.draw()
Exemple #3
0
 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()
Exemple #4
0
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))
Exemple #5
0
 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)
Exemple #6
0
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 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()
Exemple #8
0
 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)
Exemple #9
0
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 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()
Exemple #11
0
    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)
Exemple #12
0
 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 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 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()
Exemple #15
0
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()
Exemple #17
0
						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
Exemple #18
0
 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]
Exemple #19
0
    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()
Exemple #20
0
def update_position(e):
   print "From update position"
   #Transform co-ordinates to get new 2D projection
   tX, tY, _ = proj3d.proj_transform(dataX, dataY, dataZ, ax.get_proj())
   for i in range(len(dataX)):
      label = labels[i]
      label.xy = tX[i],tY[i]
      label.update_positions(fig.canvas.renderer)
   fig.canvas.draw()
   return
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()
    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()
Exemple #23
0
def test_proj_transform():
    M = _test_proj_make_M()

    xs = np.array([0, 1, 1, 0, 0, 0, 1, 1, 0, 0]) * 300.0
    ys = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 0]) * 300.0
    zs = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) * 300.0

    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
    ixs, iys, izs = proj3d.inv_transform(txs, tys, tzs, M)

    np.testing.assert_almost_equal(ixs, xs)
    np.testing.assert_almost_equal(iys, ys)
    np.testing.assert_almost_equal(izs, zs)
def plotFeatures(features, wordBidict, dims):
    """ 
    Plot the desired points. Will draw all points if that is requested. Will draw labels
    for added words. 
    """
    if (FIG == None and AXES == None):
        setupPlot()

    AXES.clear()
    
    xs, ys, zs = None, None, None
    if not PLOT_ALL_POINTS:
        # iterate LABELS_MAP and get features for words
        xs = np.empty((len(LABELS_MAP),))
        ys = np.empty((len(LABELS_MAP),))
        zs = np.empty((len(LABELS_MAP),))
        c = 0
        for w in LABELS_MAP:
            x, y, z, _ = LABELS_MAP[w]
            xs[c] = x
            ys[c] = y
            zs[c] = z
            c = c + 1
    else:
        xs = features[:,dims[0]] # dim 0
        ys = features[:,dims[1]] # 1
        zs = features[:,dims[2]] # 2

    AXES.scatter(xs, ys, zs, c='r', marker='o')
    
    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 = pylab.annotate(k, xy=(x2,y2), textcoords="offset points", xytext=(0, 0))
        #annotation = pylab.annotate(k, xy = (x2, y2), xytext = (-15, 15), 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'))
        
        LABELS_MAP[k][3] = annotation
                 
    AXES.set_xlabel('X='+str(dims[0]))
    AXES.set_ylabel('Y='+str(dims[1]))
    AXES.set_zlabel('Z='+str(dims[2]))
    
    global CALLBACK_ADDED
    if not CALLBACK_ADDED:
        FIG.canvas.mpl_connect('button_release_event', update_position)
        #FIG.canvas.mpl_connect('motion_notify_event', update_position)
        CALLBACK_ADDED = True
        
    plt.show()
    plt.draw()
	def distance(point, event):
		"""Return distance between mouse position and given data point
		Args:
			point (np.array): np.array of shape (3,), with x,y,z in data coords
			event (MouseEvent): mouse event (which contains mouse position in .x and .xdata)
		Returns:
			distance (np.float64): distance (in screen coords) between mouse pos and data point
		"""
		assert point.shape == (3,), "distance: point.shape is wrong: %s, must be (3,)" % point.shape
		# Project 3d data space to 2d data space
		x2, y2, _ = proj3d.proj_transform(point[0], point[1], point[2], plt.gca().get_proj())
		# Convert 2d data space to 2d screen space
		x3, y3 = ax.transData.transform((x2, y2))
		return np.sqrt ((x3 - event.x)**2 + (y3 - event.y)**2)
Exemple #26
0
def _test_proj_draw_axes(M, s=1, *args, **kwargs):
    xs = [0, s, 0, 0]
    ys = [0, 0, s, 0]
    zs = [0, 0, 0, s]
    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)
    o, ax, ay, az = zip(txs, tys)
    lines = [(o, ax), (o, ay), (o, az)]

    fig, ax = plt.subplots(*args, **kwargs)
    linec = LineCollection(lines)
    ax.add_collection(linec)
    for x, y, t in zip(txs, tys, ['o', 'x', 'y', 'z']):
        ax.text(x, y, t)

    return fig, ax
Exemple #27
0
def annotate_point(figure, axes, x, y, z, color):
    xp1, yp1, _ = proj3d.proj_transform(x, y, z, axes.get_proj())
    label = axes.annotate(
        '{:.5g}'.format(z), xy=(xp1, yp1), xytext = (-20, 40),
        textcoords = 'offset points', ha = 'right', va = 'bottom',
        bbox = dict(boxstyle='round,pad=0.5', fc=color, alpha=0.5),
        arrowprops = dict(arrowstyle='->', connectionstyle='arc3,rad=0',
                          color=color))

    def update_position(_):
        xp2, yp2, _ = proj3d.proj_transform(x, y, z, axes.get_proj())
        label.xy = xp2, yp2
        label.update_positions(figure.canvas.renderer)
        figure.canvas.draw()
    figure.canvas.mpl_connect('button_release_event', update_position)
Exemple #28
0
    def draw(self, renderer, rasterized=True):
        """
        Drawing actually happens here
        """
        # Draws only when the dragging finished
        if self.leftdown:
            return
        xs3d, ys3d, zs3d = self._verts3d
        for i in xrange(len(xs3d)):
            xs, ys, _ = proj3d.proj_transform(xs3d[i], ys3d[i], zs3d[i], renderer.M)
            self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
            self.set_color(self.colors[i])
            FancyArrowPatch.draw(self, renderer)

        self.leftdown = False
Exemple #29
0
def test_proj_axes_cube():
    M = _test_proj_make_M()

    ts = '0 1 2 3 0 4 5 6 7 4'.split()
    xs = np.array([0, 1, 1, 0, 0, 0, 1, 1, 0, 0]) * 300.0
    ys = np.array([0, 0, 1, 1, 0, 0, 0, 1, 1, 0]) * 300.0
    zs = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]) * 300.0

    txs, tys, tzs = proj3d.proj_transform(xs, ys, zs, M)

    fig, ax = _test_proj_draw_axes(M, s=400)

    ax.scatter(txs, tys, c=tzs)
    ax.plot(txs, tys, c='r')
    for x, y, t in zip(txs, tys, ts):
        ax.text(x, y, t)

    ax.set_xlim(-0.2, 0.2)
    ax.set_ylim(-0.2, 0.2)
    def annotatePlot(X, index):
        """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()
        # 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())
        annotatePlot.label = plt.annotate("index: %d" % index,
            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'))
        fig.canvas.draw()
Exemple #31
0
    def plot_throttle_table(self, create_fit_line=False, referencepoint=[], neighbors=[], MakeLabels=False,trajectory_mdot=[],trajectory_thrust=[],trajectory_power=[]):
        import matplotlib        
        from mpl_toolkits.mplot3d import Axes3D
        from mpl_toolkits.mplot3d import proj3d
        PPUpower = []
        Isp = []
        Thrust = []
        Voltage = []
        Mdot = []
        PointLabels = []
        Efficiency = []
        Current = []
        ScaledCurrent = []

        for setting in self.ThrottleSettings:
            if not (referencepoint == setting or setting in neighbors):
                PPUpower.append(setting.ThrusterPower / self.PPUefficiency)
                Isp.append(setting.Isp)
                Thrust.append(setting.Thrust)
                Voltage.append(setting.BeamVoltage)
                Mdot.append(setting.Mdot)
                Efficiency.append(setting.efficiency)
            
                Current.append(setting.BeamCurrent)
                ScaledCurrent.append(Efficiency[-1]*Current[-1])
                PointLabels.append(setting.TL)

        ThrottleFigure = matplotlib.pyplot.figure()
        ThrottleFigure.subplots_adjust(left=0.01, right=0.99, bottom=0.01, top=0.99)
        ThrottleAxes = ThrottleFigure.add_subplot(111, projection='3d')
        ThrottleAxes.view_init(elev=90, azim=-90)
        ThrottleAxes.scatter(numpy.array(PPUpower), numpy.array(Mdot), numpy.array(Thrust), color='blue', s=50, alpha=1.0, label='throttle settings')

        if MakeLabels:
            for i, txt in enumerate(PointLabels):
                x2D, y2D, _ = proj3d.proj_transform(PPUpower[i],Mdot[i],Thrust[i], ThrottleAxes.get_proj())
                ThrottleAxes.annotate(PointLabels[i], (x2D,y2D))

        if create_fit_line:
            Voltage_polynomial = numpy.poly1d(numpy.polyfit(PPUpower, Voltage, 4))
            Isp_polynomial = numpy.poly1d(numpy.polyfit(PPUpower, Isp, 4))
            Mdot_polynomial = numpy.poly1d(numpy.polyfit(PPUpower, Mdot, 4))
            Thrust_polynomial = numpy.poly1d(numpy.polyfit(PPUpower, Thrust, 4))
            Current_polynomial = numpy.poly1d(numpy.polyfit(PPUpower, Current, 4))
            powerlinepoints = numpy.linspace(min(PPUpower), max(PPUpower), 100)
            ThrottleAxes.plot(powerlinepoints, Mdot_polynomial(powerlinepoints), Thrust(powerlinepoints))

        if referencepoint:
            ThrottleAxes.scatter(referencepoint.ThrusterPower / self.PPUefficiency, referencepoint.Mdot, referencepoint.Thrust, color='crimson', s=50, alpha=1.0, label='reference throttle setting')
            if MakeLabels:
                x2D, y2D, _ = proj3d.proj_transform(referencepoint.ThrusterPower / self.PPUefficiency, referencepoint.Mdot, referencepoint.Thrust, ThrottleAxes.get_proj())
                ThrottleAxes.annotate(referencepoint.TL, (x2D, y2D))

        if neighbors:
            NPPUpower = []
            NVoltage = []
            NIsp = []
            NThrust = []
            NPointLabels = []
            NMdot = []
            for neighbor in neighbors:
                print(neighbor.TL)
                NPPUpower.append(neighbor.ThrusterPower / self.PPUefficiency)
                NMdot.append(neighbor.Mdot)
                NIsp.append(neighbor.Isp)
                NThrust.append(neighbor.Thrust)
                NVoltage.append(neighbor.BeamVoltage)
                NPointLabels.append(neighbor.TL)
            ThrottleAxes.scatter(numpy.array(NPPUpower), numpy.array(NMdot), numpy.array(NThrust), color='orange', s=50, alpha=1.0, label='neighbors of reference throttle setting')
            if MakeLabels:
                for i, txt in enumerate(NPointLabels):
                    x2D, y2D, _ = proj3d.proj_transform(NPPUpower[i],NMdot[i],NThrust[i], ThrottleAxes.get_proj())
                    ThrottleAxes.annotate(NPointLabels[i], (x2D,y2D))

        if len(trajectory_mdot) and len(trajectory_thrust) and len(trajectory_power):
            ThrottleAxes.scatter(numpy.array(trajectory_power),numpy.array(trajectory_mdot),numpy.array(trajectory_thrust), marker='x',c='black',s=100,alpha=1.0,label='Throttle outputs used in trajectory')
            ThrottleAxes.view_init(elev=0, azim=0)

        ThrottleAxes.set_xlabel('PPU input power (kW)')
        ThrottleAxes.set_ylabel('Mass flow rate (mg/s)')
        ThrottleAxes.set_zlabel('Thrust (mN)')
        ThrottleAxes.set_title(self.FileName)
        leg = ThrottleAxes.legend()
        leg.draggable()

        ThrottleFigure.show()
        
        if create_fit_line:
            return Voltage_polynomial, Thrust_polynomial, Mdot_polynomial, Isp_polynomial
Exemple #32
0
    def pcaSubplot(self, X_r, dim, PCs_round, labels, template_list, dpiVal):
        """
        Get the Principal Component Analysis data for this set of coordinates
        The value of 'dim' specifies the number of dimensions to diplay
        Then plot the PCA data
        """
        # Set some figure parameters
        plt.rcParams['xtick.major.pad'] = '8'
        plt.rcParams['ytick.major.pad'] = '8'

        # Plot either PCA data on 2D or 3D
        if dim == 2:
            fig = plt.figure(figsize=(15, 13), dpi=dpiVal)
            fig.set_facecolor('white')
            fig.canvas.set_window_title("PCA 2D")
            ax = fig.add_subplot(111)

            # Scatter conformations. Designated by circles, colored based on
            # IFP similarity to a defined template
            scat = ax.scatter(X_r[:, 0],
                              X_r[:, 1],
                              s=600,
                              marker="v",
                              color="black")

            # Setting labels for both conformations and templates
            for label, x, y in zip(labels, X_r[:, 0], X_r[:, 1]):
                ax.annotate(label,
                            xy=(x, y + 0.06),
                            fontsize=30,
                            ha='center',
                            va='bottom')

        if dim == 3:
            fig = plt.figure()
            fig.set_facecolor('white')
            fig.canvas.set_window_title("PCA 3D")
            ax = fig.add_subplot(111, projection='3d')

            # Conformations
            scat = Axes3D.scatter(ax,
                                  X_r[:, 0],
                                  X_r[:, 1],
                                  X_r[:, 2],
                                  size=600,
                                  marker="o")

            # Scatter plot labels
            for label, x, y, z in zip(labels, X_r[:, 0], X_r[:, 1], X_r[:, 2]):
                if label != "":
                    x2D, y2D, _ = proj3d.proj_transform(x, y, z, ax.get_proj())
                    ax.annotate(label,
                                xy=(x2D, y2D),
                                fontsize=30,
                                ha='left',
                                va='bottom')

        # Setting axes and labels
        ax.set_xlabel("PC1 ({} %)".format(PCs_round[0]))
        ax.xaxis.label.set_size(25)
        ax.set_ylabel("PC2 ({} %)".format(PCs_round[1]))
        ax.yaxis.label.set_size(25)
        if dim == 3:
            ax.set_zlabel("PC3 ({0} %)".format(PCs_round[2]))
            ax.zaxis.label.set_size(25)
        ax.tick_params(axis="both", which="major", labelsize=25)
 def draw(self, renderer):
     """Starts as 2-d,g ets projected into 3-d"""
     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)
X = np.array(Xt)
Y = np.array(Yt)
Z = np.array(Zt)
max_range = np.array([X.max() - X.min(),
                      Y.max() - Y.min(),
                      Z.max() - Z.min()]).max() / 2.0
mid_x = (X.max() + X.min()) * 0.5
mid_y = (Y.max() + Y.min()) * 0.5
mid_z = (Z.max() + Z.min()) * 0.5
ax2.set_xlim3d(mid_x - max_range, mid_x + max_range)
ax2.set_ylim3d(mid_y - max_range, mid_y + max_range)
ax2.set_zlim3d(mid_z - max_range, mid_z + max_range)

# Create Annotation
ax2.annotate(s=r'$x$',
             xy=tuple(proj3d.proj_transform(*px, M=ax2.get_proj()))[:2],
             fontsize=14,
             bbox={
                 'pad': 8,
                 'fill': None,
                 'edgecolor': 'None'
             },
             va='top',
             ha='left')
ax2.annotate(s=r'$y$',
             xy=tuple(proj3d.proj_transform(*pcbl, M=ax2.get_proj()))[:2],
             fontsize=14,
             bbox={
                 'pad': 8,
                 'fill': None,
                 'edgecolor': 'None'
Exemple #35
0
def plot_bloch_vector(bloch, title=""):
    """Plot a Bloch vector.

    Plot a sphere, axes, the Bloch vector, and its projections onto each axis.
    bloch is a 3-tuple (x, y, z)
    title is a string, the plot title
    """
    # Set arrow lengths
    arlen = 1.3

    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.set_aspect("equal")

    # Plot semi-transparent sphere
    u = np.linspace(0, 2 * np.pi, 100)
    v = np.linspace(0, np.pi, 100)
    x = np.outer(np.cos(u), np.sin(v))
    y = np.outer(np.sin(u), np.sin(v))
    z = np.outer(np.ones(np.size(u)), np.cos(v))
    ax.plot_surface(x, y, z, color="b", alpha=0.1)

    # Plot arrows (axes, Bloch vector, its projections)
    xa = Arrow3D([0, arlen], [0, 0], [0, 0],
                 mutation_scale=20,
                 lw=1,
                 arrowstyle="-|>",
                 color="k")
    ya = Arrow3D([0, 0], [0, arlen], [0, 0],
                 mutation_scale=20,
                 lw=1,
                 arrowstyle="-|>",
                 color="k")
    za = Arrow3D([0, 0], [0, 0], [0, arlen],
                 mutation_scale=20,
                 lw=1,
                 arrowstyle="-|>",
                 color="k")
    a = Arrow3D([0, bloch[0]], [0, bloch[1]], [0, bloch[2]],
                mutation_scale=20,
                lw=2,
                arrowstyle="simple",
                color="k")
    bax = Arrow3D([0, bloch[0]], [0, 0], [0, 0],
                  mutation_scale=20,
                  lw=2,
                  arrowstyle="-",
                  color="r")
    bay = Arrow3D([0, 0], [0, bloch[1]], [0, 0],
                  mutation_scale=20,
                  lw=2,
                  arrowstyle="-",
                  color="g")
    baz = Arrow3D([0, 0], [0, 0], [0, bloch[2]],
                  mutation_scale=20,
                  lw=2,
                  arrowstyle="-",
                  color="b")
    arrowlist = [xa, ya, za, a, bax, bay, baz]
    for arr in arrowlist:
        ax.add_artist(arr)

    # Rotate the view
    ax.view_init(30, 30)

    # Annotate the axes, shifts are ad-hoc for this (30, 30) view
    xp, yp, _ = proj3d.proj_transform(arlen, 0, 0, ax.get_proj())
    plt.annotate("x",
                 xy=(xp, yp),
                 xytext=(-3, -8),
                 textcoords='offset points',
                 ha='right',
                 va='bottom')
    xp, yp, _ = proj3d.proj_transform(0, arlen, 0, ax.get_proj())
    plt.annotate("y",
                 xy=(xp, yp),
                 xytext=(6, -5),
                 textcoords='offset points',
                 ha='right',
                 va='bottom')
    xp, yp, _ = proj3d.proj_transform(0, 0, arlen, ax.get_proj())
    plt.annotate("z",
                 xy=(xp, yp),
                 xytext=(2, 0),
                 textcoords='offset points',
                 ha='right',
                 va='bottom')

    plt.title(title)
    plt.show()
Exemple #36
0
ax.text(P_0[0],
        P_0[1] - 0.15 * r,
        P_0[2] + 0.035 * r,
        r"$P_0$",
        color='darkblue',
        size=14)  # P_0

ax.text(r * sin(phi_0 + 0.13) * cos(-0.2 * pi),
        r * sin(phi_0 + 0.13) * sin(-0.2 * pi),
        r * cos(phi_0 + 0.13),
        r"$ \theta=\theta_0$",
        color='darkblue',
        size=14)  # theta

x2, y2, _ = proj3d.proj_transform(0, r * sin(pi - 0.2), r * cos(pi - 0.2),
                                  ax.get_proj())
label = pylab.annotate(
    r"$ \phi=0$",
    color='darkblue',
    xy=(x2, y2),
    xytext=(-15, 10),
    size=14,
    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',
                    color='darkblue'))

#Vetores
Exemple #37
0
 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]))
     FancyArrowPatch.draw(self, renderer)
Exemple #38
0
    def plotData(self):
        # Plot the hand position
        self.axisPos.set_title('Hand Position', fontweight='bold', fontsize=16)
        self.axisPos.set_xlabel('x [mm]', fontsize=10)
        self.axisPos.set_ylabel('y [mm]', fontsize=10)
        self.axisPos.set_zlabel('z [mm]', fontsize=10)
        self.axisPos.set_xlim(
            [max(self.handPos[0]) + 5,
             min(self.handPos[0]) - 5])
        self.axisPos.set_ylim(
            [max(self.handPos[1]) + 5,
             min(self.handPos[1]) - 5])
        self.axisPos.set_zlim(
            [min(self.handPos[2]) - 5,
             max(self.handPos[2]) + 5])

        for i in range(0, len(self.handPos[0])):
            if i == 0:
                # Plot the start position
                self.axisPos.scatter(self.handPos[0][i],
                                     self.handPos[1][i],
                                     self.handPos[2][i],
                                     color='yellowgreen',
                                     marker='o',
                                     s=200,
                                     alpha=0.75)
                x2D, y2D, _ = proj3d.proj_transform(self.handPos[0][i],
                                                    self.handPos[1][i],
                                                    self.handPos[2][i],
                                                    self.axisPos.get_proj())
                self.annStart = self.axisPos.annotate(
                    'Start',
                    xy=(x2D, y2D),
                    xytext=(-30, 0),
                    textcoords='offset points',
                    ha='right',
                    va='bottom',
                    bbox=dict(boxstyle='round, pad = 0.5',
                              fc='yellowgreen',
                              alpha=0.65),
                    arrowprops=dict(arrowstyle='->',
                                    connectionstyle='arc3, rad = 0'))
            elif i == len(self.handPos[0]) - 1:
                # Plot the target position
                self.axisPos.scatter(self.handPos[0][i],
                                     self.handPos[1][i],
                                     self.handPos[2][i],
                                     color='gold',
                                     marker='o',
                                     s=200,
                                     alpha=0.75,
                                     label='Target')
                x2D, y2D, _ = proj3d.proj_transform(self.handPos[0][i],
                                                    self.handPos[1][i],
                                                    self.handPos[2][i],
                                                    self.axisPos.get_proj())
                self.annTarget = self.axisPos.annotate(
                    'Target',
                    xy=(x2D, y2D),
                    xytext=(80, 0),
                    textcoords='offset points',
                    ha='right',
                    va='bottom',
                    bbox=dict(boxstyle='round, pad = 0.5',
                              fc='gold',
                              alpha=0.65),
                    arrowprops=dict(arrowstyle='->',
                                    connectionstyle='arc3, rad = 0'))
            else:
                # Plot the remaining trajectory
                self.axisPos.scatter(self.handPos[0][i],
                                     self.handPos[1][i],
                                     self.handPos[2][i],
                                     color='firebrick',
                                     marker='.',
                                     s=170,
                                     alpha=0.50)

        # Plot the hand velocity
        self.axisVel.set_title('Hand Velocity Norm',
                               fontweight='bold',
                               fontsize=16)
        self.axisVel.set_xlabel('Time [s]', fontsize=11)
        self.axisVel.set_ylabel('[mm/s]', fontsize=11)
        self.axisVel.set_xlim(min(self.t), max(self.t))
        self.axisVel.set_ylim(0.0, max(self.handVel) + 5)
        self.axisVel.spines['left'].set_color('teal')
        self.axisVel.spines['left'].set_linewidth(3)
        self.axisVel.plot(self.t,
                          self.handVel,
                          color='teal',
                          linewidth=1.65,
                          label='Vel [mm/s]')

        # ************************** #
        #       FUNCTION: update     #
        # ************************** #
        def update(i):
            # Plot the start position annotation
            oldAnnStart = self.annStart
            x2D, y2D, _ = proj3d.proj_transform(self.handPos[0][0],
                                                self.handPos[1][0],
                                                self.handPos[2][0],
                                                self.axisPos.get_proj())
            self.annStart = self.axisPos.annotate(
                'Start',
                xy=(x2D, y2D),
                xytext=(-30, 0),
                textcoords='offset points',
                ha='right',
                va='bottom',
                bbox=dict(boxstyle='round, pad = 0.5',
                          fc='yellowgreen',
                          alpha=0.65),
                arrowprops=dict(arrowstyle='->',
                                connectionstyle='arc3, rad = 0'))
            oldAnnStart.remove()

            # Plot the target position annotation
            oldAnnTarget = self.annTarget
            l = len(self.handPos[0]) - 1
            x2D, y2D, _ = proj3d.proj_transform(self.handPos[0][l],
                                                self.handPos[1][l],
                                                self.handPos[2][l],
                                                self.axisPos.get_proj())
            self.annTarget = self.axisPos.annotate(
                'Target',
                xy=(x2D, y2D),
                xytext=(80, 0),
                textcoords='offset points',
                ha='right',
                va='bottom',
                bbox=dict(boxstyle='round, pad = 0.5', fc='gold', alpha=0.65),
                arrowprops=dict(arrowstyle='->',
                                connectionstyle='arc3, rad = 0'))
            oldAnnTarget.remove()

        # Updates the annotations of start and target positions, when the view is changed
        a = anim.FuncAnimation(self.fig, update, frames=1000)
        self.handWindow.mainloop()
Exemple #39
0
def main():
    start_time = time.time()

    conn = None
    try:
        # read connection parameters
        params = config()

        # connect to the PostgreSQL server
        print('Connecting to the PostgreSQL database...')
        conn = psycopg2.connect(**params)

        # create a cursor
        cur = conn.cursor()

        ax = plt.axes()

        cur.execute(
            'SELECT "Tower Density (Km2 per Cell)" FROM public.altice_statsmunicipals'
        )
        fetched = cur.fetchall()
        towerDensities = parseDBColumns(fetched, 0, float)

        print("Statistics of Tower Density Values")
        plt.title("Different Tower Density Values for the Various Municipals")
        plt.xlabel("municipal")
        plt.ylabel("Tower Density (Km2 per Cell)")
        plt.plot(towerDensities, 'gx')
        plt.grid(True)
        plt.show()

        print(stats(towerDensities))
        # ----------------------------------------------------------------------------------------------
        classes = [0, 1, 2, 4, 8, 16, 32, 64, 128, 277]
        classNames = [
            "[0 to 1[", "]1 to 2]", "]2 to 4]", "]4 to 8]", "]8, 16]",
            "]16, 32]", "]32, 64]", "]64, 128]", "]128, 277]"
        ]
        out = pd.cut(list(towerDensities), bins=classes, include_lowest=True)
        ax = out.value_counts().plot.bar(rot=0,
                                         color="g",
                                         figsize=(30, 20),
                                         fontsize=25)
        ax.set_xticklabels(classNames)
        ax.margins(y=0.0, tight=True)
        plt.ylim(0, 80)
        plt.grid(True)
        rects = ax.patches

        values = []

        allInfo = str(pd.Categorical.value_counts(out))
        lines = allInfo.split("\n")

        for i in range(len(lines) - 1):
            line = lines[i].split("]")
            values.append(int(line[1].strip()))

        for rect, label in zip(rects, values):
            height = rect.get_height()
            ax.text(rect.get_x() + rect.get_width() / 2,
                    height,
                    round(label, 2),
                    ha='center',
                    va='bottom',
                    fontsize=19)

        plt.title("Different Tower Density Values for the Various Municipals",
                  fontsize=40)
        plt.ylabel("Number of Users", fontsize=30)
        plt.xlabel("Range of Travells Distance (in Kms)", fontsize=30)
        plt.grid(True)
        plt.show()
        # ----------------------------------------------------------------------------------------------

        cur.execute(
            'SELECT "Average Calls Per Day", "Average of Days Until Call","Nº Active Days" FROM public.altice_region_users_characterization'
        )
        fetched = cur.fetchall()

        averageCallsPerDay = parseDBColumns(fetched, 0, float)
        regularity = parseDBColumns(fetched, 1, float)
        numberActiveDays = parseDBColumns(fetched, 2, int)

        print("Statistics of Average Calls Per Day Values")
        plt.title(
            "Different Average Calls Per Day Values for the Various User")
        plt.xlabel("user")
        plt.ylabel("Average Calls Per Day")
        plt.plot(averageCallsPerDay, 'bx')
        plt.grid(True)
        plt.show()

        print(stats(averageCallsPerDay))

        # ----------------------------------------------------------------------------------------------
        classes = [0, 1, 2, 4, 8, 16, 32, 64, 128, 236]
        classNames = [
            "[0 to 1[", "]1 to 2]", "]2 to 4]", "]4 to 8]", "]8, 16]",
            "]16, 32]", "]32, 64]", "]64, 128]", "]128, 236]"
        ]
        out = pd.cut(list(averageCallsPerDay),
                     bins=classes,
                     include_lowest=True)
        ax = out.value_counts().plot.bar(rot=0,
                                         color="b",
                                         figsize=(30, 20),
                                         fontsize=25)
        ax.set_xticklabels(classNames)
        ax.margins(y=0.0, tight=True)
        plt.ylim(0, 190000)
        plt.grid(True)
        rects = ax.patches

        values = []

        allInfo = str(pd.Categorical.value_counts(out))
        lines = allInfo.split("\n")

        for i in range(len(lines) - 1):
            line = lines[i].split("]")
            values.append(int(line[1].strip()))

        for rect, label in zip(rects, values):
            height = rect.get_height()
            ax.text(rect.get_x() + rect.get_width() / 2,
                    height,
                    round(label, 2),
                    ha='center',
                    va='bottom',
                    fontsize=19)

        plt.title(
            "Different Average Calls Per Day Values for the Various User",
            fontsize=40)
        plt.ylabel("user", fontsize=30)
        plt.xlabel("Average Calls Per Day", fontsize=30)
        plt.grid(True)
        plt.show()
        # ----------------------------------------------------------------------------------------------

        print("Statistics of Average of Days Until Call Values")
        plt.title(
            "Different Average of Days Until Call Values for the Various Users"
        )
        plt.xlabel("user")
        plt.ylabel("Average of Days Until Call")
        plt.plot(regularity, 'rx')
        plt.grid(True)
        plt.show()
        print(stats(regularity))

        # ----------------------------------------------------------------------------------------------
        classes = [0, 1, 2, 4, 8, 16, 32, 64, 128, 226]
        classNames = [
            "[0 to 1[", "]1 to 2]", "]2 to 4]", "]4 to 8]", "]8, 16]",
            "]16, 32]", "]32, 64]", "]64, 128]", "]128, 226]"
        ]
        out = pd.cut(list(regularity), bins=classes, include_lowest=True)
        ax = out.value_counts().plot.bar(rot=0,
                                         color="r",
                                         figsize=(30, 20),
                                         fontsize=25)
        ax.set_xticklabels(classNames)
        ax.margins(y=0.0, tight=True)
        plt.ylim(0, 250000)
        plt.grid(True)
        rects = ax.patches

        values = []

        allInfo = str(pd.Categorical.value_counts(out))
        lines = allInfo.split("\n")

        for i in range(len(lines) - 1):
            line = lines[i].split("]")
            values.append(int(line[1].strip()))

        for rect, label in zip(rects, values):
            height = rect.get_height()
            ax.text(rect.get_x() + rect.get_width() / 2,
                    height,
                    round(label, 2),
                    ha='center',
                    va='bottom',
                    fontsize=19)

        plt.title(
            "Different Average of Days Until Call Values for the Various Users",
            fontsize=40)
        plt.ylabel("user", fontsize=30)
        plt.xlabel("Average of Days Until Call", fontsize=30)
        plt.grid(True)
        plt.show()
        # ----------------------------------------------------------------------------------------------

        print("Statistics of Nº Active Days Values Values")
        plt.title("Different Nº Active Days Values for the Various Users")
        plt.xlabel("user")
        plt.ylabel("Nº Active Days")
        plt.plot(numberActiveDays, 'yx')
        plt.grid(True)
        plt.show()
        print(stats(numberActiveDays))

        # ----------------------------------------------------------------------------------------------
        classes = [0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 405]
        classNames = [
            "[0 to 1[", "]1 to 2]", "]2 to 4]", "]4 to 8]", "]8, 16]",
            "]16, 32]", "]32, 64]", "]64, 128]", "]128, 256]", "]256, 405]"
        ]
        out = pd.cut(list(numberActiveDays), bins=classes, include_lowest=True)
        ax = out.value_counts().plot.bar(rot=0,
                                         color="y",
                                         figsize=(30, 20),
                                         fontsize=25)
        ax.set_xticklabels(classNames)
        ax.margins(y=0.0, tight=True)
        plt.ylim(0, 160000)
        plt.grid(True)
        rects = ax.patches

        values = []

        allInfo = str(pd.Categorical.value_counts(out))
        lines = allInfo.split("\n")

        for i in range(len(lines) - 1):
            line = lines[i].split("]")
            values.append(int(line[1].strip()))

        for rect, label in zip(rects, values):
            height = rect.get_height()
            ax.text(rect.get_x() + rect.get_width() / 2,
                    height,
                    round(label, 2),
                    ha='center',
                    va='bottom',
                    fontsize=19)

        plt.title("Different Nº Active Days Values for the Various Users",
                  fontsize=40)
        plt.ylabel("user", fontsize=30)
        plt.xlabel("Nº Active Days", fontsize=30)
        plt.grid(True)
        plt.show()

        # --------------------------------------------------------
        cur.execute('SELECT * FROM public.altice_experiment5')
        fetched = cur.fetchall()

        regularity = parseDBColumns(fetched, 0, float)
        averageCalls = parseDBColumns(fetched, 1, float)
        numberDays = parseDBColumns(fetched, 2, float)

        fig = plt.figure(figsize=(16, 12))
        plt.subplots_adjust(left=0,
                            bottom=0,
                            right=1,
                            top=1,
                            wspace=0,
                            hspace=0)
        ax = fig.add_subplot(111, projection='3d')

        theta = np.linspace(-4 * np.pi, 4 * np.pi, 100)
        z = np.linspace(-2, 2, 100)
        r = z**2 + 1
        x = 25 * r * np.sin(theta)
        y = 350 * r * np.cos(theta)
        plt.rcParams['agg.path.chunksize'] = 10000
        print("Drawing the Chart...")

        # ran
        plt.grid(True)
        ax.set_xlim(-1, 75)
        ax.set_ylim(-1, 100)
        ax.set_zlim(-1, 400)
        plt.gca().invert_xaxis()

        ax.plot(averageCalls, regularity, numberDays, "gx")
        ax.set_xlabel('Call Activity Every x Days', fontsize=18, labelpad=14)
        ax.set_ylabel('Average Calls Per Day', fontsize=18, labelpad=14)
        ax.set_zlabel('Nº of Active Days', fontsize=18, labelpad=14)

        f = lambda x, y, z: proj3d.proj_transform(x, y, z, ax.get_proj())[:2]
        ax.legend(loc="upper left",
                  bbox_transform=ax.transData,
                  prop={'size': 13})

        plt.show()

        # --------------------------------------------------------
        cur.execute('SELECT * FROM public.altice_experiment_3_1')
        fetched = cur.fetchall()
        numberDays = parseDBColumns(fetched, 0, float)
        numberDays_questao1 = [1] * len(numberDays)

        numberDays_racioHome = parseDBColumns(fetched, 1, float)
        numberDays_racioWorkplace = parseDBColumns(fetched, 2, float)
        numberDays_racioHome_Workplace = parseDBColumns(fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_3_2')
        fetched = cur.fetchall()

        numberDays_questao2 = [2] * len(numberDays)
        numberDays_racioHome_Morning = parseDBColumns(fetched, 1, float)
        numberDays_racioWorkplace_Morning = parseDBColumns(fetched, 2, float)
        numberDays_racioHome_Workplace_Morning = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_3_3')
        fetched = cur.fetchall()

        numberDays_questao3 = [3] * len(numberDays)
        numberDays_racioHome_Evening = parseDBColumns(fetched, 1, float)
        numberDays_racioWorkplace_Evening = parseDBColumns(fetched, 2, float)
        numberDays_racioHome_Workplace_Evening = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_3_4')
        fetched = cur.fetchall()

        numberDays_questao4 = [4] * len(numberDays)
        numberDays_racioH_W = parseDBColumns(fetched, 1, float)
        numberDays_racioW_H = parseDBColumns(fetched, 2, float)
        numberDays_racioH_W_or_W_H = parseDBColumns(fetched, 3, float)
        numberDays_racioH_W_and_W_H = parseDBColumns(fetched, 4, float)

        cur.execute('SELECT * FROM public.altice_experiment_3_5')
        fetched = cur.fetchall()

        numberDays_questao5 = [5] * len(numberDays)
        numberDays_racioWeekdays = parseDBColumns(fetched, 1, float)

        fig = plt.figure(figsize=(12, 8))
        ax = plt.axes()

        plt.xlabel("Number of Days", fontsize=18)
        plt.ylabel("Percentage of Users", fontsize=18)
        ax.set_xlim(-1, 420)
        ax.set_ylim(-1, 100)
        plt.xticks(np.arange(min(numberDays) - 1, 420, 20), fontsize=14)
        plt.yticks(np.arange(0, 100, 5), fontsize=14)

        ax.plot(numberDays,
                numberDays_racioWeekdays,
                color="#663300",
                linewidth=4,
                label="Call Activity on Weekdays")

        ax.plot(numberDays,
                numberDays_racioHome_Workplace,
                'y',
                linewidth=4,
                label="Indentified Home and Workplace")

        f = lambda x, y, z: proj3d.proj_transform(x, y, z, ax.get_proj())[:2]
        ax.legend(loc="upper right",
                  bbox_transform=ax.transData,
                  prop={'size': 14})

        plt.grid(True)
        plt.show()

        # --------------------------------------------------------
        cur.execute('SELECT * FROM public.altice_experiment_2_1')
        fetched = cur.fetchall()
        regularity = parseDBColumns(fetched, 0, float)
        regularity_questao1 = [1] * len(regularity)

        regularity_racioHome = parseDBColumns(fetched, 1, float)
        regularity_racioWorkplace = parseDBColumns(fetched, 2, float)
        regularity_racioHome_Workplace = parseDBColumns(fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_2_2')
        fetched = cur.fetchall()

        regularity_questao2 = [2] * len(regularity)
        regularity_racioHome_Morning = parseDBColumns(fetched, 1, float)
        regularity_racioWorkplace_Morning = parseDBColumns(fetched, 2, float)
        regularity_racioHome_Workplace_Morning = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_2_3')
        fetched = cur.fetchall()

        regularity_questao3 = [3] * len(regularity)
        regularity_racioHome_Evening = parseDBColumns(fetched, 1, float)
        regularity_racioWorkplace_Evening = parseDBColumns(fetched, 2, float)
        regularity_racioHome_Workplace_Evening = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_2_4')
        fetched = cur.fetchall()

        regularity_questao4 = [4] * len(regularity)
        regularity_racioH_W = parseDBColumns(fetched, 1, float)
        regularity_racioW_H = parseDBColumns(fetched, 2, float)
        regularity_racioH_W_or_W_H = parseDBColumns(fetched, 3, float)
        regularity_racioH_W_and_W_H = parseDBColumns(fetched, 4, float)

        cur.execute('SELECT * FROM public.altice_experiment_2_5')
        fetched = cur.fetchall()

        regularity_questao5 = [5] * len(regularity)
        regularity_racioWeekdays = parseDBColumns(fetched, 1, float)

        fig = plt.figure(figsize=(14, 10))
        ax = plt.axes()

        plt.xlabel("Regularity (Call Activity in Every x Days)", fontsize=18)
        plt.ylabel("Percentage of Users", fontsize=18)
        ax.set_xlim(-1, 210)
        ax.set_ylim(-1, 100)
        # plt.xticks(np.arange(min(regularity)-1, 210, 10), fontsize=14)
        # plt.yticks(np.arange(0, 100, 2.5), fontsize=14)
        ax.plot(regularity[:-42],
                regularity_racioWeekdays[:-42],
                "k",
                linewidth=3,
                label="Call Activity on Weekdays")

        ax.plot(regularity[:-42],
                regularity_racioHome_Workplace[:-42],
                'r',
                linewidth=3,
                label="Indentified Home and Workplace")

        ax.plot(regularity[:-42],
                regularity_racioHome_Workplace_Morning[:-42],
                'k',
                linewidth=3,
                label="Activity at Home and Workplace in the Morning")

        ax.plot(regularity[:-42],
                regularity_racioHome_Workplace_Evening[:-42],
                'b',
                linewidth=3,
                label="Activity at Home and Workplace in the Morning")

        ax.plot(regularity[:-42],
                regularity_racioH_W_or_W_H[:-42],
                'g',
                linewidth=3,
                label="Call Activity During Home->Work or Vice-Versa")
        ax.plot(regularity[:-42],
                regularity_racioH_W_and_W_H[:-42],
                'c',
                linewidth=3,
                label="Call Activity During Home->to Work and Vice-Versa")

        ax.legend(loc="right",
                  bbox_transform=ax.transData,
                  fontsize=14,
                  labelspacing=2,
                  prop={'size': 14})

        plt.grid(True)
        plt.show()

        stats1 = stats(regularity_racioWeekdays[:-42])
        stats2 = stats(regularity_racioHome_Workplace[:-42])
        stats3 = stats(regularity_racioHome_Workplace_Morning[:-42])
        stats4 = stats(regularity_racioHome_Workplace_Evening[:-42])
        stats5 = stats(regularity_racioH_W_or_W_H[:-42])
        stats6 = stats(regularity_racioH_W_and_W_H[:-42])

        res1 = next(x for x, val in enumerate(regularity_racioWeekdays[:-42])
                    if val < stats1["mean"])
        res2 = next(
            x for x, val in enumerate(regularity_racioHome_Workplace[:-42])
            if val < stats2["mean"])
        res3 = next(x for x, val in enumerate(
            regularity_racioHome_Workplace_Morning[:-42])
                    if val < stats3["mean"])
        res4 = next(x for x, val in enumerate(
            regularity_racioHome_Workplace_Evening[:-42])
                    if val < stats4["mean"])
        res5 = next(x for x, val in enumerate(regularity_racioH_W_or_W_H[:-42])
                    if val < stats5["mean"])
        res6 = next(x
                    for x, val in enumerate(regularity_racioH_W_and_W_H[:-42])
                    if val < stats6["mean"])

        print(regularity[res1])
        print(regularity[res2])
        print(regularity[res3])
        print(regularity[res4])
        print(regularity[res5])
        print(stats5["mean"])
        print(regularity[res6])
        print(stats6["mean"])
        print(regularity)

        # --------------------------------------------------------
        cur.execute('SELECT * FROM public.altice_experiment_1_1')
        fetched = cur.fetchall()
        averageCalls = parseDBColumns(fetched, 0, float)

        averageCalls_racioHome = parseDBColumns(fetched, 1, float)
        averageCalls_racioWorkplace = parseDBColumns(fetched, 2, float)
        averageCalls_racioHome_Workplace = parseDBColumns(fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_1_2')
        fetched = cur.fetchall()

        averageCalls_racioHome_Morning = parseDBColumns(fetched, 1, float)
        averageCalls_racioWorkplace_Morning = parseDBColumns(fetched, 2, float)
        averageCalls_racioHome_Workplace_Morning = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.altice_experiment_1_3')
        fetched = cur.fetchall()

        averageCalls_racioHome_Evening = parseDBColumns(fetched, 1, float)
        averageCalls_racioWorkplace_Evening = parseDBColumns(fetched, 2, float)
        averageCalls_racioHome_Workplace_Evening = parseDBColumns(
            fetched, 3, float)

        cur.execute('SELECT * FROM public.experiment_1_4')
        fetched = cur.fetchall()

        averageCalls_racioH_W = parseDBColumns(fetched, 1, float)
        averageCalls_racioW_H = parseDBColumns(fetched, 2, float)
        averageCalls_racioH_W_or_W_H = parseDBColumns(fetched, 3, float)
        averageCalls_racioH_W_and_W_H = parseDBColumns(fetched, 4, float)

        cur.execute('SELECT * FROM public.altice_experiment_1_5')
        fetched = cur.fetchall()

        averageCalls_racioWeekdays = parseDBColumns(fetched, 1, float)

        fig = plt.figure(figsize=(12, 8))
        ax = plt.axes()

        plt.xlabel("Average Number of CallsMade/Received Per Day", fontsize=18)
        plt.ylabel("Percentage of Users", fontsize=18)
        ax.set_xlim(-1, 42)
        ax.set_ylim(-1, 100)
        plt.xticks(np.arange(min(averageCalls), 42, 2), fontsize=14)
        plt.yticks(np.arange(0, 100, 5), fontsize=14)
        ax.plot(averageCalls[:400],
                averageCalls_racioWeekdays[:400],
                color='#000000',
                linewidth=3,
                label="Call Activity on Weekdays")

        ax.plot(averageCalls[:400],
                averageCalls_racioHome_Workplace[:400],
                color='#003300',
                linewidth=3,
                label="Indentified Home and Workplace")

        ax.plot(averageCalls[:400],
                averageCalls_racioHome_Workplace_Morning[:400],
                color='#ffb3b3',
                linewidth=3,
                label="Activity at Home and Workplace in the Morning")

        ax.plot(averageCalls[:400],
                averageCalls_racioHome_Workplace_Evening[:400],
                color='#ff1a1a',
                linewidth=3,
                label="Activity at Home and Workplace in the Evening")

        ax.plot(averageCalls[:400],
                averageCalls_racioH_W_or_W_H[:400],
                color='#ff6600',
                linewidth=3,
                label="Call Activity During Home->Work or Vice-Versa")
        ax.plot(averageCalls[:400],
                averageCalls_racioH_W_and_W_H[:400],
                color='#009973',
                linewidth=3,
                label="Call Activity During Home->to Work and Vice-Versa")

        plt.grid(True)
        plt.show()

        stats1 = stats(averageCalls_racioWeekdays[:400])
        stats2 = stats(averageCalls_racioHome_Workplace[:400])
        stats3 = stats(averageCalls_racioHome_Workplace_Morning[:400])
        stats4 = stats(averageCalls_racioHome_Workplace_Evening[:400])
        stats5 = stats(averageCalls_racioH_W_or_W_H[:400])
        stats6 = stats(averageCalls_racioH_W_and_W_H[:400])

        res1 = next(x for x, val in enumerate(averageCalls_racioWeekdays[:400])
                    if val > stats1["mean"])
        res2 = next(
            x for x, val in enumerate(averageCalls_racioHome_Workplace[:400])
            if val > stats2["mean"])
        res3 = next(x for x, val in enumerate(
            averageCalls_racioHome_Workplace_Morning[:400])
                    if val > stats3["mean"])
        res4 = next(x for x, val in enumerate(
            averageCalls_racioHome_Workplace_Evening[:400])
                    if val > stats4["mean"])
        res5 = next(x
                    for x, val in enumerate(averageCalls_racioH_W_or_W_H[:400])
                    if val > stats5["mean"])
        res6 = next(
            x for x, val in enumerate(averageCalls_racioH_W_and_W_H[:400])
            if val > stats6["mean"])

        print(averageCalls[res1])
        print(averageCalls[res2])
        print(averageCalls[res3])
        print(averageCalls[res4])
        print(averageCalls[res5])
        print(stats5["mean"])
        print(averageCalls[res6])
        print(stats6["mean"])

        # EXPERIMENT 5 --------------------------------------------------------------------------------------------------------------------

        cur.execute('SELECT * FROM public.altice_experiment5')
        fetched = cur.fetchall()

        regularity = parseDBColumns(fetched, 0, float)
        averageCalls = parseDBColumns(fetched, 1, float)
        numberDays = parseDBColumns(fetched, 2, float)

        fig = plt.figure(figsize=(16, 12))
        plt.subplots_adjust(left=0,
                            bottom=0,
                            right=1,
                            top=1,
                            wspace=0,
                            hspace=0)
        ax = fig.add_subplot(111, projection='3d')

        plt.rcParams['agg.path.chunksize'] = 10000
        print("Drawing the Chart...")

        ax.set_xlim(0, 400)
        ax.set_ylim(-1, 210)
        ax.set_zlim(-1, 45)
        plt.gca().invert_xaxis()

        ax.plot(numberDays, regularity, averageCalls, '*')
        ax.set_xlabel('Nº of Active Days', fontsize=18, labelpad=14)
        ax.set_ylabel('Regularity', fontsize=18, labelpad=14)
        ax.set_zlabel('Average Number of calls', fontsize=18, labelpad=14)

        f = lambda x, y, z: proj3d.proj_transform(x, y, z, ax.get_proj())[:2]
        ax.legend(loc="upper left",
                  bbox_transform=ax.transData,
                  prop={'size': 13})

        plt.show()

        # EXPERIMENT 4_2

        cur.execute('SELECT * FROM public.altice_experiment_4_2')
        fetched = cur.fetchall()

        towerdensities = parseDBColumns(fetched, 1, float)
        racioH_W = parseDBColumns(fetched, 2, float)
        racioW_H = parseDBColumns(fetched, 3, float)
        racioH_W_or_W_H = parseDBColumns(fetched, 4, float)
        racioH_W_and_W_H = parseDBColumns(fetched, 5, float)

        fig = plt.figure(figsize=(12, 8))
        ax = plt.axes()

        plt.xlabel("Tower Density (Km2 per cell)")
        plt.ylabel("Percentage of Users")

        plt.xticks(np.arange(0, 607, 20))
        plt.yticks(np.arange(0, 100, 10))
        ax.plot(towerdensities,
                racioH_W,
                "*",
                label="Intermediate Towers Home->Work")
        ax.plot(towerdensities,
                racioW_H,
                "*",
                label="Intermediate Towers Work->Home")
        ax.plot(towerdensities,
                racioH_W_or_W_H,
                "*",
                label="Intermediate Towers Home->Work or Work->Home")
        ax.plot(towerdensities,
                racioH_W_and_W_H,
                "*",
                label="Intermediate Towers Home->Work and Work->Home")

        f = lambda x, y, z: proj3d.proj_transform(x, y, z, ax.get_proj())[:2]
        ax.legend(loc="upper right",
                  bbox_transform=ax.transData,
                  prop={'size': 13})

        plt.grid(True)
        plt.show()

        fig = plt.figure(figsize=(16, 12))
        plt.subplots_adjust(left=0,
                            bottom=0,
                            right=1,
                            top=1,
                            wspace=0,
                            hspace=0)
        ax = fig.add_subplot(111, projection='3d')

        plt.rcParams['agg.path.chunksize'] = 10000
        print("Drawing the Chart...")

        ax.set_yticks(np.arange(0, 600, 40))
        plt.gca().invert_yaxis()
        plt.xticks(np.arange(4),
                   ('Home->Work', 'Work->Home', 'Home->Work \nor Work->Home',
                    'Home->Work \nand Work->Home'),
                   fontsize=14)
        ax.plot([0] * len(towerdensities), towerdensities, racioH_W, '*')
        ax.plot([1] * len(towerdensities), towerdensities, racioW_H, '*')
        ax.plot([2] * len(towerdensities), towerdensities, racioH_W_or_W_H,
                '*')
        ax.plot([3] * len(towerdensities), towerdensities, racioH_W_and_W_H,
                '*')

        ax.set_ylabel('Tower Density (Km2 Per Cell)', fontsize=18, labelpad=14)
        ax.set_zlabel('Percentage of Users', fontsize=18, labelpad=14)

        f = lambda x, y, z: proj3d.proj_transform(x, y, z, ax.get_proj())[:2]
        ax.legend(loc="upper left",
                  bbox_transform=ax.transData,
                  prop={'size': 13})

        plt.show()

        elapsed_time = time.time() - start_time
        print("EXECUTION TIME: " + str(elapsed_time / 60) + " MINUTES")
        # close the communication with the PostgreSQL
        cur.close()
    except (Exception, psycopg2.DatabaseError) as error:
        print(error)
    finally:
        if conn is not None:
            conn.close()
            print('Database connection closed.')
Exemple #40
0
ax.set_yticks([])
ax._axis3don = False

box = ax.get_position()
# create color bar
axColor = plt.axes(
    [box.x0 * 1.00 + box.width * 1.00, box.y0, 0.01, box.height])

cb = plt.colorbar(sm, cax=axColor)
cb.set_label("Air density (kg/m^3)")
cb.ax.invert_yaxis()
labels = []
ax.set_xlim(25, 50)
ax.set_ylim(np.min(y), np.max(y))
ax.set_zlim(np.min(z), np.max(z))
x2, y2, _ = proj3d.proj_transform(x, y, z, ax.get_proj())

print x2

ax.scatter(x, y, z, t, cmap=green_red, lw=0, s=1)
for i in range(1, np.size(z), 500):
    name = "Altitude: " + np.str(z[i]) + " m\n" + "Distance: " + np.str(
        dist[i]) + " m"
    label = ax.annotate(name,
                        xy=(x2[i], y2[i]),
                        xytext=(-150.0, -10.0),
                        textcoords='offset points',
                        fontsize=10,
                        arrowprops=dict(arrowstyle="->",
                                        connectionstyle="arc3,rad=0"))
    labels.append(label)
Exemple #41
0
 def dataspace(point):
     if point.shape == (3,):
         x2, y2, _ = proj3d.proj_transform(point[0], point[1], point[2], plt.gca().get_proj())
     else:
         x2, y2 = point[0], point[1]
     return x2, y2
           zorder=10)  # pontos O-Q-R-S

plt.plot(x_11, y_11, z_11, color="darkblue", alpha=0.8, zorder=0)
plt.plot(x_21, y_21, z_21, color="darkblue", alpha=0.8, zorder=0)
plt.plot(x_12, y_12, z_12, color="darkblue", alpha=0.8, zorder=0)
plt.plot(x_22, y_22, z_22, color="darkblue", alpha=0.8, zorder=0)
plt.plot(xx_21, yy_21, zz_21, color="darkblue", alpha=0.2, zorder=0, ls='--')
plt.plot(xx_22, yy_22, zz_22, color="darkblue", alpha=0.2, zorder=0, ls='--')

# #Setas
step_arrow = 0.007
# O Q
x_seta, y_seta, z_seta = [
    0.5 * (Q_0[0] + O_0[0]), 0.5 * (Q_0[1] + O_0[1]), 0.5 * (Q_0[2] + O_0[2])
]
x2, y2, _ = proj3d.proj_transform(x_seta, y_seta, z_seta, ax.get_proj())
plt.arrow(x2,
          y2,
          0.05 * step_arrow,
          -0.5 * step_arrow,
          shape='full',
          length_includes_head=True,
          head_width=.0035,
          color='darkblue',
          zorder=0,
          alpha=0.8)
# Q R
x_seta, y_seta, z_seta = [
    0.5 * (Q_0[0] + R_0[0]), 0.5 * (Q_0[1] + R_0[1]), 0.5 * (Q_0[2] + R_0[2])
]
x2, y2, _ = proj3d.proj_transform(x_seta, y_seta, z_seta, ax.get_proj())
 def draw(self, renderer):
     xp, yp, zp = self._v
     x, y, z = proj3d.proj_transform(xp, yp, zp, renderer.M)
     self.set_positions((x[0], y[0]), (x[1], y[1]))
     FancyArrowPatch.draw(self, renderer)
Exemple #44
0
    def LabelEvent(self, GraphicsObject, PlotOptions, labelString = None):        
        import matplotlib
        import matplotlib.pyplot as plt
        from mpl_toolkits.mplot3d import Axes3D
        from mpl_toolkits.mplot3d import proj3d

        description = ''
        if labelString == None:
            if PlotOptions.ShowTextDescriptions:
                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 = 'rendezvous'
                elif EventTypeFormatted == 'begin_spiral':
                    EventTypeFormatted = 'begin spiral'
                elif EventTypeFormatted == 'end_spiral':
                    EventTypeFormatted = 'end spiral'
                elif EventTypeFormatted == 'mission_end':
                    EventTypeFormatted = 'end of mission'
                elif EventTypeFormatted == 'momtransfer':
                    EventTypeFormatted = 'momentum transfer'

                if PlotOptions.NumberEventLabels:
                    EventNumber = 'Event # ' + str(PlotOptions.EventCounter) + ':\n'
                else:
                    EventNumber = ''

                description = EventNumber + EventTypeFormatted.capitalize() + '\n' + self.Location
        
                if PlotOptions.DisplayEventDates:
                    description += '\n' + self.GregorianDate
        
                if PlotOptions.DisplayEventSpecs:
                    #for launches a C3 and DLA are needed
                    if self.EventType == 'launch':
                        description += '\n$C_3$ = ' + "{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' and self.C3 > 0.0:
                        description += '\n$C_3$ = ' + "{0:.3f}".format(self.C3) + ' $km^2/s^2$'

                    #for other events, output v-infinity and DLA
                    if self.EventType in ['upwr_flyby', 'pwr_flyby', 'intercept', 'interface', 'insertion', 'momtransfer']:
                        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 in ['upwr_flyby', 'pwr_flyby', 'periapse']:
                        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') and self.DVmagorThrottle > 0.0:
                            description += '\n$\Delta v$ = ' + "{0:.3f}".format(self.DVmagorThrottle) + ' $km/s$'

                    #always append the spacecraft Mass
                    if PlotOptions.DisplayEventMass:
                        if self.Mass < 1.0e+5:
                            description += '\nm = ' + "{0:.0f}".format(self.Mass) + ' $kg$'
                        else:
                            description += '\nm = ' + "{0:.4e}".format(self.Mass) + ' $kg$'

                    if PlotOptions.DisplayArrivalPhaseAngle and self.EventType == 'intercept':
                        R = self.SpacecraftState[0:3]
                        V = self.DeltaVorThrustVectorControl
                        r = math.sqrt(R[0]*R[0] + R[1]*R[1] + R[2]*R[2])
                        v = math.sqrt(V[0]*V[0] + V[1]*V[1] + V[2]*V[2])
                        try:
                            PhaseAngle = math.acos(-(R[0]*V[0] + R[1]*V[1] + R[2]*V[2]) / (r * v)) * 180.0 / math.pi
                            description += '\n' + r'$\beta $' + ' = ' + "{0:.1f}".format(PhaseAngle) + ' degrees'
                        except:
                            print("Bad velocity vector while calculating phase angle, event" + str(self.EventNumber))

            else:
                description = str(PlotOptions.EventCounter)
        else:
            description = labelString

        #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.0001):
            x2D, y2D, _ = proj3d.proj_transform(self.SpacecraftState[0],self.SpacecraftState[1],self.SpacecraftState[2], GraphicsObject.get_proj())
            
            if PlotOptions.ShowTextDescriptions:
                self.eventlabel = plt.annotate(description, xycoords = 'data', xy = (x2D, y2D), xytext = (20, (PlotOptions.EventCounter + 20)), textcoords = 'offset points', ha = 'left', va = 'bottom',
                #self.eventlabel = plt.annotate(description, xycoords = 'data', xy = (self.SpacecraftState[0],self.SpacecraftState[1]), xytext = (20, (PlotOptions.EventCounter + 20)), textcoords = 'offset points', ha = 'left', va = 'bottom',
                                               bbox = dict(boxstyle = 'round,pad=0.5', fc = 'white', alpha = 1.0), arrowprops = dict(arrowstyle = '->',
                                               connectionstyle = 'arc3,rad=0'), size=PlotOptions.FontSize, family='serif') # changed to usurp drag-fu
            else:
                self.eventlabel = plt.annotate(description, xycoords = 'data', xy = (x2D, y2D), ha = 'left', va = 'bottom',
                                               bbox = dict(boxstyle = 'round,pad=0.5', fc = 'white', alpha = 1.0), arrowprops = dict(arrowstyle = '->',
                                               connectionstyle = 'arc3,rad=0'), size=PlotOptions.FontSize, family='serif') # changed to usurp drag-fu

            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)

            #update the event counter only if the event is printable
            PlotOptions.EventCounter += 1
Exemple #45
0
    def animate(self, vessel, periapsis, eccentricity, ecc_anom, incl, argPe):
        # Calculate data used in both modes
        pr = vessel.orbit.body.equatorial_radius

        inclination = incl + np.pi
        q = periapsis + pr  # periapsis radius
        a = q / (1 - eccentricity)  # semi major axis
        ap = 2 * a - q  # aperiapsis radius

        theta = np.linspace(0, 2 * np.pi, 181)
        r = (a * (1 - eccentricity ** 2)) / (1 + eccentricity * np.cos(theta))

        true_anom = 2 * np.arctan2(np.sqrt(1 + eccentricity) * np.sin(ecc_anom / 2), np.sqrt(1 - eccentricity) * np.cos(ecc_anom / 2))
        r_vess = (a * (1 - eccentricity ** 2)) / (1 + eccentricity * np.cos(true_anom))

        # Plot 1
        if self.mode is not 1:
            # clear the plot and reset its properties
            self.ax1.clear()
            self.ax1.set_theta_offset(np.pi)
            self.ax1.axis("off")
            self.ax1.set_title("Orbit - Planar View", fontsize=24, color="blue", fontweight="bold")

            #  plot the planet
            circle = plt.Circle((0, 0), pr, transform=self.ax1.transData._b, color="grey", alpha=1)
            self.ax1.add_artist(circle)
            self.ax1.annotate(vessel.orbit.body.name,
                              xy=(.5, .5),
                              xycoords='axes fraction',
                              horizontalalignment='center',
                              verticalalignment='center',
                              color="white",
                              size=24
                              )

            # set the plot axis limits
            self.ax1.set_rlim(ap * 1.25)

            # plot the orbit
            self.ax1.plot(theta, r, color="blue", lw=3)

            # plot PE and AP
            self.ax1.plot([0], [q], "D", color="white", markersize=7)
            self.ax1.annotate("Pe = " + si_val(periapsis, 2) + "m",
                              xy=(0, q),  # theta, radius
                              xytext=(-5, -5),  # fraction, fraction
                              textcoords='offset points',
                              horizontalalignment='right',
                              verticalalignment='bottom',
                              color="white"
                              )

            self.ax1.plot([np.pi], [ap], "D", color="white", markersize=7)
            self.ax1.annotate("Ap = " + si_val(ap - pr, 2) + "m",
                              xy=(np.pi, ap),  # theta, radius
                              xytext=(5, 5),  # fraction, fraction
                              textcoords='offset points',
                              horizontalalignment='left',
                              verticalalignment='bottom',
                              color="white"
                              )

            # plot the current position
            self.ax1.plot([true_anom], [r_vess], ".", color="red", markersize=20)

        # plot 2
        if self.mode is not 0:
            self.ax2.clear()
            self.ax2.axis("off")
            self.ax2.set_title("Orbit - Oblique View", fontsize=24, color="blue", fontweight="bold")

            # Adjustment of the axes, so that they all have the same span:
            for axis in 'xyz':
                getattr(self.ax2, 'set_{}lim'.format(axis))((-a, a))

            r2 = (a * (1 - eccentricity ** 2)) / (1 + eccentricity * np.cos(theta + np.asanyarray(argPe) - np.pi / 2))

            xo = r2 * np.cos(theta)
            y2 = r2 * np.sin(theta)
            zo = np.zeros(181)

            inclination = incl

            x2 = xo * np.cos(inclination) + zo * np.sin(inclination)
            # y2 = yo
            z2 = -xo * np.sin(inclination) + zo * np.cos(inclination)

            # Set up marker points
            # coord index, label, marker, colours (in RGBA) and sizes
            # AN and Dn
            # These are simple as we have rotated our orbit so the An is at +Y
            node_label = [(45, "An", "^", [0, 1, 0, 1], 10),
                          (135, "Dn", "v", [0, 1, 0, 1], 10)]

            # Pe and Ap
            # These are then calculated from An using argPe, and opposite to that point.
            i_pe = (45 + int(degrees(argPe) / 2)) % 180
            i_ap = (i_pe + 90) % 180

            node_label.append((i_pe, "Pe", "D", [1, 1, 1, 1], 10))
            node_label.append((i_ap, "Ap", "D", [1, 1, 1, 1], 10))

            # Vessel
            i_ve = (i_pe + int(degrees(true_anom) / 2)) % 180
            node_label.append((i_ve, "", "o", [1, 0, 0, 1], 10))

            self.ax2.plot(x2, y2, z2)

            for i in range(len(node_label)):
                xl, yl, _ = proj3d.proj_transform(x2[node_label[i][0]], y2[node_label[i][0]], z2[node_label[i][0]], self.ax2.get_proj())
                self.ax2.plot([x2[node_label[i][0]]], [y2[node_label[i][0]]], [z2[node_label[i][0]]], node_label[i][2], c=node_label[i][3], markersize=node_label[i][4])
                self.ax2.annotate(node_label[i][1],
                                  xy=(xl, yl),
                                  xytext=(5, 5),  # fraction, fraction
                                  textcoords='offset points',
                                  horizontalalignment='left',
                                  verticalalignment='bottom',
                                  color="white"
                                  )

            # add the planet
            t1, t2 = np.mgrid[0.0:np.pi:150j, 0.0:2.0 * np.pi:150j]
            xp = pr * np.sin(t1) * np.cos(t2)
            yp = pr * np.sin(t1) * np.sin(t2)
            zp = pr * np.cos(t1)

            self.ax2.plot_surface(xp, yp, zp, color="grey", edgecolor="none")

        self.fig.canvas.draw()
    def plotLatticeSpacing(self, text):
        """adds lattice spacing to plot"""

        # create tranfsromation of cube dimensions to 2D
        x_shift = .3  # width shift
        y_shift = 0.  # depth shift
        z_shift = 0.  # upwards shift
        l = 2.  # length of arrow
        a = 1  # axis the arrow will extend along (0,1,2) = (x,y,z)

        i = np.asarray(  # the initial field position
            [1 + x_shift, -1 + y_shift, -1 + z_shift])
        mask = np.in1d(np.arange(i.size), a)  # mask is true on only the axis
        f = i + mask * l  # the final arrow point
        m = i + .5 * mask * l  # the mid point

        # lambda function to get the position from a different matrix projection
        getPos = lambda xyz: proj3d.proj_transform(*tuple(xyz),
                                                   M=self.ax.get_proj())

        # get points of the arrow
        x1, y1, _ = getPos(i)  # initial points
        x2, y2, _ = getPos(f)  # final point
        xm, ym, _ = getPos(m)  # mid point

        arrow = self.ax.annotate(
            '',  # draw the arrow
            xy=(x1, y1),  # start of arrow
            xytext=(x2, y2),  # end of arrow
            arrowprops={'arrowstyle': '<->'})
        label = self.ax.annotate(  # draw the text
            text,  # text to annotate with
            xy=(xm, ym),  # location of text
            xytext=(10, -10),  # specify the offset of the text
            xycoords='data',
            textcoords='offset points')

        # add to list of labels
        self.labels['spacing_arrow'] = arrow
        self.labels['spacing_label'] = label

        def update_position_arrow(e):
            """click and the labels snap the correct place
            http://stackoverflow.com/a/10394128/4013571
            """
            # get points of the arrow
            x1, y1, _ = getPos(i)  # initial points
            x2, y2, _ = getPos(f)  # final point
            self.labels['spacing_arrow'].xy = x1, y1  # redef start point
            self.labels['spacing_arrow'].xyann = x2, y2  # redef final point
            self.labels['spacing_arrow'].update_positions(
                self.fig.canvas.renderer)
            self.fig.canvas.draw()
            pass

        def update_position_text(e):
            """click and the labels snap the correct place
            http://stackoverflow.com/a/10394128/4013571
            """
            # get points of the arrow
            xm, ym, _ = getPos(m)  # initial points
            self.labels['spacing_label'].xy = xm, ym  # redef start point
            self.labels['spacing_label'].update_positions(
                self.fig.canvas.renderer)
            self.fig.canvas.draw()
            pass

        # enable the updated position
        self.fig.canvas.mpl_connect('button_release_event',
                                    update_position_arrow)
        self.fig.canvas.mpl_connect('button_release_event',
                                    update_position_text)
        plt.draw()
        pass
Exemple #47
0
"""
    First transformation repositions the points so that the points with weight
    1 are positioned at the barycentric coordinates.
    The second transformation will need to scale the points to the the realtive 
    distances befor the transformations are preserved.
"""

x1s = []
y1s = []
x2s = []
y2s = []

baryPoints = []
for optPoint in T:
    # one point of interest
    x1, y1, _ = proj3d.proj_transform(optPoint[0], optPoint[1], optPoint[2], ax1.get_proj())
    [x1,y1] = ax1.transData.transform((x1, y1))  # convert 2d space to screen space
    # put them in screen space relative to ax0
    x1s.append(x1/width)
    y1s.append(y1/height)
    
    length =  ( optPoint[0] + optPoint[1] + optPoint[2] )
    baryPoint = [optPoint[0] / length, optPoint[1] / length, 0]
    baryPoints.append(baryPoint)
    
    # another point of interest
    x2, y2, _ = proj3d.proj_transform(baryPoint[0], baryPoint[1], baryPoint[2], ax2.get_proj())
    [x2,y2] = ax2.transData.transform((x2, y2))  # convert 2d space to screen space
    x2s.append(x2/width)
    y2s.append(y2/height)
Exemple #48
0
 def draw(self, renderer):
     """Draw the patch."""
     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]))
     super(Arrow3D, self).draw(renderer)
Exemple #49
0
Y = np.array(Yt)
Z = np.array(Zt)
max_range = 0.5 * np.array([
    X.max() - X.min(), Y.max() - Y.min(),
    Z.max() - Z.min()
]).max() / 2.0
mid_x = (X.max() + X.min()) * 0.5 - 0.25
mid_y = (Y.max() + Y.min()) * 0.5 - 0.35
mid_z = (Z.max() + Z.min()) * 0.5
ax2.set_xlim3d(mid_x - max_range, mid_x + max_range)
ax2.set_ylim3d(mid_y - max_range, mid_y + max_range)
ax2.set_zlim3d(mid_z - max_range, mid_z + max_range)

# Create Annotation
ax2.annotate(s=r'$x$',
             xy=tuple(proj3d.proj_transform(*px, M=ax2.get_proj()))[:2],
             fontsize=14,
             bbox={
                 'pad': 8,
                 'fill': None,
                 'edgecolor': 'None'
             },
             va='top',
             ha='left')
ax2.annotate(s=r'$y$',
             xy=tuple(proj3d.proj_transform(*py, M=ax2.get_proj()))[:2],
             fontsize=14,
             bbox={
                 'pad': 8,
                 'fill': None,
                 'edgecolor': 'None'
Exemple #50
0
def update_position(e):
    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()
Exemple #51
0
    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)
Exemple #52
0
 def do_3d_projection(self, render=None):
     from mpl_toolkits.mplot3d import proj3d
     xs3d, ys3d, zs3d = self._verts3d
     xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
     self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
     return np.min(zs)
Exemple #53
0
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 16 13:06:57 2018

@author: Otm
"""

import pylab
from mpl_toolkits.mplot3d import Axes3D
from mpl_toolkits.mplot3d import proj3d

fig = pylab.figure()
ax = fig.add_subplot(111, projection='3d')
x = y = z = [1, 2, 3]
sc = ax.scatter(x, y, z)
# now try to get the display coordinates of the first point

x2, y2, _ = proj3d.proj_transform(1, 1, 1, ax.get_proj())
Exemple #54
0
 def draw(self, renderer):
     xs3d, ys3d, zs3d = self._verts3d
     xs, ys, zs = proj_transform(xs3d, ys3d, zs3d, renderer.M)
     self.xy = (xs, ys)
     Annotation.draw(self, renderer)
    def __init__(self, groups):

        points = [g['center'] for g in groups]

        self.points = points
        self.groups = groups

        # color = iter(plt.cm.rainbow(np.linspace(0, 1, len(set(deals)))))
        colors = get_colors(len(groups))

        self.fig = plt.figure(1)
        plt.rcParams['figure.figsize'] = 9, 9

        self.fig_text = plt.figure(2)

        self.fig_buttons = plt.figure(3)

        # Doing some layout with subplots:
        # fig = plt.figure()
        self.ax = self.fig.gca(projection='3d')

        self.ax.set_xlabel('x')
        self.ax.set_ylabel('y')
        self.ax.set_zlabel('z')

        # plot main figure
        labels = []
        buttons = []
        # cursors = []

        for i_col, group in enumerate(self.groups):

            ax_button = self.fig_buttons.add_subplot(len(groups), 1, i_col + 1)
            # cursor = Cursor(ax_button, useblit=True, color='black', linewidth=2)

            c = group['center']
            r = group['radius']

            self.ax.scatter(c[0], c[1], c[2], s=1e3 * r, c=colors[i_col])

            group_button = ButtonClickProcessor(ax_button, label=i_col, color=colors[i_col], viewer=self)

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

            label = self.ax.annotate(str(i_col),
                                     xy=(x_proj, y_proj), xytext=(-20, 20),
                                     textcoords='offset points', ha='right', va='top', fontsize=12,
                                     bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5),
                                     arrowprops = dict(arrowstyle='->', connectionstyle='arc3,rad=0'))

            labels.append(label)
            buttons.append(group_button)
            # cursors.append(cursor)

        self.labels = labels
        # self.buttons = buttons
        # self.cursors = cursors

        # lgd = self.ax.legend(loc=9, bbox_to_anchor=(0.5,0))
        # self.ax.legend()

        self.fig_buttons.canvas.draw()

        #connect events
        self.fig.canvas.mpl_connect('button_release_event', self.update_position)
 def draw(self, renderer):
   from mpl_toolkits.mplot3d import proj3d
   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)
Exemple #57
0
    def pcaSubplot_vars(self, X_r, dim, varData, varName, PCs_round, labels,
                        template_list, dpiVal):
        """
        Get the Principal Component Analysis data for this set of coordinates
        The value of 'dim' specifies the number of dimensions to diplay
        Then plot the PCA data
        """
        # Set some figure parameters
        plt.rcParams['xtick.major.pad'] = '8'
        plt.rcParams['ytick.major.pad'] = '8'

        # Divide up the data to plot into general conformations and templates.
        # The colormap data is not used for the templates, and a different
        # marker is used.
        templatePosition = []
        confData = []
        confPosition = []
        for l, d, x in zip(labels, varData, X_r):
            if l in template_list:
                templatePosition.append(x)
            else:
                confData.append(d)
                confPosition.append(x)
        templatePosition = np.array(templatePosition)
        confPosition = np.array(confPosition)

        # Plot either PCA data on 2D or 3D
        if dim == 2:
            # Create figure and subplot
            fig = plt.figure(figsize=(17, 13), dpi=dpiVal)
            fig.set_facecolor('white')
            fig.canvas.set_window_title("PCA 2D")
            ax = fig.add_subplot(111)

            # Scatter conformations. Designated by circles, colored based on
            # IFP similarity to a defined template
            scat = ax.scatter(confPosition[:, 0],
                              confPosition[:, 1],
                              s=600,
                              marker="o",
                              cmap=plt.cm.magma,
                              c=confData,
                              vmin=0.0,
                              vmax=1.0)

            # Scatter the template conformation(s). Designated by arrows.
            ax.scatter(templatePosition[:, 0],
                       templatePosition[:, 1],
                       s=600,
                       marker="v",
                       color="black")

            # Setting labels for both conformations and templates
            for label, x, y in zip(labels, X_r[:, 0], X_r[:, 1]):
                ax.annotate(label,
                            xy=(x, y + 0.05),
                            fontsize=30,
                            ha='center',
                            va='bottom')

            # Settin axis and labels
            ax.set_xlabel("PC1 ({} %)".format(PCs_round[0]), fontsize=30)
            ax.set_ylabel("PC2 ({} %)".format(PCs_round[1]), fontsize=30)
            ax.tick_params(axis="both", which="major", labelsize=25)

            # Plot the colorbar
            cb = plt.colorbar(scat)
            cb.set_label(varName, size=30)
            cb.ax.tick_params(labelsize=25)

        # 3D figure
        if dim == 3:
            # Create figure and subplot
            fig = plt.figure()
            fig.set_facecolor('white')
            fig.canvas.set_window_title("PCA 3D")
            ax = fig.add_subplot(111, projection='3d')

            # Conformations
            scat = ax.scatter(confPosition[:, 0],
                              confPosition[:, 1],
                              confPosition[:, 2],
                              s=200,
                              marker="o",
                              cmap=plt.cm.magma,
                              c=confData,
                              vmin=0.0,
                              vmax=1.0)
            # Templates
            ax.scatter(templatePosition[:, 0],
                       templatePosition[:, 1],
                       templatePosition[:, 2],
                       c="black",
                       s=200,
                       marker="v")

            # Scatter plot labels
            for label, x, y, z in zip(labels, X_r[:, 0], X_r[:, 1], X_r[:, 2]):
                if label != "":
                    x2D, y2D, _ = proj3d.proj_transform(x, y, z, ax.get_proj())
                    ax.annotate(label,
                                xy=(x2D, y2D),
                                fontsize=10,
                                ha='left',
                                va='top')

            # Setting axis and labelsize
            ax.set_xlabel("PC1 ({} %)".format(PCs_round[0]), fontsize=10)
            ax.set_ylabel("PC2 ({} %)".format(PCs_round[1]), fontsize=10)
            ax.set_zlabel("PC3 ({} %)".format(PCs_round[2]), fontsize=10)
            ax.tick_params(axis="both", which="major", labelsize=10)

            # Plot the colorbar
            cb = plt.colorbar(scat)
            cb.set_label(varName, size=10)
            cb.ax.tick_params(labelsize=10)
Exemple #58
0
 def do_3d_projection(self, renderer=None):
     xs3d, ys3d, zs3d = self._verts3d
     xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, self.axes.M)
     self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
     return np.min(zs)
Exemple #59
0
from mpl_toolkits.mplot3d import Axes3D
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from mpl_toolkits.mplot3d import proj3d

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
vertices = vv
#colors = colors = "bgrcmykw"
for i, poly in enumerate(parsed):
    ax.add_collection3d(Poly3DCollection([poly[1]], alpha=0.5))
#ax.scatter([x[0] for i,x in enumerate(vertices)],[x[1] for x in vertices],[x[2] for x in vertices])
ax.scatter([x[0] for x in vv], [x[1] for x in vv], [x[2] for x in vv])
ax.scatter(vertices_np[:, 0], vertices_np[:, 1], vertices_np[:, 2])
ax.auto_scale_xyz([-a, a], [-a, a], [-a, a])
for a, p in vdict.iteritems():
    tr = proj3d.proj_transform(p[0], p[1], p[2], ax.get_proj())
    ax.annotate(str(a), (tr[0], tr[1]))
a = 0.6
plt.show()
exit()

print output_np
fig = plt.figure()
ax = fig.add_subplot(111)
ax.imshow(output_np, interpolation='none')
numrows, numcols = output_np.shape


def format_coord(x, y):
    col = int(x + 0.5)
    row = int(y + 0.5)
Exemple #60
0
 def draw(self, renderer):
     x3d, y3d, z3d = self._verts3d
     x, y, z = proj3d.proj_transform(x3d, y3d, z3d, renderer.M)
     self.center = x, y
     Circle.draw(self, renderer)