コード例 #1
0
 def add_legend(self, padding=10, align="ur"):
     legend = Legend(component=self.plot_container, padding=10, align="ur")
     legend.tools.append(LegendTool(legend, drag_button="right"))
     multibarplot = self.multibarplot
     legend.plots = dict(zip(multibarplot.legend_labels,
                             multibarplot.barplots))
     self.plot_container.overlays.append(legend)
コード例 #2
0
ファイル: multiaxis.py プロジェクト: brycehendrix/chaco
def _create_plot_component():

    container = OverlayPlotContainer(padding = 50, fill_padding = True,
                                     bgcolor = "lightgray", use_backbuffer=True)

    # Create the initial X-series of data
    numpoints = 100
    low = -5
    high = 15.0
    x = arange(low, high+0.001, (high-low)/numpoints)

    # Plot some bessel functions
    plots = {}
    broadcaster = BroadcasterTool()
    for i in range(4):
        y = jn(i, x)
        plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
        plot.index.sort_order = "ascending"
        plot.bgcolor = "white"
        plot.border_visible = True
        if i == 0:
            add_default_grids(plot)
            add_default_axes(plot)

        # Create a pan tool and give it a reference to the plot it should
        # manipulate, but don't attach it to the plot.  Instead, attach it to
        # the broadcaster.
        pan = PanTool(plot)
        broadcaster.tools.append(pan)

        container.add(plot)
        plots["Bessel j_%d"%i] = plot

    # Add an axis on the right-hand side that corresponds to the second plot.
    # Note that it uses plot.value_mapper instead of plot0.value_mapper.
    plot1 = plots["Bessel j_1"]
    axis = PlotAxis(plot1, orientation="right")
    plot1.underlays.append(axis)

    # Add the broadcast tool to the container, instead of to an
    # individual plot
    container.tools.append(broadcaster)

    legend = Legend(component=container, padding=10, align="ur")
    legend.tools.append(LegendTool(legend, drag_button="right"))
    container.overlays.append(legend)

    # Set the list of plots on the legend
    legend.plots = plots

    # Add the title at the top
    container.overlays.append(PlotLabel("Bessel functions",
                              component=container,
                              font = "swiss 16",
                              overlay_position="top"))

    # Add the traits inspector tool to the container
    container.tools.append(TraitsTool(container))

    return container
コード例 #3
0
ファイル: client.py プロジェクト: FlorianFetzer/Fetzer_Rep
    def _plot_targets_fired(self):
        print 'bla'
        numpoints = 100
        low = -5
        high = 15.0
        x = np.arange(low, high+0.001, (high-low)/numpoints)
        # Plot some bessel functions
        value_mapper = None
        index_mapper = None
        plots = {}
        for i in range(10):
            y = jn(i, x)
            plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
            #plot.index.sort_order = "ascending"

            plot.bgcolor = "white"
            plot.border_visible = True
            if i != 0:
                plot.value_mapper = value_mapper
                value_mapper.range.add(plot.value)
                plot.index_mapper = index_mapper
                index_mapper.range.add(plot.index)
            else:
                value_mapper = plot.value_mapper
                index_mapper = plot.index_mapper
                add_default_grids(plot)
                add_default_axes(plot)
                plot.index_range.tight_bounds = False
                plot.index_range.refresh()
                plot.value_range.tight_bounds = False
                plot.value_range.refresh()
                plot.tools.append(PanTool(plot))
               
                # The ZoomTool tool is stateful and allows drawing a zoom
                # box to select a zoom region.
                zoom = ZoomTool(plot, tool_mode="box", always_on=False)
                plot.overlays.append(zoom)
                # The DragZoom tool just zooms in and out as the user drags
                # the mouse vertically.
                dragzoom = DragZoom(plot, drag_button="right")
                plot.tools.append(dragzoom)
                # Add a legend in the upper right corner, and make it relocatable
                legend = Legend(component=plot, padding=10, align="ur")
                legend.tools.append(LegendTool(legend, drag_button="right"))
                plot.overlays.append(legend)
            self.LinePlotContainer.add(plot)
            plots["Bessel j_%d"%i] = plot
        # Set the list of plots on the legend
        legend.plots = plots
        # Add the title at the top
        self.LinePlotContainer.overlays.append(PlotLabel("Bessel functions",
                                  component=self.LinePlotContainer,
                                  font = "swiss 16",
                                  overlay_position="top"))
        # Add the traits inspector tool to the container
        self.LinePlotContainer.tools.append(TraitsTool(self.LinePlotContainer))
        self.show_lines=True
        print 'hallo'
