Discuss Matplotlib ”; Previous Next Matplotlib is one of the most popular Python packages used for data visualization. It is a cross-platform library for making 2D plots from data in arrays. It provides an object-oriented API that helps in embedding plots in applications using Python GUI toolkits such as PyQt, WxPythonotTkinter. It can be used in Python and IPython shells, Jupyter notebook and web application servers also. Print Page Previous Next Advertisements ”;
Matplotlib – Quiver Plot ”; Previous Next A quiver plot displays the velocity vectors as arrows with components (u,v) at the points (x,y). quiver(x,y,u,v) The above command plots vectors as arrows at the coordinates specified in each corresponding pair of elements in x and y. Parameters The following table lists down the different parameters for the Quiver plot − x 1D or 2D array, sequence. The x coordinates of the arrow locations y 1D or 2D array, sequence. The y coordinates of the arrow locations u 1D or 2D array, sequence. The x components of the arrow vectors v 1D or 2D array, sequence. The y components of the arrow vectors c 1D or 2D array, sequence. The arrow colors The following code draws a simple quiver plot − import matplotlib.pyplot as plt import numpy as np x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25)) z = x*np.exp(-x**2 – y**2) v, u = np.gradient(z, .2, .2) fig, ax = plt.subplots() q = ax.quiver(x,y,u,v) plt.show() Print Page Previous Next Advertisements ”;
Matplotlib – Scroll Event ”; Previous Next In general, a scroll event occurs when a user interacts with the mouse scroll wheel. The scroll wheel that is located in the middle of the mouse is used to scroll up and down on any page without using the vertical scroll bar on the right hand side of a document or webpage. In this tutorial, we will explore about the scroll event handling in Matplotlib. Scroll event in Matplotlib Matplotlib provides a mechanism for handling the scroll events through MouseEvent class. This scroll_event event is triggered when a user rolled the mouse scroll wheel. Which is used for providing a mechanism for interactive navigation or zooming within plots. Example Here is a simple example that detects scroll events and displays the messages based on whether the user scrolls up or down the mouse scroll wheel. import matplotlib.pyplot as plt import numpy as np def on_scroll(event): if event.button == ”up”: print(”Scroll Up Event Triggered..”) elif event.button == ”down”: print(”Scroll Down Event Triggered..”) # Create a figure and axis fig, ax = plt.subplots() ax.text(0.13, 0.5, ”Scroll Mouse Wheel on me!”, dict(size=20)) # Connect the on_scroll method to the scroll_event fig.canvas.mpl_connect(”scroll_event”, on_scroll) plt.show() Output On executing the above code we will get the following output − Scroll Up Event Triggered.. Scroll Up Event Triggered.. Scroll Down Event Triggered.. Scroll Up Event Triggered.. Scroll Down Event Triggered.. Scroll Up Event Triggered.. Scroll Up Event Triggered.. Watch the video below to observe how the this scroll event feature works here. Zooming with Scroll Event Scroll events in Matplotlib can be used for dynamically zooming the plots. By connecting the scroll event to a callable function, users can dynamically adjust the view within a plot. Example Let”s see an example that demonestrates how to implement zoom functionality using the scroll event. import matplotlib.pyplot as plt def zoom_factory(axs, base_scale=2.): def zoom_fun(event): # get the current x and y limits cur_xlim = axs.get_xlim() cur_ylim = axs.get_ylim() cur_xrange = (cur_xlim[1] – cur_xlim[0]) * 0.2 cur_yrange = (cur_ylim[1] – cur_ylim[0]) * 0.2 # get event x location xdata = event.xdata ydata = event.ydata if event.button == ”up”: # deal with zoom in scale_factor = 1/base_scale elif event.button == ”down”: # deal with zoom out scale_factor = base_scale else: # deal with something that should never happen scale_factor = 1 print(event.button) # set new limits axs.set_xlim([xdata – cur_xrange*scale_factor, xdata + cur_xrange*scale_factor]) axs.set_ylim([ydata – cur_yrange*scale_factor, ydata + cur_yrange*scale_factor]) # force re-draw plt.draw() # get the figure of interest fig = axs.get_figure() # Connect the call back function to the scroll_event fig.canvas.mpl_connect(”scroll_event”, zoom_fun) # return the function return zoom_fun # Example Usage fig, axs = plt.subplots(figsize=(7, 4)) axs.plot(range(100)) scale = 1.5 f = zoom_factory(axs, base_scale=scale) plt.show() Output On executing the above program you will get the following figure roll the mouse scroll wheel to observe the Zooming effect in this plot − Watch the video below to observe how the this scroll event feature works here. Interactive Scrolling through Images The scroll event in Matplotlib can also be applied to interactively scroll through a series of images. This feature is particularly useful when navigating through multi-dimensional datasets or a collection of images. Example This example, creates a class IndexTracker to navigate through a series of 2D slices using the scroll event. The on_scroll method adjusts the index based on the scroll direction, then it updates and displayed image. import matplotlib.pyplot as plt import numpy as np class IndexTracker: def __init__(self, axs, X): self.index = 0 self.X = X self.axs = axs self.im = axs.imshow(self.X[:, :, self.index]) self.update() def on_scrolling(self, event): print(event.button, event.step) increment = 1 if event.button == ”up” else -1 maxs_index = self.X.shape[-1] – 1 self.index = np.clip(self.index + increment, 0, maxs_index) self.update() def update(self): self.im.set_data(self.X[:, :, self.index]) self.axs.set_title( f”Use scroll wheel to navigatenindex {self.index}”) self.im.axes.figure.canvas.draw() # 3D data x, y, z = np.ogrid[-25:25:100j, -25:25:100j, 1:50:100j] X = np.sin(x * y * z) / (x * y * z) # Create a figure fig, axs = plt.subplots() tracker = IndexTracker(axs, X) fig.canvas.mpl_connect(”scroll_event”, tracker.on_scrolling) plt.show() Output On executing the above program you will get the following figure roll the mouse scroll wheel to observe working of this example − up 1.0 up 2.0 down -1.0 down -2.0 down -1.0 up 1.0 up 1.0 down -1.0 down -1.0 up 1.0 up 3.0 down -1.0 down -3.0 Watch the video below to observe how the this scroll event feature works here. Print Page Previous Next Advertisements ”;
Matplotlib – Manual Contour ”; Previous Next Manual contouring in general refers to the process of outlining the boundaries of an object or a specific area by hand rather than relying on automated methods. This is usually done to create accurate representations of the shapes and boundaries within the image. A contour line represents a constant value on a map or a graph. It is like drawing a line to connect points that share the same height on a topographic map or lines on a weather map connecting places with the same temperature. Manual Contour in Matplotlib In Matplotlib, a manual contour plot is a way to represent three-dimensional data on a two-dimensional surface using contour lines. These lines connect points of equal value in a dataset, creating a map-like visualization of continuous data. For a manual contour plot, you specify the contour levels or values at which the lines should be drawn. The plot then displays these contour lines, with each line representing a specific value in the dataset. Basic Manual Contour Plot Creating a basic manual contours in Matplotlib involves drawing lines to connect points with the same value, forming closed loops or curves that represent distinct levels of the measured quantity. This process allows for customization and fine-tuning of the contour lines to accurately represent the given data. While manual contouring can be time-consuming, it provides a level of control and precision that may be necessary in certain situations where automated methods may not be adequate. Example In the following example, we are creating a simple contour plot using Matplotlib. We are using the contour() function to generate contour lines of a sine function, with manually specified levels, overlaying them on the XY-plane − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(-3, 3, 100) y = np.linspace(-3, 3, 100) # Creating a grid of x and y values X, Y = np.meshgrid(x, y) # Calculating the value of Z using the given function Z = np.sin(X**2 + Y**2) # Creating contour plot with manual levels levels = [-0.9, -0.6, -0.3, 0, 0.3, 0.6, 0.9] plt.contour(X, Y, Z, levels=levels) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Manual Contour Plot”) # Displaying the plot plt.show() Output Following is the output of the above code − Manual Contour Plot with Labeling In Matplotlib, a manual contour plot with labeling represents three-dimensional data on a two-dimensional surface with contour lines, and annotate specific contour levels with labels. This type of plot displays contour lines to show regions of equal data value, and adds text labels to these lines to indicate the corresponding data values. The labels help to identify important features or values in the dataset, making it easier to interpret the plot and understand the distribution of the data. Example In here, we are creating a contour plot with inline labels to the contour lines using the clabel() function − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(-3, 3, 100) y = np.linspace(-3, 3, 100) X, Y = np.meshgrid(x, y) Z = np.sin(X**2 + Y**2) # Contour plot with labels levels = [-0.9, -0.6, -0.3, 0, 0.3, 0.6, 0.9] CS = plt.contour(X, Y, Z, levels=levels) plt.clabel(CS, inline=True, fontsize=12) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Manual Contour Plot with Labeling”) plt.show() Output On executing the above code we will get the following output − Manual Contour Plot with Filled Regions In Matplotlib, a manual contour plot with filled regions use colors to visually represent different levels or values in the dataset, unlike traditional contour plots that only show contour lines. Each filled region corresponds to a specific range of values, with colors indicating the intensity or magnitude of those values. Example In the example below, we are creating a filled contour plot of a sine function using the contourf() function with the “RdYlBu” colormap. We then add a color bar to indicate the intensity scale of the filled contours − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(-3, 3, 100) y = np.linspace(-3, 3, 100) X, Y = np.meshgrid(x, y) Z = np.sin(X**2 + Y**2) # Creating contour plot with filled regions plt.contourf(X, Y, Z, levels=[-0.9, -0.6, -0.3, 0, 0.3, 0.6, 0.9], cmap=”RdYlBu”) plt.colorbar() plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Manual Contour Plot with Filled Regions”) plt.show() Output After executing the above code, we get the following output − Manual Contour Plot with Custom Line Styles In Matplotlib, a manual contour plot with custom line styles is a way to represent contour lines, where each line can have a distinct visual style. Generally, contour lines are drawn as solid lines, but with custom line styles, you can modify aspects like the line width, color, and pattern to distinguish different levels or values in the dataset. For example, you might use dashed lines, dotted lines, or thicker lines to highlight specific contour levels or regions of interest. Example Now, we are creating a manual contour plot with custom line styles by specifying a list of line styles to use for different levels. We achieve this by passing the “linestyles” parameter to the contour() function − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(-3, 3, 100) y = np.linspace(-3, 3, 100) X, Y = np.meshgrid(x, y) Z = np.sin(X**2 + Y**2) # Contour plot with custom line styles levels = [-0.9, -0.6, -0.3, 0, 0.3, 0.6, 0.9] plt.contour(X, Y, Z, levels=levels, linestyles=[”-”, ”–”, ”-.”, ”:”, ”-”, ”–”]) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Manual Contour Plot with Customized Line Styles”) plt.show() Output On executing the above code we will get the following output − Print Page Previous
Matplotlib – Violin Plot ”; Previous Next Violin plots are similar to box plots, except that they also show the probability density of the data at different values. These plots include a marker for the median of the data and a box indicating the interquartile range, as in the standard box plots. Overlaid on this box plot is a kernel density estimation. Like box plots, violin plots are used to represent comparison of a variable distribution (or sample distribution) across different “categories”. A violin plot is more informative than a plain box plot. In fact while a box plot only shows summary statistics such as mean/median and interquartile ranges, the violin plot shows the full distribution of the data. import matplotlib.pyplot as plt import numpy as np np.random.seed(10) collectn_1 = np.random.normal(100, 10, 200) collectn_2 = np.random.normal(80, 30, 200) collectn_3 = np.random.normal(90, 20, 200) collectn_4 = np.random.normal(70, 25, 200) ## combine these different collections into a list data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4] # Create a figure instance fig = plt.figure() # Create an axes instance ax = fig.add_axes([0,0,1,1]) # Create the boxplot bp = ax.violinplot(data_to_plot) plt.show() Print Page Previous Next Advertisements ”;
Matplotlib – 3D Wireframe Plots ”; Previous Next A 3D wireframe plot is a way of representing data in three dimensions using lines to represent the shape of an object. A wireframe plot connects the data points of an object to create a mesh-like structure to show the shape of the object. Imagine we have a cube and instead of drawing the solid faces of the cube, we only show the lines outlining its edges and corners. The outline we get is the 3D wireframe plot − 3D Wireframe Plot in Matplotlib In Matplotlib, a 3D wireframe plot is a type of visualization where data is represented by a network of lines forming the edges of a three-dimensional surface. We can create a 3D wireframe plot in Matplotlib using the plot_wireframe() function in the ”mpl_toolkits.mplot3d” module. This function accepts the X, Y, and Z coordinates of a 3D object and connects these coordinates with lines to create a 3D outline of the object. Let’s start by drawing a basic 3D wireframe plot. Basic 3D Wireframe Plot A basic 3D wireframe plot in Matplotlib displays the surface of a 3D object as a mesh of lines, allowing you to visualize the shape and structure of the surface. The wireframe plot is formed by joining a series of points on the sphere”s surface with straight lines running along the x, y, and z axes. To create a wireframe plot, you can define arrays for the x, y, and z coordinates of the surface points you want to visualize. Then, you can pass these arrays to the plot_wireframe() function to generate the wireframe plot. Example In the following example, we are creating a basic 3D wireframe plot of a spherical surface. First, we generate the X, Y, and Z points of the sphere by varying them with the angles ”theta” and ”phi”. Then, we use the plot_wireframe() function to create lines that connect the data points of the sphere. In the resultant plot, we get a 3D wireframe plot of a spherical surface − import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # Generating data for a spherical surface theta = np.linspace(0, 2*np.pi, 100) phi = np.linspace(0, np.pi, 100) theta, phi = np.meshgrid(theta, phi) r = 1 x = r * np.sin(phi) * np.cos(theta) y = r * np.sin(phi) * np.sin(theta) z = r * np.cos(phi) # Creating a 3D plot fig = plt.figure() ax = fig.add_subplot(111, projection=”3d”) # Plotting the spherical wireframe ax.plot_wireframe(x, y, z, color=”blue”) # Adding labels and title ax.set_xlabel(”X”) ax.set_ylabel(”Y”) ax.set_zlabel(”Z”) ax.set_title(”Basic 3D Wireframe Plot”) # Displaying the plot plt.show() Output Following is the output of the above code − Toroidal 3D Wireframe Plot In Matplotlib, a toroidal 3D wireframe plot represents the surface of a torus using lines in three-dimensional space. A torus is a doughnut-shaped object with a hole in the middle. The wireframe plot connects the lines on surface of the torus to create its outline. Example In here, we are generating a toroidal 3D wireframe plot. We start by creating the surface of the torus by varying the X and Y coordinates with angles ”theta” and ”phi” and with major radius ”R” and minor radius ”r”, while the Z coordinate varies with ”r” and ”phi”. Then, we use the plot_wireframe() function to connect the coordinates with lines creating a resultant plot which represents a 3D wireframe plot of a torus − import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # Generating data for a toroidal surface theta = np.linspace(0, 2*np.pi, 100) phi = np.linspace(0, 2*np.pi, 100) theta, phi = np.meshgrid(theta, phi) R = 2 r = 1 x = (R + r * np.cos(phi)) * np.cos(theta) y = (R + r * np.cos(phi)) * np.sin(theta) z = r * np.sin(phi) # Creating a 3D plot fig = plt.figure() ax = fig.add_subplot(111, projection=”3d”) # Plotting the toroidal wireframe ax.plot_wireframe(x, y, z, color=”green”) # Adding labels and title ax.set_xlabel(”X”) ax.set_ylabel(”Y”) ax.set_zlabel(”Z”) ax.set_title(”Toroidal 3D Wireframe Plot”) # Displaying the plot plt.show() Output On executing the above code we will get the following output − Paraboloid 3D Wireframe Plot A paraboloid 3D wireframe plot in Matplotlib displays the outline of a paraboloid using lines on a three-dimensional graph. A paraboloid is a three-dimensional parabola that resembles a bowl. The 3D wireframe plot connects the data points to create a mesh-like structure of the paraboloid. Example The following example creates a 3D wireframe plot of a paraboloid in a 3D space. We create the paraboloid by evenly spacing the X, Y, and Z on a 3D graph. Then, we connect the coordinates with lines using the plot_wireframe() function to create a 3D wireframe plot − import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D # Generating data for a paraboloid surface x = np.linspace(-5, 5, 100) y = np.linspace(-5, 5, 100) X, Y = np.meshgrid(x, y) Z = X**2 + Y**2 # Creating a 3D plot fig = plt.figure() ax = fig.add_subplot(111, projection=”3d”) # Plotting the paraboloid wireframe ax.plot_wireframe(X, Y, Z, color=”purple”) # Adding labels and title ax.set_xlabel(”X”) ax.set_ylabel(”Y”) ax.set_zlabel(”Z”) ax.set_title(”Paraboloid 3D Wireframe Plot”) # Displaying the plot plt.show() Output After executing the above code, we get the following output − Cylindrical 3D Wireframe Plot In Matplotlib, a cylindrical wireframe plot is a visualization of the geometry of a cylinder in a three-dimensional space. A cylinder is a three-dimensional shape with a circular cross-section that extends along its length. The data points on the surface of the cylinder are connected with lines to create a 3D wireframe plot. Example Now, we are generating a 3D wireframe plot for a
Matplotlib – Basemap ”; Previous Next What is Basemap? The Matplotlib Basemap toolkit is an extension to Matplotlib that provides functionality for creating maps and visualizations involving geographical data. It allows users to plot data on various map projections, draw coastlines, countries and other map features . These are used to handle geographic coordinates seamlessly within Matplotlib. The below are the key features of Matplotlib Basemap. Map Projections Basemap supports various map projections by allowing users to visualize data in different coordinate systems like cylindrical, conic or azimuthal projections. Examples are Mercator, Lambert Conformal Conic and Orthographic projections. Plotting Geographic Data Basemap allows the plotting of geographical data such as points, lines, or polygons over maps. Users can overlay datasets onto maps and visualize geographic relationships. Map Elements Basemap provides functions to add map elements like coastlines, countries, states, rivers and political boundaries by enhancing the visual context of the maps. Coordinate Transformation It facilitates seamless conversion between different coordinate systems such as latitude and longitude to map projection coordinates and vice versa. Installing Basemap If we want to work with Basemap of matplotlib library we have to install it in our working environment. The below is the code. Example pip install basemap Note − When we are working with Jupyter notebook then we have to install basemap through the anaconda command terminal. Output Basic Workflow with Basemap The below is the basic workflow of the Basemap of the Matplotlib library. Let’s see each of them in detail for better understanding. Create a Basemap Instance Instantiate a Basemap object by specifying the map projection, bounding coordinates and other parameters. To create a Basemap instance using the Basemap toolkit in Matplotlib we can define the map projection and specify the desired map boundaries. Example In this example we are generating a basic map with coastlines and country boundaries using the specified Mercator projection and the provided bounding coordinates. We can further customize the map by adding features, plotting data points or using different projections and resolutions based on our requirements. from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt # Create a Basemap instance with a specific projection and bounding coordinates map = Basemap( projection=”merc”, llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180, urcrnrlon=180, resolution=”c”) # Draw coastlines and countries map.drawcoastlines() map.drawcountries() # Show the map plt.show() Output Plot Data on the Map In this we use the Basemap methods to draw map features, plot data points or visualize geographical datasets. Example In this example we are generating random latitude and longitude points and then uses the map() function to project these coordinates onto the Basemap instance. The scatter() method is then used to plot these projected points on the map as red markers. from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt import numpy as np # Create a Basemap instance with a specific projection and bounding coordinates map = Basemap( projection=”merc”, llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180, urcrnrlon=180, resolution=”c”) # Draw coastlines and countries map.drawcoastlines() map.drawcountries() # Generate random data (longitude, latitude) for plotting num_points = 100 lons = np.random.uniform(low=-180.0, high=180.0, size=num_points) lats = np.random.uniform(low=-80.0, high=80.0, size=num_points) # Plot the data points on the map x, y = map(lons, lats) # Project the latitudes and longitudes to map coordinates map.scatter(x, y, marker=”o”, color=”red”, zorder=10) # Plotting the data points # Show the map with plotted data plt.title(”Data Points on Map”) plt.show() Output Display the Map We can use Matplotlib library to show() function to display the final map. Example Here”s an example demonstrating the usage of Basemap to create a map and plot data points. from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt import numpy as np # Creating a Basemap instance with a specific projection and bounding coordinates map = Basemap( projection=”merc”, llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180, urcrnrlon=180, resolution=”c”) # Drawing coastlines, countries, and states map.drawcoastlines() map.drawcountries() map.drawstates() # Generating random data for plotting num_points = 100 lons = np.random.uniform(low=-180.0, high=180.0, size=num_points) lats = np.random.uniform(low=-80.0, high=80.0, size=num_points) data_values = np.random.rand(num_points) * 100 # Random values for data # Plotting data points on the map x, y = map(lons, lats) # Projecting latitudes and longitudes to map coordinates map.scatter(x, y, c=data_values, cmap=”viridis”, marker=”o”, alpha=0.7) # Adding a colorbar to represent the data values plt.colorbar(label=”Data Values”) # Display the map with plotted data plt.title(”Basemap Example with Data Points”) plt.show() Output Applications of Matplotlib Basemap Geospatial Analysis − Analyzing and visualizing geographical data such as climate patterns, population distributions or seismic activities. Cartography − Creating custom maps for publications, presentations or research purposes. Data Visualization − Integrating geographical data with other datasets for exploratory data analysis. Note Matplotlib Basemap is being phased out in favor of newer geospatial libraries like Cartopy which offer more extensive functionality and better integration with Matplotlib. Cartopy builds on the concepts of Basemap but provides a more modern, flexible and actively developed interface for handling geospatial data within Matplotlib. Print Page Previous Next Advertisements ”;
Matplotlib – PostScript ”; Previous Next PostScript is a page description language and a dynamically typed, stack-based programming language often abbreviated as PS. Created by Adobe Systems in the early 1980s, its primary purpose is to describe the layout and graphics of printed pages. It is widely used in electronic publishing and desktop publishing applications. A PostScript file can be printed or displayed on different devices without losing quality. This is the key advantage when generating plots for different purposes. PostScript in Matplotlib In the context of Matplotlib, PostScript serves as a backend rendering engine (used for displaying figures on the screen or writing to files), enabling users to generate publication-quality plots and graphics. When you choose the PostScript backend, Matplotlib generates PostScript code to describe the layout and appearance of the plot. The PostScript code generated by Matplotlib includes instructions for drawing lines, shapes, text, and other graphical elements on a page. These instructions are written in the PostScript programming language. The Matplotlib PostScript Backend (matplotlib.backends.backend_ps) can produce both .ps and .eps files. Create a PostScript file Let”s explore how to create a simple plot and save it as a PostScript file using Matplotlib. Example 1 This example demonstrates how to create a simple plot with wrapped text and saves it as a PostScript file(.ps). import matplotlib import matplotlib.pyplot as plt import textwrap from pylab import * # Generate a string containing printable characters (ASCII 32 to 126) text_to_wrap = “”.join(c for c in map(chr, range(32, 127)) if c.isprintable()) # Wrap the string to fit within the figure wrapped_text = “n”.join(textwrap.wrap(text_to_wrap)) # Add the wrapped text to the figure figtext(0, 0.5, wrapped_text) # Save the figure to a PostScript file named “test.ps” savefig(“test.ps”) print(”Successfully created the PostScript (PS) file…”) Output If you visit the folder where the Output is saved you can observe resultant PostScript file named test.ps. Successfully created the PostScript (PS) file… Example 2 Here is another example that demonstrates how to use the PostScript backend to generate a plot and save it to an encapsulated PostScript (EPS) file. import numpy as np from matplotlib import pyplot as plt # Generate data x_data = np.linspace(1, 10, 100) y_data = np.sin(x_data) # Create the plot plt.plot(x_data, y_data, c=”green”, marker=”o”) plt.grid() # Save the figure to a PostScript file named “example.eps” plt.savefig(“example.eps”) print(”Successfully created the encapsulated PostScript (EPS) file…”) Output If you visit the folder where the Output is saved you can observe resultant PostScript file named example.eps. Successfully created the encapsulated PostScript (EPS) file… Customizing PostScript Output Adjusting the PostScript output settings in Matplotlib allows you to enhance the visual quality of Encapsulated PostScript (EPS) files. By default, Matplotlib uses a distillation process when creating EPS files. This distillation step removes specific PostScript operators that LaTeX considers illegal in an EPS file. One effective workaround involves modifying the resolution parameter to achieve better visual results. The rcParams[“ps.distiller.res”] parameter controls the resolution of the EPS files, with the default value set to 6000. Increasing this value can result in larger files but may significantly improve visual quality and maintain reasonable scalability. Example 1 This example demonstrates how adjusting resolution parameter can enhance the visual quality of EPS files. import numpy as np import matplotlib.pyplot as plt # Set the resolution for EPS files plt.rcParams[“ps.distiller.res”] = 12000 # Set the figure size and enable autolayout plt.rcParams[“figure.figsize”] = [7, 3.50] plt.rcParams[“figure.autolayout”] = True # Generate data x_data = np.linspace(1, 10, 100) y_data = np.sin(x_data) # Plotting plt.plot(x_data, y_data, label=”Sine Wave”, color=”green”) # Save the figure as an EPS file plt.savefig(”Output customized file.eps”, format=”eps”, bbox_inches=”tight”) print(”Successfully created the output customized PostScript (EPS) file…”) Output If you visit the folder where the Output is saved you can observe resultant PostScript file named Output customized file.eps. Successfully created the output customized PostScript (EPS) file… Example 2 Here is an example that demonstrates how the transparency is preserved when saving the plot as an .eps file by setting the transparent=True parameter in the savefig() function. import numpy as np import matplotlib.pyplot as plt # Adjust figure size and autolayout plt.rcParams[“figure.figsize”] = [7.50, 3.50] plt.rcParams[“figure.autolayout”] = True # Generate data x_data = np.linspace(1, 10, 100) y_data = np.sin(x_data) # Plot data with transparency plt.plot(x_data, y_data, c=”green”, marker=”o”, alpha=.35, ms=10, lw=1) plt.grid() # Save plot as .eps by preserving the transparency plt.savefig(“lost_transparency_img.eps”, transparent=True) # Display plot plt.show() Output On executing the above code you will get the following output − Whenever plots are saved in .eps/.ps, then the transparency of the plots get lost. You can observe the difference in th eabove image. Print Page Previous Next Advertisements ”;
Matplotlib – Ribbon Box ”; Previous Next In general, a “ribbon box” is a graphical representation used to visualize data distributions across different categories or groups. The term “ribbon box” refers to a specific type of plot that displays these distributions in a visually appealing and informative manner. It is particularly useful when you have multiple categories or groups and want to compare the distributions of a variable across these categories. In a ribbon box plot − Each category or group is typically represented along the x-axis. The y-axis often represents the range or distribution of a numeric variable. Each “ribbon” corresponds to the distribution of the numeric variable within a particular category or group. The ribbon can be shaded or colored to indicate the density or intensity of the distribution within each category. This allows for easy comparison of distributions across different categories. Here, we created a simple ribbon box plot with three categories (Category 1, Category 2, Category 3) along the x-axis and their corresponding distribution of values along the y-axis. We shade the ribbon boxes to indicate the intensity of the distribution within each category. Ribbon Box in Matplotlib In Matplotlib, a “ribbon box” is a visual representation used to display the distribution of a numeric variable across different categories or groups. While matplotlib does not have a specific function to create ribbon box plots, you can use other techniques available, such as − Use matplotlib”s plot() function to plot the central line for each category or group. This line represents the central tendency of the data within each category, such as the mean or median. Using the fill_between function to fill the area between two curves, where one curve represents the upper boundary of the ribbon and the other curve represents the lower boundary. Customize the appearance of the plot as needed by adding labels, titles, legends, gridlines, etc. Ribbon Box Plot with Confidence Interval In matplotlib, a simple ribbon box plot with confidence interval is a graphical representation used to display the central tendency of a dataset along with the uncertainty around that central value. It is like plotting the average of something (like daily temperatures) and shading an area around it to show how much the actual values might vary due to uncertainty. Example In the following example, we are creating a ribbon box plot showing the central tendency and confidence interval (uncertainity) around a sine wave, using matplotlib”s plot() and fill_between() functions, respectively − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(0, 10, 100) y_mean = np.sin(x) # Standard deviation y_std = 0.1 # Plotting the central line plt.plot(x, y_mean, color=”blue”, label=”Mean”) # Plotting the shaded area representing the uncertainty (confidence interval) plt.fill_between(x, y_mean – y_std, y_mean + y_std, color=”blue”, alpha=0.2, label=”Uncertainty”) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Simple Ribbon Box Plot with Confidence Interval”) plt.legend() plt.grid(True) plt.show() Output Following is the output of the above code − Multiple Ribbon Box Plots In Matplotlib, multiple ribbon box plots are a way to compare the distributions of multiple datasets using ribbon box plots within the same plot. Each ribbon box plot represents the spread and central tendency of a different dataset, allowing for easy comparison between them. Example In here, we are generating multiple ribbon box plots with different colors to represent two sine and cosine waves along with their uncertainty bands using matplotlib − import matplotlib.pyplot as plt import numpy as np # Generating data x = np.linspace(0, 10, 100) y_means = [np.sin(x), np.cos(x)] # Standard deviations y_stds = [0.1, 0.15] colors = [”blue”, ”green”] # Plotting multiple ribbon box plots with different colors for y_mean, y_std, color in zip(y_means, y_stds, colors): plt.plot(x, y_mean, color=color, label=”Mean”, alpha=0.7) plt.fill_between(x, y_mean – y_std, y_mean + y_std, color=color, alpha=0.2) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Multiple Ribbon Box Plots with Different Colors”) plt.legend() plt.grid(True) plt.show() Output On executing the above code we will get the following output − Stacked Ribbon Box Plot In Matplotlib, stacked ribbon box plots are a type of graphical representation used to compare the distributions of multiple datasets while also showing the combined distribution of all the datasets. In a stacked ribbon box plot, each dataset is represented by its own ribbon box plot, just like in multiple ribbon box plots. However, instead of displaying the box plots side by side, they are stacked vertically on top of each other. This stacking allows for a direct comparison of the distributions of each dataset while also showing how they contribute to the overall distribution when combined. Example Now, we are plotting a stacked ribbon box plot, stacking the distributions of a sine and cosine wave to compare their variations across the x-axis using matplotlib − import matplotlib.pyplot as plt import numpy as np # Generating example data x = np.linspace(0, 10, 100) y1 = np.sin(x) y2 = np.cos(x) # Plotting stacked ribbon box plot plt.plot(x, y1, color=”blue”, label=”Dataset 1”) plt.fill_between(x, y1, color=”blue”, alpha=0.2) plt.plot(x, y2, color=”green”, label=”Dataset 2”) plt.fill_between(x, y2, color=”green”, alpha=0.2) plt.xlabel(”X”) plt.ylabel(”Y”) plt.title(”Stacked Ribbon Box Plot”) plt.legend() plt.grid(True) plt.show() Output After executing the above code, we get the following output − Horizontal Ribbon Box Plot A horizontal ribbon box plot in Matplotlib is a graphical representation that shows the distribution of a dataset along a horizontal axis using ribbon-shaped boxes. In a horizontal ribbon box plot, the dataset”s values are grouped into categories or bins, and for each category, a ribbon-shaped box is drawn horizontally. The length of each box represents the range of values within that category, while the position along the horizontal axis indicates the category itself. Example In the following example,
Matplotlib – Ellipse with Units ”; Previous Next An ellipse is a geometric shape that looks like a stretched circle. It is defined by two key properties: its major axis (the longest diameter) and its minor axis (the shortest diameter). These axes intersect at the center of the ellipse, and the shape of an ellipse is determined by the lengths of these axes. Both the distance from the center to the edge along the major axis and the distance from the center to the edge along the minor axis are important. In terms of units, you would measure these distances using some kind of unit, like inches, centimeters, or any other measurement you choose. So, when we say an ellipse with units, we mean that we are using specific measurements (units) to describe the size of the ellipse, considering both the length of the major axis and the length of the minor axis. Ellipse with Units in Matplotlib We can create an ellipse with units in Matplotlib using the “Ellipse” class in the “matplotlib.patches” module. The Ellipse class allows you to define the center, width and height (major and minor axes), angle of rotation, and other properties of the ellipse such as its rotation angle. The units of measurement for the axes depend on the coordinate system you are using. For example, if you are working with a plot in inches, the major and minor axes lengths would be in inches. Fixed Size Ellipse in Data Coordinates In Matplotlib, creating a fixed size ellipse in data coordinates involves drawing an ellipse on a plot with a specific size and position determined by data coordinates. This means that the dimensions of the ellipse are specified in the same units as your actual data. For instance, if you have a dataset with x and y values, you can draw an ellipse where the center is located at a particular (x, y) point, and the width and height of the ellipse are defined in terms of the data coordinates. Example we are drawing a simple ellipse with a fixed size specified in data coordinates. The center of the ellipse is located at (3, 5) on the plot, and the width is set to “4” units in meters, while the height is set to “2” units − import matplotlib.pyplot as plt from matplotlib.patches import Ellipse # Creating a plot fig, ax = plt.subplots() # Ellipse in data coordinates (units: meters) ellipse = Ellipse((3, 5), width=4, height=2, edgecolor=”b”, facecolor=”none”) ax.add_patch(ellipse) # Setting plot title and labels ax.set_title(”Fixed Size Ellipse in Data Coordinates”) ax.set_xlabel(”X-axis (meters)”) ax.set_ylabel(”Y-axis (meters)”) # Setting aspect ratio to ”equal” ax.set_aspect(”equal”) # Adjusting axis limits ax.set_xlim(0, 6) ax.set_ylim(3, 7) # Displaying dimensions plt.text(3, 5, f”Width: 4 metersnHeight: 2 meters”, ha=”center”, va=”center”, color=”red”, fontsize=10) plt.show() Output Following is the output of the above code − Ellipse with Variable Size in Axes Coordinates Creating an ellipse with variable size in axes coordinates in Matplotlib involves drawing an ellipse on a plot where the dimensions are specified in terms of the axes, rather than the actual data. In other words, the width and height of the ellipse are given as a percentage of the total length of the x and y axes, respectively. For example, if you want to visualize an ellipse that always covers 60% of the x-axis and 30% of the y-axis, regardless of the specific data values, you can use axes coordinates. This is particularly useful when you want the size of the ellipse to be relative to the overall dimensions of the plot. Example In here, we are drawing a an ellipse with a variable size specified in axes coordinates. The center of the ellipse is placed at (0.5, 0.5), which corresponds to the center of the plot. The width and height are set to 60% and 30% of the respective axis lengths, allowing the ellipse to scale with changes in the axes − import matplotlib.pyplot as plt from matplotlib.patches import Ellipse # Creating a plot fig, ax = plt.subplots() # Ellipse in axes coordinates ellipse = Ellipse((0.5, 0.5), width=0.6, height=0.3, edgecolor=”r”, facecolor=”none”, transform=ax.transAxes) ax.add_patch(ellipse) # Setting plot title and labels ax.set_title(”Ellipse with Variable Size in Axes Coordinates”) ax.set_xlabel(”X-axis (normalized)”) ax.set_ylabel(”Y-axis (normalized)”) # Displaying dimensions in the output plt.text(0.5, 0.5, f”Width: 0.6 (normalized)nHeight: 0.3 (normalized)”, ha=”center”, va=”center”, color=”blue”, fontsize=10, transform=ax.transAxes) plt.show() Output On executing the above code we will get the following output − Ellipse Centered at Figure Origin Creating an ellipse centered at figure origin in Matplotlib involves drawing an ellipse on a plot with its center positioned at the origin of the entire figure. The origin is the point (0, 0) in the coordinate system of the figure. In this case, the width and height of the ellipse are specified in the units of the figure, and the center of the ellipse is precisely at the origin. This demonstrates how to position an ellipse with respect to the overall figure rather than the individual axes. Example In the example below, we are creating an ellipse with its center at the origin of the figure (0, 0). The width is set to 4 units, and the height is set to 2 units − import matplotlib.pyplot as plt from matplotlib.patches import Ellipse import numpy as np # Creating a plot fig, ax = plt.subplots() # Ellipse centered at figure origin ellipse = Ellipse((0, 0), width=4, height=2, edgecolor=”g”, facecolor=”none”, transform=ax.transData) ax.add_patch(ellipse) # Marking the center with a marker center_x, center_y = 0, 0 ax.plot(center_x, center_y, marker=”o”, markersize=8, color=”red”, label=”Center”) # Dotted line to represent the center ax.plot([center_x, center_x], [center_y, center_y], ”r–”) # Horizontal and vertical lines passing through the center ax.axhline(center_y, color=”blue”, linestyle=”–”, label=”Horizontal Line”) ax.axvline(center_x, color=”purple”,