コード例 #4
0
    def __init__(self):
        super(LinePlot, self).__init__()
        x = linspace(-14, 14, 100)
        y1 = sin(x) * x**3
        y2 = cos(x) * x**3
        plotdata = ArrayPlotData(x=x, y1=y1, y2=y2)
        plot = Plot(plotdata)
        plot.plot(("x", "y1"), type="line", color="blue", name="sin(x) * x**3")
        plot.plot(("x", "y2"), type="line", color="red", name="cos(x) * x**3")
        plot.plot(("x", "y2"), type="scatter", color="red", marker = "circle",
                  marker_size = 2, name="cos(x) * x**3 points")
        plot.title = "Multiple Curves"
        self.plot = plot

        legend = Legend(padding=10, align="ur")
        legend.plots = plot.plots
        plot.overlays.append(legend)        
コード例 #5
0
    def __init__(self):
        super(LinePlot, self).__init__()
        x = linspace(-14, 14, 100)
        y1 = sin(x) * x**3
        y2 = cos(x) * x**3
        plotdata = ArrayPlotData(x=x, y1=y1, y2=y2)
        plot = Plot(plotdata)
        plot.plot(("x", "y1"), type="line", color="blue", name="sin(x) * x**3")
        plot.plot(("x", "y2"), type="line", color="red", name="cos(x) * x**3")
        plot.plot(("x", "y2"),
                  type="scatter",
                  color="red",
                  marker="circle",
                  marker_size=2,
                  name="cos(x) * x**3 points")
        plot.title = "Multiple Curves"
        self.plot = plot

        legend = Legend(padding=10, align="ur")
        legend.plots = plot.plots
        plot.overlays.append(legend)
コード例 #6
0
    def __init__(self, parent, id=-1, **kwargs):
        wx.Panel.__init__(self, parent, id=id, **kwargs)
        self.statusBar = self.GetTopLevelParent().statusBar

        self.container = OverlayPlotContainer(padding = 50, fill_padding = True,
            bgcolor = "lightgray", use_backbuffer=True)
        self.legend = Legend(component=self.container, padding=10, align="ur")
        #self.legend.tools.append(LegendTool(self.legend, drag_button="right"))
        self.container.overlays.append(self.legend)

        self.plot_window = Window(self, component=self.container)

        self.container.tools.append(TraitsTool(self.container))

        self.firstplot = True
        self._palette = ['red', 'blue', 'green', 'purple', 'yellow']
        self._current_palette_index = 0

        self._traces = []

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.plot_window.control, 1, wx.EXPAND)
        self.SetSizer(sizer)
        self.SetAutoLayout(True)
コード例 #7
0
    def _refresh_container( self ):
        ''' rebuild the container for the current data
        '''
        broadcaster = BroadcasterTool()
    
        mfn_line = self.value
        ydata = transpose(mfn_line.ydata)
        
        adapter = self.adapter
        if adapter.var_x != '':
            # Get the x-label text from the object's trait var_x          
            label_x = getattr( self.object, adapter.var_x )
        else:
            # Get the x-label from the adapter          
            label_x = adapter.label_x
            
        if adapter.var_y  != '':
            label_y = getattr( self.object, adapter.var_y )
        else:
            label_y = adapter.label_y
        
        index = ArrayDataSource(mfn_line.xdata)
        index_range = DataRange1D()
        index_range.add(index)
        index_mapper = LinearMapper(range=index_range)
            
        value_range = DataRange1D(  low_setting = 0.0  )
        
        colors = [] 
        colors = adapter.line_color #self.line_color_chaco.values() 

        styles = []
        styles = adapter.line_style #self.line_style_chaco.values()

        s_item = styles.items()
        
        color_chaco = []
        style_chaco = []
        c_index = 0  # loop for colors
        s_index = 0  # loop for styles
        i=0          # for colors and styles
        plots = {}   # for legend

        pd = ArrayPlotData(index = mfn_line.xdata)
        self.splot = Plot(pd)

        for vector in ydata[:]:

            if len(colors) == c_index:
                c_index = 0
            if len(styles) == s_index:
                s_index = 0
            
            style_name = s_item[s_index][0]    
            color_chaco.append(colors[c_index])
            style_chaco.append(style_name)
            c_index = c_index + 1
            s_index = s_index + 1
            
            y = ArrayDataSource(vector, sort_order="none")
                  
            value_range.add(y)
            value_mapper = LinearMapper(range=value_range)
            
            self.line_plot = LinePlot(index = index, value = y,
                                            index_mapper = index_mapper,
                                            value_mapper = value_mapper,
                                            color = color_chaco[i],  
                                            line_width = adapter.linewidth,
                                            edge_color = 'blue',
                                            border_visible = False,
                                            line_style = style_chaco[i])
        
            add_default_grids(self.line_plot)
            add_default_axes(self.line_plot, vtitle= label_y, htitle= label_x)
    
            self.plot_container.add(self.line_plot)
#            pan = PanTool(line_plot)
#            zoom = SimpleZoom(line_plot, tool_mode="box", always_on=False)
#            broadcaster.tools.append(pan)
#            broadcaster.tools.append(zoom)
    
            # Add the traits inspector tool to the container
            #
 #           self.plot_container.tools.append(TraitsTool( self.plot_container ))
            
            self.line_plot.tools.append(PanTool(self.line_plot))
            self.line_plot.overlays.append(ZoomTool(self.line_plot))

            # Legend
            lgnd = adapter.legend_labels[i]
            plots[lgnd] = self.line_plot

            # change the color of the curves
            i = i +1  

        legend = Legend(component=self.plot_container, padding=10, align="ul")
        legend.tools.append(LegendTool(legend, drag_button="right"))
        self.plot_container.overlays.append(legend)

        # Set the list of plots on the legend
        legend.plots = plots

        # Add the title at the top
        self.plot_container.overlays.append(PlotLabel(adapter.title,
                                  component=self.plot_container,
                                  font = "swiss 16",
                                  overlay_position="top"))
コード例 #8
0
ファイル: line.py プロジェクト: axelvonderheide/scratch
    def _create_window(self):
        container = OverlayPlotContainer(padding = 50, fill_padding = True,
                                         bgcolor = "lightgray", use_backbuffer=True)
        self.container = container

        # Create the initial X-series of data
        numpoints = 100
        low = -5
        high = 15.0
        x = arange(low, high+0.001, (high-low)/numpoints)

        # Plot some bessel functions
        value_mapper = None
        index_mapper = None
        plots = {}
        for i in range(10):
            y = jn(i, x)
            if i%2 == 1:
                plot = create_line_plot((x,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
                plot.index.sort_order = "ascending"
            else:
                plot = create_scatter_plot((x,y), color=tuple(COLOR_PALETTE[i]))

            plot.bgcolor = "white"
            plot.border_visible = True
            if i == 0:
                value_mapper = plot.value_mapper
                index_mapper = plot.index_mapper
                add_default_grids(plot)
                add_default_axes(plot)
                plot.index_range.tight_bounds = False
                plot.index_range.refresh()
                plot.value_range.tight_bounds = False
                plot.value_range.refresh()
            else:
                plot.value_mapper = value_mapper
                value_mapper.range.add(plot.value)
                plot.index_mapper = index_mapper
                index_mapper.range.add(plot.index)

            if i==0:
                plot.tools.append(PanTool(plot))
                
                # The ZoomTool tool is stateful and allows drawing a zoom
                # box to select a zoom region.
                zoom = ZoomTool(plot, tool_mode="box", always_on=False)
                plot.overlays.append(zoom)

                # The DragZoom tool just zooms in and out as the user drags
                # the mouse vertically.
                dragzoom = DragZoom(plot, drag_button="right")
                plot.tools.append(dragzoom)

                # Add a legend in the upper right corner, and make it relocatable
                legend = Legend(component=plot, padding=10, align="ur")
                legend.tools.append(LegendTool(legend, drag_button="right"))
                plot.overlays.append(legend)

            container.add(plot)
            plots["Bessel j_%d"%i] = plot

        # Set the list of plots on the legend
        legend.plots = plots

        # Add the title at the top
        container.overlays.append(PlotLabel("Bessel functions",
                                  component=container,
                                  font = "swiss 16",
                                  overlay_position="top"))

        
        container.overlays.append(PlotLabel("height",component=container,overlay_position="bottom"))


        # Add the traits inspector tool to the container
        container.tools.append(TraitsTool(container))

        return Window(self, -1, component=container)
コード例 #9
0
ファイル: scales_test.py プロジェクト: brycehendrix/chaco
def _create_plot_component():
    container = OverlayPlotContainer(padding = 50, fill_padding = True,
                                     bgcolor = "lightgray", use_backbuffer=True)

    # Create the initial X-series of data
    numpoints = 100
    low = -5
    high = 15.0
    x = linspace(low, high, numpoints)

    now = time()
    timex = linspace(now, now+7*24*3600, numpoints)

    # Plot some bessel functions
    value_mapper = None
    index_mapper = None
    plots = {}
    for i in range(10):
        y = jn(i, x)
        if i%2 == 1:
            plot = create_line_plot((timex,y), color=tuple(COLOR_PALETTE[i]), width=2.0)
            plot.index.sort_order = "ascending"
        else:
            plot = create_scatter_plot((timex,y), color=tuple(COLOR_PALETTE[i]))
        plot.bgcolor = "white"
        plot.border_visible = True
        if i == 0:
            value_mapper = plot.value_mapper
            index_mapper = plot.index_mapper
            left, bottom = add_default_axes(plot)
            left.tick_generator = ScalesTickGenerator()
            bottom.tick_generator = ScalesTickGenerator(scale=CalendarScaleSystem())
            add_default_grids(plot, tick_gen=bottom.tick_generator)
        else:
            plot.value_mapper = value_mapper
            value_mapper.range.add(plot.value)
            plot.index_mapper = index_mapper
            index_mapper.range.add(plot.index)

        if i==0:
            plot.tools.append(PanTool(plot))
            zoom = ZoomTool(plot, tool_mode="box", always_on=False)
            plot.overlays.append(zoom)
            # Add a legend in the upper right corner, and make it relocatable
            legend = Legend(component=plot, padding=10, align="ur")
            legend.tools.append(LegendTool(legend, drag_button="right"))
            plot.overlays.append(legend)

        container.add(plot)
        plots["Bessel j_%d"%i] = plot

    # Set the list of plots on the legend
    legend.plots = plots

    # Add the title at the top
    container.overlays.append(PlotLabel("Bessel functions",
                              component=container,
                              font = "swiss 16",
                              overlay_position="top"))

    # Add the traits inspector tool to the container
    container.tools.append(TraitsTool(container))

    return container
コード例 #10
0
    def _plot_container_default(self):
        container = OverlayPlotContainer( padding = 60, fill_padding = False,
                                  bgcolor = "white", use_backbuffer=True)
        # Plot some distribution functions
        plots = {}
        broadcaster = BroadcasterTool()
    
    #""" Plot 
        
#        view = DataView(border_visible = True)
#
        index = ArrayDataSource(self.x_array)
        value = ArrayDataSource(self.pdf_array, sort_order="none")

        index_range = DataRange1D()
        index_range.add(index)
        index_mapper = LinearMapper(range=index_range)
    
        value_range = DataRange1D()
        value_range.add(value)
        value_mapper = LinearMapper(range=value_range)

        pdf_plot = FilledLinePlot(index = index, value = value,
                                    index_mapper = index_mapper,
                                    value_mapper = value_mapper,
                                    edge_color = tuple(COLOR_PALETTE[0]),
                                    face_color = "paleturquoise",
                                    bgcolor = "white",
                                    border_visible = True)

        add_default_grids(pdf_plot)
        add_default_axes(pdf_plot)

        #***************************Label*************************************
        pdf_label = DataLabel(component=pdf_plot, data_point=(2.4,0.15), 
                          label_position=(15,15), padding=5,
                          label_format = 'PDF',
                          bgcolor = "transparent",
                          marker_color = "transparent",
                          marker_line_color = "transparent",
                          border_visible=False)
        pdf_plot.overlays.append(pdf_label)
        
        
#        tool = DataLabelTool(pdf_label, drag_button="right", auto_arrow_root=True)
#        pdf_label.tools.append(tool)


        container.add(pdf_plot)
        pan = PanTool(pdf_plot)
        zoom = SimpleZoom(pdf_plot, tool_mode="box", always_on=False)
        broadcaster.tools.append(pan)
        broadcaster.tools.append(zoom)
        
        
#*********************************CDF****************************

        plot = create_line_plot((self.x_array,self.pdf_array), 
                                color=tuple(COLOR_PALETTE[0]), width=2.0)
        
        plot.bgcolor = "white"
        plot.border_visible = True                

        add_default_grids(plot)
        add_default_axes(plot)


        container.add(plot)


#       # Create a pan tool and give it a reference to the plot it should
#       # manipulate, but don't attach it to the plot.  Instead, attach it to
#       # the broadcaster.
        pan = PanTool(plot)
        zoom = SimpleZoom(plot, tool_mode="box", always_on=False)
        broadcaster.tools.append(pan)
        broadcaster.tools.append(zoom)
        

    #""" PDF Plot
        # Add an axis on the right-hand side that corresponds to the second plot.
        # Note that it uses plot.value_mapper instead of plot0.value_mapper.
        pdf_plot = create_line_plot((self.x_array,self.cdf_array), 
                                color=tuple(COLOR_PALETTE[1]), width=2.0)
        pdf_plot.bgcolor = "white"
        pdf_plot.border_visible = True
     

        # Label
        cdf_text = TextBoxOverlay(text = 'CDF', alternate_position = (200,390) )
        pdf_plot.overlays.append(cdf_text)

        tool = DataLabelTool(cdf_text, drag_button="right", auto_arrow_root=True)
        cdf_text.tools.append(tool)
        
        container.add(pdf_plot)

#        vertical_axis = LabelAxis(pdf_plot, orientation='top',
#                                  title='Categories')
#        pdf_plot.underlays.append(vertical_axis)

        pdf_pan = PanTool(pdf_plot)
        pdf_zoom = SimpleZoom(pdf_plot, tool_mode="box", always_on=False)
        broadcaster.tools.append(pdf_pan)
        broadcaster.tools.append(pdf_zoom)


        axis = PlotAxis(pdf_plot, orientation="right")
        pdf_plot.underlays.append(axis)



#"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""

        # Add the broadcast tool to the container, instead of to an
        # individual plot
        container.tools.append(broadcaster)


        container.underlays.append(PlotLabel("CDF",
                                  component=container,
                                  font = "swiss 16",
                                  overlay_position="right"))


        legend = Legend(component=container, padding=10, align="ul")
        legend.tools.append(LegendTool(legend, drag_button="right"))
        container.overlays.append(legend)

        # Set the list of plots on the legend
        plots["pdf"] = plot
        plots["cdf"] = pdf_plot
        legend.plots = plots


#*******************************************************************************


        x = ArrayDataSource( array( [ 0.0, 0.0 ], dtype = float ) ) 
        y = ArrayDataSource( array( [ 0.0, self.mean ], dtype = float ) )
        
        
        mean_plot = create_line_plot((x,y),
                                  color=tuple(COLOR_PALETTE[2]), width=2.0)


#        vertical_plot = LinePlot(index = ArrayDataSource( array( [ 0.0, 1.0 ], dtype = float ) ),
#                        value = ArrayDataSource( array( [ 0.0, 1.0 ], dtype = float ) ),
#                        color = "green"),
#                        index_mapper = LinearMapper(range=index_mapper),
#                        value_mapper = LinearMapper(range=value_mapper))
 


        container.add(mean_plot)


       # Create a pan tool and give it a reference to the plot it should
       # manipulate, but don't attach it to the plot.  Instead, attach it to
       # the broadcaster.
        mean_pan = PanTool(mean_plot)
        mean_zoom = SimpleZoom(mean_plot, tool_mode="box", always_on=False)
        broadcaster.tools.append(mean_pan)
        broadcaster.tools.append(mean_zoom)



#**************************************************************************

        x = ArrayDataSource( array( [ 0.0, 0.0 ], dtype = float ) ) 
        y = ArrayDataSource( array( [ 0.0, 2.0 ], dtype = float ) )
        
        print "self.standard_deviation", self.standard_deviation
        
        st_plot = create_line_plot((x,y),
                                  color=tuple(COLOR_PALETTE[4]), width=2.0)

        container.add(st_plot)


       # Create a pan tool and give it a reference to the plot it should
       # manipulate, but don't attach it to the plot.  Instead, attach it to
       # the broadcaster.
        st_pan = PanTool(st_plot)
        st_zoom = SimpleZoom(st_plot, tool_mode="box", always_on=False)
        broadcaster.tools.append(st_pan)
        broadcaster.tools.append(st_zoom)



#*****************************************************************************

        # Add the title at the top
        container.overlays.append(PlotLabel("Distribution plots",
                                  component=container,
                                  font = "swiss 16",
                                  overlay_position="top"))

        # Add the traits inspector tool to the container
        container.tools.append(TraitsTool(container))
        return container
コード例 #11
0
    def _refresh_container(self,container):
        """ Plot some distribution functions """
        plots = {}
        broadcaster = BroadcasterTool()
    
        index = ArrayDataSource(self.x_array)
        value = ArrayDataSource(self.pdf_array, sort_order="none")

        index_range = DataRange1D()
        index_range.add(index)
        index_mapper = LinearMapper(range=index_range)
    
        value_range = DataRange1D(  low_setting = 0.0  )
        value_range.add(value)
        value_mapper = LinearMapper(range=value_range)

        """Plot probability distribution function(pdf) with marking the area under the function  """ 
        plot_pdf = FilledLinePlot(index = index, value = value,
                                    index_mapper = index_mapper,
                                    value_mapper = value_mapper,
                                    edge_color = tuple(COLOR_PALETTE[0]),
                                    face_color = "paleturquoise",
                                    border_visible = True)
        
        """define the grid, axes and title of the vertical grid """
        add_default_grids(plot_pdf)
        add_default_axes(plot_pdf, vtitle="PDF") 

        """create a label for the pdf and append it to the plot_pdf """
        label_pdf = DataLabel(component=plot_pdf, data_point=(2.4,0.13), 
                          label_position=(15,15), padding=5,
                          label_format = 'PDF',
                          bgcolor = "transparent",
                          marker_color = "transparent",
                          marker_line_color = "transparent",
                          arrow_color = tuple(COLOR_PALETTE[0]),
                          border_visible=False)
        plot_pdf.overlays.append(label_pdf)
        container.add(plot_pdf)
        
        """create a label for the x coordinate """
        container.overlays.append(PlotLabel("X",
                                  component=container,
                                  font = "swiss 16",
                                  overlay_position="bottom"))

        pan = PanTool(plot_pdf)
#        zoom = SimpleZoom(plot_pdf, tool_mode="box", always_on=False)

        broadcaster.tools.append(pan)
 #       broadcaster.tools.append(zoom)
        #"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
        #""" Mean Plot
        x = ArrayDataSource( array( [ self.mean, self.mean ], dtype = float ) ) 
        y = ArrayDataSource( array( [ 0.0, max( self.pdf_array ) ], dtype = float ) )

        """ Plot the mean value"""
        plot_mean = LinePlot(index = x, value = y,
                        color = "pink",
                        index_mapper = index_mapper,
                        value_mapper = value_mapper )
        container.add(plot_mean)
        
        # Create a pan tool and give it a reference to the plot it should
        # manipulate, but don't attach it to the plot.  Instead, attach it to
        # the broadcaster.
        mean_pan = PanTool(plot_mean)
#        mean_zoom = SimpleZoom(plot_mean, tool_mode="box", always_on=False)
        broadcaster.tools.append(mean_pan)
 #       broadcaster.tools.append(mean_zoom)
        #"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
        # Add an axis on the right-hand side that corresponds to the second plot.
        # Note that it uses plot.value_mapper instead of plot0.value_mapper.
        """ Plot cdf and its label """
        plot_cdf = create_line_plot((self.x_array,self.cdf_array), 
                                color=tuple(COLOR_PALETTE[1]), width=2.0)
        plot_cdf.bgcolor = "white"
        plot_cdf.border_visible = True

        label_cdf = DataLabel(component=plot_cdf, data_point=(2.4,0.9), 
                          label_position=(-35,20), padding=5,
                          label_format = 'CDF',
                          bgcolor = "transparent",
                          marker_color = "transparent",
                          marker_line_color = "transparent",
                          arrow_color = tuple(COLOR_PALETTE[1]),
                          border_visible=False)
        plot_cdf.overlays.append(label_cdf)

        container.add(plot_cdf)

        pan1 = PanTool(plot_cdf)
#        zoom1 = SimpleZoom(plot_cdf, tool_mode="box", always_on=False)
        broadcaster.tools.append(pan1)
#        broadcaster.tools.append(zoom1)

        axis = PlotAxis(plot_cdf, title="CDF", orientation="right")
        plot_cdf.underlays.append(axis)
        #"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
        # Add the broadcast tool to the container, instead of to an
        # individual plot
        container.tools.append(broadcaster)
        ##**************************************************************************
        """Plot standard deviation """
        stdev_low   = self.mean - self.standard_deviation
        stdev_high  = self.mean + self.standard_deviation
        stdev_low_height = self.distr.pdf( stdev_low )
        stdev_high_height = self.distr.pdf( stdev_high )
        
        x = ArrayDataSource( array( [ stdev_low, stdev_low, stdev_high, stdev_high ], dtype = float ) ) 
        y = ArrayDataSource( array( [ 0, stdev_low_height, stdev_high_height, 0. ], dtype = float ) )
              
        plot_st = PolygonPlot(index = x, value = y,
                        edge_color = "purple",
                        index_mapper = index_mapper,
                        value_mapper = value_mapper )
        container.add(plot_st)
        ##*****************************************************************************
        """create the legend for the mean """
        legend = Legend(component=container, padding=10, align="ul")
        legend.tools.append(LegendTool(legend, drag_button="right"))
        container.overlays.append(legend)

        # Set the list of plots on the legend
        plots["Mean"] = plot_mean
        legend.plots = plots

        # Add the title at the top
        container.overlays.append(PlotLabel("probability distribution plots",
                                  component=container,
                                  font = "swiss 16",
                                  overlay_position="top"))
        # Add the traits inspector tool to the container
        container.tools.append(TraitsTool(container))