Easily Save MATLAB Figures: An Introduction to savefig

By /

Okay, here is a detailed article introducing the savefig function in MATLAB, aiming for approximately 5000 words.

Easily Save MATLAB Figures: An Introduction to savefig

MATLAB is an indispensable tool for engineers, scientists, and researchers worldwide, providing a powerful environment for numerical computation, data analysis, algorithm development, and, crucially, data visualization. Generating informative plots and figures is often a primary output of MATLAB work, allowing users to understand trends, present findings, and communicate complex information effectively. However, simply creating a figure on the screen is often not enough. You need to save these visualizations for reports, presentations, publications, or later analysis.

While MATLAB’s interactive figure window offers a “File > Save As…” menu, relying solely on manual clicking becomes inefficient, inconsistent, and non-reproducible, especially when dealing with multiple figures or integrating figure generation into automated scripts. This is where programmatic figure saving comes into play, and one of the fundamental functions for this task is savefig.

This article provides a comprehensive introduction to the savefig function in MATLAB. We will delve into its purpose, syntax, usage, benefits, limitations, and how it compares to other figure-saving functions like saveas, print, and the modern exportgraphics. By the end, you’ll understand precisely when and how to use savefig effectively within your MATLAB workflows.

Table of Contents

  1. The Importance of Programmatic Figure Saving
    • Reproducibility
    • Automation and Efficiency
    • Consistency
    • Integration into Workflows
    • Batch Processing
  2. Introducing savefig: Saving the MATLAB Figure Object
    • What is savefig?
    • The .fig File Format: A Native MATLAB Representation
  3. Basic savefig Syntax and Usage
    • Saving the Current Figure
    • Specifying a Filename and Path
    • Code Example: A Simple Plot and Save
  4. Working with Figure Handles
    • What are Figure Handles?
    • Identifying the Current Figure (gcf)
    • Creating Figures Explicitly and Getting Handles
    • Saving Specific Figures Using Handles
    • Code Example: Managing and Saving Multiple Figures
  5. The Power and Purpose of .fig Files
    • Complete Representation: Preserving All Properties
    • Editability: Modifying Figures After Saving
    • Data Linking (Potential Caveats)
    • Platform Independence (Within MATLAB Versions)
    • Loading .fig Files with openfig
    • Code Example: Saving, Closing, Loading, and Modifying
  6. savefig vs. Other MATLAB Saving Functions: Making the Right Choice
    • saveas: The Versatile Predecessor
      • Syntax and Comparison
      • Use Cases and Limitations
    • print: The Powerful Exporter (Legacy and Advanced Use)
      • Syntax and Device Drivers (-dpng, -depsc, etc.)
      • Control Over Resolution, Rendering
      • Complexity and Historical Context
    • exportgraphics: The Modern Standard for Exporting
      • Recommended Approach for Images/Vector Graphics (PNG, JPEG, PDF, EPS)
      • Simplified Syntax and Improved Consistency
      • Key Options (Resolution, BackgroundColor, ContentType)
      • When to Use exportgraphics Instead of savefig
    • Summary Table: savefig vs. saveas vs. print vs. exportgraphics
  7. Advanced savefig Considerations
    • The 'compact' Option (Less Common Now)
    • Handling File Paths and Directories Programmatically
    • Error Handling (e.g., Folder Doesn’t Exist)
  8. Automating Figure Saving in Scripts and Loops
    • Generating Dynamic Filenames (sprintf)
    • Saving Figures Based on Iteration or Data
    • Code Example: Batch Plotting and Saving
  9. Best Practices for Using savefig
    • Use Meaningful and Descriptive Filenames
    • Organize Saved Figures Logically (Subdirectories)
    • Explicitly Use Figure Handles
    • Know When to Use .fig vs. Export Formats
    • Version Control Considerations for .fig Files
    • Comment Your Saving Code
  10. Common Pitfalls and How to Avoid Them
    • Overwriting Existing Files Unintentionally
    • Saving the Wrong Figure (Handle Management)
    • Saving Empty or Undesired Figures (Timing Issues)
    • Incorrect File Paths or Permissions
    • Large .fig File Sizes for Complex Figures
    • .fig File Version Compatibility Issues
  11. Putting It All Together: A More Comprehensive Example
    • Generating Multiple Plots with Subplots
    • Adding Annotations and Customizations
    • Saving Both .fig (using savefig) and PNG (using exportgraphics)
  12. Conclusion: savefig as a Foundational Tool

1. The Importance of Programmatic Figure Saving

Before diving into savefig specifically, let’s establish why saving figures using code, rather than manual clicks, is crucial for effective MATLAB usage.

  • Reproducibility: Science and engineering demand reproducibility. If you generate figures manually, it’s difficult to guarantee that you can recreate the exact same figure later, especially if parameters change or data is updated. Saving figures programmatically ensures that the saving step is part of your documented, repeatable code. Anyone (including your future self) can run the script and get the identical figure output (assuming the same MATLAB version and data).
  • Automation and Efficiency: Imagine you need to generate and save plots for dozens of datasets, different parameter variations, or time steps in a simulation. Manually saving each figure would be incredibly tedious and time-consuming. Programmatic saving allows you to automate this process within loops or functions, saving hours of effort and reducing the chance of manual errors.
  • Consistency: Manual saving often leads to inconsistencies in filenames, file types, or figure appearance (if minor tweaks are made interactively before saving). Code ensures every figure is saved using the same conventions, format, and potentially the same appearance settings (if those are also set programmatically).
  • Integration into Workflows: MATLAB scripts often perform a sequence of tasks: load data, process it, perform calculations, visualize results, and save outputs. Programmatic figure saving integrates seamlessly into this workflow. The figure generation and saving happen automatically as part of the script’s execution, without requiring user intervention.
  • Batch Processing: For large-scale analyses or simulations running on clusters or overnight, user interaction is impossible. Programmatic saving is the only way to capture the graphical results generated during these unattended runs.

Using functions like savefig transforms figure saving from a manual chore into an integral, reliable part of your computational process.

2. Introducing savefig: Saving the MATLAB Figure Object

Now, let’s focus on savefig.

  • What is savefig?
    savefig is a MATLAB function specifically designed to save a MATLAB figure to a file using the native MATLAB Figure (.fig) format. Its primary purpose is to create a complete, high-fidelity representation of the figure as a MATLAB object.

  • The .fig File Format: A Native MATLAB Representation
    This is the crucial distinguishing feature of savefig. It doesn’t save your plot as a standard image file like a PNG, JPEG, or PDF that you might embed directly into a document (though other functions do that). Instead, it saves a .fig file. Think of a .fig file as a “snapshot” of the entire figure object, including:

    • The axes, lines, surfaces, text labels, legends, colorbars, etc.
    • All associated properties (colors, line styles, font sizes, axis limits, camera position for 3D plots, etc.).
    • The underlying data used to generate the plot elements (often, but with some complexities regarding data linking).
    • Information about the figure window itself.

    Because it saves the figure as a MATLAB object, a .fig file can be re-opened in MATLAB later, and it will appear exactly as it was saved, and it will be editable. You can use the plot tools, change properties, add annotations, or even access the underlying data (usually) just as if you had just created the figure.

3. Basic savefig Syntax and Usage

The syntax for savefig is relatively straightforward.

  • Saving the Current Figure:
    The simplest form saves the currently active figure window (gcf – Get Current Figure) to a file named filename.fig in the current MATLAB directory.

    matlab
    savefig('filename.fig')
    You must include the .fig extension in the filename. savefig exclusively creates .fig files.

  • Specifying a Filename and Path:
    You can provide a full or relative path to save the figure in a specific location.

    “`matlab
    % Save in the current directory
    savefig(‘my_figure_name.fig’);

    % Save in a subdirectory (assuming ‘results’ exists)
    savefig(‘results/simulation_plot.fig’);

    % Save using an absolute path (example for Windows)
    % savefig(‘C:\Users\YourUser\Documents\MATLAB\ProjectAlpha\output.fig’);

    % Save using an absolute path (example for Linux/macOS)
    % savefig(‘/home/youruser/matlab_projects/project_alpha/output.fig’);
    It's good practice to use `fullfile` to construct paths programmatically, making your code more robust across different operating systems:matlab
    outputDir = ‘results’;
    if ~exist(outputDir, ‘dir’)
    mkdir(outputDir); % Create the directory if it doesn’t exist
    end
    filename = ‘my_data_plot.fig’;
    fullPath = fullfile(outputDir, filename);
    savefig(fullPath);
    disp([‘Figure saved to: ‘, fullPath]);
    “`

  • Code Example: A Simple Plot and Save:

    “`matlab
    % Generate some data
    x = linspace(0, 2*pi, 100);
    y1 = sin(x);
    y2 = cos(x);

    % Create a figure window
    figure; % Good practice to create a new figure explicitly

    % Plot the data
    plot(x, y1, ‘b-‘, ‘LineWidth’, 1.5);
    hold on; % Keep the current plot active for adding more data
    plot(x, y2, ‘r–‘, ‘LineWidth’, 1.5);
    hold off; % Release the hold

    % Add labels and title
    title(‘Sine and Cosine Functions’);
    xlabel(‘Angle (radians)’);
    ylabel(‘Value’);
    legend(‘sin(x)’, ‘cos(x)’);
    grid on;

    % — Save the figure using savefig —
    outputFilename = ‘sine_cosine_plot.fig’;
    try
    savefig(outputFilename);
    disp([‘Figure successfully saved as: ‘, outputFilename]);
    catch ME
    disp([‘Error saving figure: ‘, ME.message]);
    end

    % You can now find ‘sine_cosine_plot.fig’ in your current MATLAB directory.
    % You can close the figure window now. The saved .fig file persists.
    % close(gcf); % Uncomment to close the figure after saving
    “`

    After running this code, you will have a file named sine_cosine_plot.fig. You can double-click this file in the MATLAB file browser or use the openfig command (discussed later) to reopen it.

4. Working with Figure Handles

While savefig('filename.fig') saves the current figure, relying on “current” can be risky in complex scripts where multiple figures might be generated or brought into focus unintentionally. A much more robust approach is to use figure handles.

  • What are Figure Handles?
    In MATLAB, nearly everything you create in a figure (the figure window itself, axes, lines, text, etc.) is an object with associated properties. A handle is simply a unique identifier (essentially a number or, in newer MATLAB versions, an object) that refers to a specific graphics object. You can use this handle to target operations, like saving or modification, to that specific object.

  • Identifying the Current Figure (gcf)
    The command gcf stands for “Get Current Figure”. It returns the handle of the currently active figure window (the one most recently created, clicked on, or plotted into). savefig('filename.fig') implicitly uses gcf.

  • Creating Figures Explicitly and Getting Handles
    When you create a figure, you can capture its handle directly:

    “`matlab
    % Create a figure and store its handle in the variable ‘fig1’
    fig1 = figure;
    plot(1:10, rand(1, 10));
    title(‘Figure 1: Random Data’);

    % Create a second figure and store its handle in ‘fig2’
    fig2 = figure;
    plot(1:10, (1:10).^2);
    title(‘Figure 2: Squared Data’);

    % fig1 and fig2 now hold unique handles to their respective figures.
    % Note that fig2 is now the ‘current’ figure (gcf).
    You can also assign specific numbers to figures, which also serve as handles (though less flexible than object handles):matlab
    figure(10); % Creates figure number 10 (or brings it to focus if it exists)
    plot(randn(100,1));
    title(‘Figure 10’);
    “`

  • Saving Specific Figures Using Handles
    The primary syntax for saving a specific figure using its handle is:

    matlab
    savefig(figure_handle, 'filename.fig')
    Here, figure_handle is the variable holding the handle to the figure you want to save.

  • Code Example: Managing and Saving Multiple Figures

    “`matlab
    % — Figure 1: Sine Wave —
    x = linspace(0, 4*pi, 200);
    y_sin = sin(x);

    h_fig1 = figure; % Get handle for figure 1
    plot(x, y_sin, ‘m-‘);
    title(‘Figure 1: Sine Wave’);
    xlabel(‘X’);
    ylabel(‘sin(X)’);
    grid on;

    % — Figure 2: Cosine Wave —
    y_cos = cos(x);

    h_fig2 = figure; % Get handle for figure 2
    plot(x, y_cos, ‘c–‘);
    title(‘Figure 2: Cosine Wave’);
    xlabel(‘X’);
    ylabel(‘cos(X)’);
    grid on;

    % — Figure 3: Tangent Wave (potentially large Y values) —
    y_tan = tan(x/2); % Example with different characteristics

    h_fig3 = figure; % Get handle for figure 3
    plot(x, y_tan, ‘k.’);
    title(‘Figure 3: Tangent Wave’);
    xlabel(‘X’);
    ylabel(‘tan(X/2)’);
    ylim([-10, 10]); % Limit y-axis for better visualization
    grid on;

    % — Save specific figures using their handles —
    outputDir = ‘multiple_figs_output’;
    if ~exist(outputDir, ‘dir’), mkdir(outputDir); end

    % Save Figure 1
    filename1 = fullfile(outputDir, ‘sine_wave_plot.fig’);
    try
    savefig(h_fig1, filename1);
    disp([‘Saved Figure 1 to: ‘, filename1]);
    catch ME
    disp([‘Error saving Figure 1: ‘, ME.message]);
    end

    % Save Figure 3 (demonstrating non-sequential saving)
    filename3 = fullfile(outputDir, ‘tangent_wave_plot.fig’);
    try
    savefig(h_fig3, filename3);
    disp([‘Saved Figure 3 to: ‘, filename3]);
    catch ME
    disp([‘Error saving Figure 3: ‘, ME.message]);
    end

    % Optionally save Figure 2 as well
    filename2 = fullfile(outputDir, ‘cosine_wave_plot.fig’);
    try
    savefig(h_fig2, filename2); % Using the handle h_fig2
    disp([‘Saved Figure 2 to: ‘, filename2]);
    catch ME
    disp([‘Error saving Figure 2: ‘, ME.message]);
    end

    % Even if Figure 1 is the current figure now (e.g., if you clicked on it),
    % the savefig commands above used the specific handles, ensuring the correct
    % figures were saved.

    % Example: Make figure 1 current and save it again without handle
    % figure(h_fig1); % Bring figure 1 to the front
    % savefig(fullfile(outputDir,’current_figure_is_fig1.fig’)); % Saves fig 1

    % Close all figures
    % close(h_fig1);
    % close(h_fig2);
    % close(h_fig3);
    “`
    Using handles makes your code unambiguous and is highly recommended for any script generating more than one figure.

5. The Power and Purpose of .fig Files

We’ve established that savefig creates .fig files. Why is this format useful?

  • Complete Representation: As mentioned, a .fig file stores almost everything about the figure object. When you reopen it, it should look identical to how it was saved, including 3D view angles, complex annotations, UI controls added to the figure, etc. Exported formats like PNG or JPEG are just “flattened” pixel representations and lose this richness. Vector formats like EPS or PDF retain scalability but lose MATLAB-specific interactivity and structure.
  • Editability: This is arguably the most significant advantage. Open a .fig file in MATLAB, and you can interact with it just like a newly created figure. You can:
    • Use the plot edit toolbar (zoom, pan, data cursor, insert legend, etc.).
    • Open the Property Inspector (usually by double-clicking elements or using the inspect command) to change colors, line styles, fonts, axis limits, titles, labels, etc.
    • Add new data series or annotations.
    • Run MATLAB commands to modify the figure (e.g., set(gca, 'XLim', [0 5])).
    • Extract the data from plots (often possible via findobj and accessing XData, YData, etc., properties).
  • Data Linking (Potential Caveats): In some cases, .fig files can maintain links to the original workspace variables used for plotting if saved from the GUI. However, this is less reliable when saved programmatically with savefig and often not the primary reason for using .fig files. It’s usually safer to assume you need the original data separately if complex reprocessing is required. The primary benefit is editing the visual properties and structure.
  • Platform Independence (Within MATLAB Versions): .fig files saved on one operating system (Windows, macOS, Linux) can typically be opened on another, provided the MATLAB versions are compatible. However, significant jumps in MATLAB versions (e.g., R2012b to R2023a) might sometimes lead to rendering differences or warnings, as the underlying graphics system has evolved. Minor version differences are usually fine.

  • Loading .fig Files with openfig:
    The command to load a .fig file back into the MATLAB workspace is openfig.

    “`matlab
    % Basic usage: Opens the figure and makes it visible
    openfig(‘my_figure_name.fig’);

    % Open the figure and get its handle, without necessarily making it visible
    % ‘invisible’: Prevents the figure from popping up on screen immediately
    % ‘new’: Ensures it opens as a new instance, not replacing an existing figure
    h_loaded_fig = openfig(‘results/simulation_plot.fig’, ‘new’, ‘invisible’);

    % Now you can manipulate the loaded figure using its handle h_loaded_fig
    % For example, change the title:
    % set(h_loaded_fig, ‘Name’, ‘Loaded and Modified Figure’); % Change window title bar
    % title(findobj(h_loaded_fig, ‘Type’, ‘Axes’), ‘New Plot Title’); % Change plot title

    % Make the figure visible if it was loaded invisibly
    % set(h_loaded_fig, ‘Visible’, ‘on’);
    “`

  • Code Example: Saving, Closing, Loading, and Modifying:

    “`matlab
    % — Create and Save a Figure —
    x = 1:10;
    y = x.^2;
    h_orig = figure(‘Name’, ‘Original Square Plot’); % Give window a name
    plot(x, y, ‘bs-‘);
    title(‘Original Plot’);
    xlabel(‘X’);
    ylabel(‘Y = X^2’);
    grid on;

    originalFilename = ‘editable_plot.fig’;
    savefig(h_orig, originalFilename);
    disp([‘Original figure saved to: ‘, originalFilename]);

    % Close the original figure
    close(h_orig);
    disp(‘Original figure closed.’);

    % — Load the Figure —
    disp(‘Loading the saved .fig file…’);
    try
    % Load invisibly first to modify before showing
    h_loaded = openfig(originalFilename, ‘new’, ‘invisible’);
    disp(‘Figure loaded successfully.’);

    % --- Modify the Loaded Figure ---
disp('Modifying the loaded figure...');

% Find the axes within the loaded figure
ax_loaded = findobj(h_loaded, 'Type', 'Axes');

if ~isempty(ax_loaded)
    % Change the title
    title(ax_loaded, 'Loaded and Modified Plot');

    % Change the line color and style
    line_handle = findobj(ax_loaded, 'Type', 'Line');
    if ~isempty(line_handle)
        set(line_handle, 'Color', 'red', 'LineStyle', ':', 'Marker', 'o');
    end

    % Change axis label
    ylabel(ax_loaded, 'Y = X^2 (Modified)');

    % Change figure window name
    set(h_loaded, 'Name', 'Modified Square Plot');

    disp('Modifications complete.');

    % Make the modified figure visible
    set(h_loaded, 'Visible', 'on');
    disp('Modified figure is now visible.');

    % --- Optionally save the modified figure ---
    modifiedFilename = 'modified_editable_plot.fig';
    % savefig(h_loaded, modifiedFilename);
    % disp(['Modified figure saved to: ', modifiedFilename]);

else
    disp('Could not find axes in the loaded figure.');
end

    catch ME
    disp([‘Error loading or modifying figure: ‘, ME.message]);
    end
    “`

    This example demonstrates the workflow: save with savefig, close, reopen with openfig, modify programmatically using the handle, and then display. This editability is the core strength of the .fig format and the primary reason to use savefig.

6. savefig vs. Other MATLAB Saving Functions: Making the Right Choice

MATLAB offers several ways to save figures, and savefig is just one piece of the puzzle. Understanding the differences is crucial for choosing the right tool for your needs.

  • saveas: The Versatile Predecessor
    saveas is an older function that can save figures in multiple formats, including .fig, as well as common image and vector formats.

    • Syntax and Comparison:
      “`matlab
      % Save as .fig (similar to savefig)
      saveas(figure_handle, ‘filename.fig’);
      saveas(gcf, ‘current_fig.fig’);

      % Save as PNG image
      saveas(figure_handle, ‘filename.png’);

      % Save as EPS vector file
      saveas(figure_handle, ‘filename.eps’, ‘epsc’); % Requires format specifier for some types
      ``
      While      saveas(h, ‘file.fig’)achieves the same primary goal assavefig(h, ‘file.fig’),savefigis generally preferred for saving.figfiles because it's specifically designed for it and potentially more optimized.saveasis more general-purpose but can sometimes have inconsistencies, especially with complex figures or newer graphics features, compared to the more modernexportgraphicsfor non-.figformats.
      * **Use Cases and Limitations:**      saveaswas the standard way to save in various formats for many years. It's still functional, but for saving standard image or vector formats (PNG, JPG, PDF, EPS),exportgraphicsis now generally recommended due to better control and consistency. If you need to save as a.figfile,savefigis the dedicated function.saveas` might still be found in legacy code.

  • print: The Powerful Exporter (Legacy and Advanced Use)
    print is the most established and arguably most powerful function for “printing” a figure to a file. It offers fine-grained control over output formats, resolution, color space, and rendering engines.

    • Syntax and Device Drivers (-dpng, -depsc, etc.):
      print uses “device” options (-d...) to specify the output format and other parameters.
      “`matlab
      % Save as PNG at screen resolution
      print(figure_handle, ‘filename.png’, ‘-dpng’);

      % Save as high-resolution PNG (e.g., 300 DPI)
      print(figure_handle, ‘high_res_plot.png’, ‘-dpng’, ‘-r300’);

      % Save as color EPS (vector format)
      print(figure_handle, ‘vector_plot.eps’, ‘-depsc’);

      % Save as PDF (often requires additional options for best results)
      print(figure_handle, ‘document_plot.pdf’, ‘-dpdf’, ‘-bestfit’); % ‘-bestfit’ helps size page

      % Save as TIFF with high resolution
      print(figure_handle, ‘publication_image.tif’, ‘-dtiff’, ‘-r600’);
      ``
      * **Control Over Resolution, Rendering:**      printprovides options like-r(resolution in DPI), renderers (-paintersfor vector,-openglfor complex 3D/transparency,-zbuffer), color space (-cmyk), etc. This makes it powerful for publication-quality output where precise control is needed.
      * **Complexity and Historical Context:** The syntax of      printcan be complex due to the multitude of options and device drivers, some of which are legacy or platform-dependent. While powerful, it can be less intuitive than newer functions. It originates from a time when sending output directly to a physical printer was a primary use case.
      * **      printvssavefig:**print*cannot* save.figfiles. Its purpose is exporting to standard document/image formats.savefig*only* saves.fig` files. They serve fundamentally different purposes.

  • exportgraphics: The Modern Standard for Exporting
    Introduced in R2020a, exportgraphics is MathWorks’ recommended function for saving figures to common image and vector formats (PNG, JPEG, TIFF, PDF, EPS). It aims to provide a simpler syntax and more consistent results than saveas and print for these common export tasks.

    • Recommended Approach for Images/Vector Graphics: If your goal is to get a PNG for a presentation, a JPEG for a website, a PDF for a report, or an EPS/PDF for a LaTeX document, exportgraphics is usually the best choice in modern MATLAB versions.

    • Simplified Syntax and Improved Consistency: It uses Name-Value pairs for options, which is more readable and consistent with other modern MATLAB functions.
      “`matlab
      % Save as PNG (default resolution usually good)
      exportgraphics(figure_handle, ‘output_plot.png’);

      % Save as PNG with specified resolution (300 DPI)
      exportgraphics(figure_handle, ‘high_res_output.png’, ‘Resolution’, 300);

      % Save as PDF (vector format, good for documents)
      exportgraphics(figure_handle, ‘document_plot.pdf’, ‘ContentType’, ‘vector’);

      % Save as EPS (vector format)
      exportgraphics(figure_handle, ‘vector_output.eps’, ‘ContentType’, ‘vector’);

      % Save as JPEG with specific quality (e.g., 90)
      exportgraphics(figure_handle, ‘web_image.jpg’, ‘Resolution’, 96, ‘Quality’, 90);

      % Save with transparent background (for PNG)
      exportgraphics(figure_handle, ‘transparent_logo.png’, ‘BackgroundColor’, ‘none’);

      % Save only the axes content, not the whole figure window gray area
      % Need to pass the axes handle (e.g., gca for current axes)
      ax_handle = gca; % Or get from figure_handle: ax_handle = findobj(figure_handle,’Type’,’Axes’);
      exportgraphics(ax_handle, ‘axes_only.pdf’, ‘ContentType’, ‘vector’);
      ``
      * **Key Options:**      Resolution,ContentType(‘vector’or‘image’),BackgroundColor,Colorspace(‘rgb’,‘cmyk’,‘gray’).
      * **When to Use      exportgraphicsInstead ofsavefig:** Useexportgraphicswhen you need a final output format for embedding in documents, presentations, or web pages (PNG, JPEG, PDF, EPS, TIFF). Usesavefigwhen you want to save the figure in a way that allows you to reopen and *edit it extensively within MATLAB* later. Often, you might use both:savefigto keep an editable master copy andexportgraphics` to produce the final output format.

  • Summary Table: savefig vs. saveas vs. print vs. exportgraphics

Feature savefig saveas print exportgraphics (Recommended for Export)
Primary Use Save editable MATLAB figure object Save in various formats (older) Export to file (image/vector), fine control Export to file (image/vector), modern standard
Output Format .fig ONLY .fig, PNG, JPG, EPS, PDF, etc. PNG, JPG, EPS, PDF, TIFF, etc. (NOT .fig) PNG, JPG, TIFF, GIF, PDF, EPS (NOT .fig)
Editability Yes (reopen in MATLAB) Yes (if saved as .fig), No (others) No No
Syntax Style Function argument Function argument + format specifier Function argument + Device drivers (-d... -r...) Function argument + Name-Value pairs
Complexity Simple Moderate High (many options) Moderate (readable options)
Modern Rec. Yes (for .fig) Less recommended (use savefig/exportgraphics) For advanced/specific cases Yes (for standard export formats)
Resolution Control N/A (saves object) Limited/Inconsistent Yes (-r<dpi>) Yes ('Resolution', dpi)
Vector Output N/A Yes (e.g., 'epsc') Yes (e.g., -depsc, -dpdf, -painters) Yes ('ContentType', 'vector')

The Rule of Thumb:

  1. Need to save a figure to reopen and edit later in MATLAB? Use savefig (outputs .fig).
  2. Need to save a figure as a standard image or vector file (PNG, JPG, PDF, EPS) for documents, presentations, etc.? Use exportgraphics (in R2020a+).
  3. Working with older MATLAB versions or need very specific, fine-grained control not offered by exportgraphics? Use print.
  4. Encountering legacy code? You might see saveas. Understand its purpose but consider updating to savefig or exportgraphics for new code.

7. Advanced savefig Considerations

While the core functionality of savefig is simple (save a figure handle to a .fig file), here are a few related points:

  • The 'compact' Option (Less Common Now):
    Older versions of MATLAB had a 'compact' option for savefig:
    matlab
    % savefig(h_fig, 'myfigure.fig', 'compact'); % Legacy syntax
    This aimed to reduce file size by not saving certain properties that could be recreated upon loading. However, its effectiveness varied, and it could sometimes lead to subtle differences when reloading. In modern MATLAB, this option is generally not needed or recommended, as MATLAB’s internal saving mechanisms have improved. Stick to the standard savefig(handle, filename) syntax unless you have a very specific reason (and understand the implications) for using 'compact'.

  • Handling File Paths and Directories Programmatically:
    As shown in earlier examples, robust scripts should handle file paths carefully.

    • Use fullfile to create paths that work across operating systems.
    • Check if output directories exist using exist(outputDir, 'dir') and create them if necessary using mkdir(outputDir).
    • Consider using relative paths for better project portability or absolute paths if figures need to be saved to a fixed location outside the project structure.

  • Error Handling (e.g., Folder Doesn’t Exist):
    Wrap your savefig calls in try...catch blocks, especially when dealing with potentially invalid paths or permissions issues. This prevents your entire script from crashing if a single figure fails to save.

    “`matlab
    outputDir = ‘/non_existent_path/results’; % Intentionally bad path
    filename = fullfile(outputDir, ‘test_save.fig’);
    h_fig = figure;
    plot(1:10);

    try
    % Attempt to save the figure
    savefig(h_fig, filename);
    disp([‘Figure saved successfully to: ‘, filename]);
    catch ME
    % Catch any error during saving
    warning([‘Failed to save figure to: ‘, filename]);
    disp([‘Error message: ‘, ME.message]);
    % Optionally, try saving to a fallback location, like the current directory
    try
    fallbackFilename = ‘fallback_save.fig’;
    savefig(h_fig, fallbackFilename);
    disp([‘Figure saved to fallback location: ‘, fallbackFilename]);
    catch ME2
    warning([‘Fallback save also failed: ‘, ME2.message]);
    end
    end
    close(h_fig); % Close the figure regardless of save success
    “`

8. Automating Figure Saving in Scripts and Loops

One of the primary motivations for programmatic saving is automation. savefig integrates perfectly into loops and functions.

  • Generating Dynamic Filenames (sprintf):
    When saving multiple figures in a loop (e.g., based on different parameters or datasets), you need unique filenames for each. The sprintf function is ideal for creating formatted strings that include loop variables or other identifiers.

  • Saving Figures Based on Iteration or Data:
    Combine figure creation, plotting, handle management, dynamic filename generation, and savefig within a loop structure.

  • Code Example: Batch Plotting and Saving

    “`matlab
    % Example: Analyze and plot results for multiple datasets

    % Simulate having multiple data files or conditions
    allDataX = {1:10, linspace(0, 1, 50), 20:30};
    allDataY = {rand(1, 10), sin(2piallDataX{2}), sqrt(allDataX{3}-19)};
    dataLabels = {‘RandomSet’, ‘SineWave’, ‘SqrtOffset’};
    numDatasets = length(allDataX);

    % — Setup Output Directory —
    outputFigDir = ‘batch_fig_output’; % For .fig files
    outputPngDir = ‘batch_png_output’; % For .png files (using exportgraphics)
    if ~exist(outputFigDir, ‘dir’), mkdir(outputFigDir); end
    if ~exist(outputPngDir, ‘dir’), mkdir(outputPngDir); end

    % — Loop Through Datasets —
    for i = 1:numDatasets
    currentX = allDataX{i};
    currentY = allDataY{i};
    currentLabel = dataLabels{i};

    % --- Create Figure and Plot ---
h_fig = figure('Name', ['Data: ', currentLabel], 'Visible', 'off'); % Create invisibly
plot(currentX, currentY, 'o-');
title(['Analysis of Dataset: ', currentLabel]);
xlabel('X Value');
ylabel('Y Value');
grid on;
legend(currentLabel, 'Location', 'best');

% --- Generate Filenames ---
% Use sprintf for formatted names. %s for string, %d for integer.
figFilename = sprintf('dataset_%s_plot_%d.fig', currentLabel, i);
pngFilename = sprintf('dataset_%s_plot_%d.png', currentLabel, i);

fullFigPath = fullfile(outputFigDir, figFilename);
fullPngPath = fullfile(outputPngDir, pngFilename);

% --- Save using savefig (for .fig) ---
try
    savefig(h_fig, fullFigPath);
    fprintf('Saved FIG: %s\n', fullFigPath);
catch ME
    warning('Failed to save FIG for dataset %d: %s\n', i, ME.message);
end

% --- Save using exportgraphics (for .png) ---
try
    exportgraphics(h_fig, fullPngPath, 'Resolution', 150); % Moderate resolution PNG
    fprintf('Saved PNG: %s\n', fullPngPath);
catch ME
    warning('Failed to save PNG for dataset %d: %s\n', i, ME.message);
end

% --- Close the Figure (important in loops!) ---
% If you don't close figures in a loop, you can run out of memory
% or system resources for very large batches.
close(h_fig);

    end

    disp(‘Batch processing complete.’);
    % Check the ‘batch_fig_output’ and ‘batch_png_output’ directories.
    ``
    This example demonstrates creating figures invisibly (    ‘Visible’, ‘off’), plotting, generating unique names usingsprintf, saving both the editable.figfile usingsavefigand a shareable PNG usingexportgraphics, and crucially, closing the figure handle (close(h_fig)`) at the end of each iteration to prevent resource exhaustion.

9. Best Practices for Using savefig

To use savefig effectively and maintain organized, reproducible workflows, consider these best practices:

  • Use Meaningful and Descriptive Filenames: plot1.fig is bad. simulation_run_alpha_temperature_vs_time.fig is much better. Include key parameters or identifiers in the filename. Use sprintf for programmatic generation.
  • Organize Saved Figures Logically: Don’t dump all .fig files into your main project directory. Create subdirectories (e.g., results/figs, analysis/plots/editable) to keep them organized. Use code (mkdir) to create these directories if needed.
  • Explicitly Use Figure Handles: Avoid relying on gcf. Always capture the handle when creating a figure (h = figure;) and pass that handle explicitly to savefig(h, filename). This prevents ambiguity.
  • Know When to Use .fig vs. Export Formats: Use savefig for master copies you might need to edit later in MATLAB. Use exportgraphics (or print) for final versions (PNG, PDF, etc.) for reports and presentations. Often, saving both is a good strategy.
  • Version Control Considerations for .fig Files: .fig files are binary and can be large. They don’t merge well in version control systems like Git. Consider:
    • Only committing essential .fig files.
    • Using Git LFS (Large File Storage) if you need to track many large .fig files.
    • Relying on the script that generates the figure as the primary version-controlled artifact, and treating .fig files as reproducible outputs (perhaps adding them to .gitignore). The best approach depends on your project needs.
  • Comment Your Saving Code: Explain why you are saving a particular figure and what it represents, especially if the filename isn’t fully self-explanatory.

10. Common Pitfalls and How to Avoid Them

Users sometimes encounter issues when saving figures. Here are common pitfalls related to savefig:

  • Overwriting Existing Files Unintentionally: savefig will overwrite existing files with the same name without warning.
    • Avoidance: Use unique, descriptive filenames (e.g., include timestamps or run IDs). Check if a file exists before saving if overwriting is undesirable (if ~exist(filename, 'file') ... end).
  • Saving the Wrong Figure (Handle Management): If you rely on gcf and your script creates or focuses multiple figures, you might save the wrong one.
    • Avoidance: Always use explicit figure handles obtained via h = figure; and pass the correct handle to savefig.
  • Saving Empty or Undesired Figures (Timing Issues): Sometimes in complex GUI callbacks or rapidly executing code, you might call savefig before plotting is fully complete, or on an unintended empty figure window.
    • Avoidance: Ensure plotting commands have finished. Use drawnow sometimes if needed to force the graphics queue to update, though usually handle management is sufficient. Save figures only after they are fully populated. Create figures invisibly ('Visible','off') and only make them visible after plotting and saving, if needed.
  • Incorrect File Paths or Permissions: Trying to save to a non-existent directory or a location where you don’t have write permissions will cause an error.
    • Avoidance: Use fullfile for path construction. Check for directory existence (exist) and create directories (mkdir). Ensure your script has write permissions in the target location. Use try...catch blocks for graceful error handling.
  • Large .fig File Sizes: Figures with very large datasets (millions of points), complex patches, or surface plots can result in very large .fig files.
    • Avoidance: Consider if you truly need to save the entire editable object. If not, use exportgraphics to save a smaller image/vector file. If the .fig is needed, be mindful of storage space. The 'compact' option (legacy) might offer minor savings but is generally not the solution. Data decimation before plotting (if appropriate) can also help.
  • .fig File Version Compatibility Issues: Opening a .fig file saved in a much newer version of MATLAB in a significantly older version might fail or render incorrectly due to changes in the graphics engine or object structure. Saving in an older version and opening in a newer one is usually more robust.
    • Avoidance: Be aware of the MATLAB versions used by collaborators or for deployment. If compatibility across vastly different versions is critical, relying on the generating script + standard export formats (exportgraphics) might be safer than relying solely on .fig files.

11. Putting It All Together: A More Comprehensive Example

Let’s combine several concepts into a script that generates a figure with subplots, adds annotations, and saves both an editable .fig file and a presentation-ready PNG file.

“`matlab
% — Comprehensive Example: Subplots, Annotations, Multiple Saves —

% — Parameters and Data Generation —
rng(123); % Set random seed for reproducibility
x = linspace(-2pi, 2pi, 200);
y1 = sin(x) + 0.1randn(size(x)); % Sine with noise
y2 = cos(x) + 0.1randn(size(x)); % Cosine with noise
y3 = exp(-0.1x.^2) . sin(3*x); % Damped oscillation

simulationID = ‘Run_XYZ789’;
timestamp = datestr(now, ‘yyyymmdd_HHMMSS’);

% — Create Figure and Get Handle —
h_mainFig = figure(‘Name’, ‘Multi-Analysis Plot’, ‘Position’, [100, 100, 800, 600]);
% Set position: [left, bottom, width, height]

% — Subplot 1: Sine Wave —
ax1 = subplot(2, 2, 1); % 2 rows, 2 columns, position 1
plot(ax1, x, y1, ‘r-‘, ‘LineWidth’, 1);
title(ax1, ‘Sine Wave with Noise’);
xlabel(ax1, ‘X’);
ylabel(ax1, ‘Amplitude’);
grid(ax1, ‘on’);
text(ax1, -pi, 0.8, ‘Peak approx’, ‘Color’, ‘blue’); % Add text annotation

% — Subplot 2: Cosine Wave —
ax2 = subplot(2, 2, 2);
plot(ax2, x, y2, ‘b–‘, ‘LineWidth’, 1);
title(ax2, ‘Cosine Wave with Noise’);
xlabel(ax2, ‘X’);
grid(ax2, ‘on’);
legend(ax2, {‘cos(x) + noise’}, ‘Location’, ‘southwest’);

% — Subplot 3: Damped Oscillation —
ax3 = subplot(2, 2, [3, 4]); % Span positions 3 and 4 (bottom row)
plot(ax3, x, y3, ‘g.-‘, ‘MarkerSize’, 8);
title(ax3, ‘Damped Oscillation: exp(-0.1x^2)sin(3x)’);
xlabel(ax3, ‘X’);
ylabel(ax3, ‘Amplitude’);
grid(ax3, ‘on’);
annotation(h_mainFig, ‘textbox’, [0.4, 0.05, 0.2, 0.05], … % Position relative to figure
‘String’, [‘Simulation: ‘, simulationID], …
‘FitBoxToText’, ‘on’, ‘EdgeColor’, ‘none’, ‘HorizontalAlignment’, ‘center’);

% — Add Overall Title (using sgtitle – R2018b+) —
if exist(‘sgtitle’, ‘builtin’) % Check if sgtitle function exists
sgtitle(h_mainFig, ‘Comprehensive Data Analysis Results’);
else
% Alternative for older versions (less elegant)
annotation(h_mainFig, ‘textbox’, [0, 0.95, 1, 0.05], …
‘String’, ‘Comprehensive Data Analysis Results’, …
‘EdgeColor’, ‘none’, ‘HorizontalAlignment’, ‘center’, …
‘FontSize’, 14, ‘FontWeight’, ‘bold’);
end

% — Prepare Output —
outputBaseDir = ‘comprehensive_output’;
outputFigSubDir = fullfile(outputBaseDir, ‘fig_files’);
outputPngSubDir = fullfile(outputBaseDir, ‘png_files’);

if ~exist(outputFigSubDir, ‘dir’), mkdir(outputFigSubDir); end
if ~exist(outputPngSubDir, ‘dir’), mkdir(outputPngSubDir); end

baseFilename = sprintf(‘analysis_%s_%s’, simulationID, timestamp);
figFilename = fullfile(outputFigSubDir, [baseFilename, ‘.fig’]);
pngFilename = fullfile(outputPngSubDir, [baseFilename, ‘.png’]);

% — Save the Editable .fig File —
try
savefig(h_mainFig, figFilename);
disp([‘Editable FIG file saved to: ‘, figFilename]);
catch ME
warning([‘Failed to save FIG file: ‘, ME.message]);
end

% — Save the Presentation-Ready .png File —
try
% Export the whole figure
exportgraphics(h_mainFig, pngFilename, ‘Resolution’, 300, ‘BackgroundColor’, ‘white’);
disp([‘Presentation PNG file saved to: ‘, pngFilename]);
catch ME
warning([‘Failed to save PNG file: ‘, ME.message]);
end

% — Optional: Close the figure after saving —
% close(h_mainFig);

disp(‘Processing and saving finished.’);
“`

This script demonstrates:
1. Creating a figure and getting its handle (h_mainFig).
2. Using subplot to create multiple axes within the figure.
3. Plotting different data on each subplot.
4. Adding titles, labels, legends, and text annotations (text, annotation).
5. Using sgtitle for an overall figure title (with fallback for older versions).
6. Generating dynamic, descriptive filenames including identifiers and timestamps.
7. Creating organized output subdirectories.
8. Using savefig to save the complete, editable .fig file.
9. Using exportgraphics to save a high-resolution PNG suitable for reports or presentations.
10. Including try...catch blocks for robust saving.

12. Conclusion: savefig as a Foundational Tool

savefig is a fundamental MATLAB function for anyone who needs to preserve their graphical work. Its unique purpose is to save MATLAB figures in the native .fig format, creating a high-fidelity, editable representation of the figure object. This is invaluable for:

  • Creating master copies of plots that might require later modification within MATLAB.
  • Archiving results in a format that retains all figure details.
  • Debugging plot generation by inspecting saved .fig files.
  • Collaborating with others who need to interact with or modify the figures in MATLAB.

However, savefig is not a universal solution for all figure saving needs. When the goal is to export figures into standard image or vector formats (like PNG, JPEG, PDF, or EPS) for use outside of MATLAB (in documents, presentations, web pages, or publications), the modern exportgraphics function (or the older print function for specific advanced cases) is the appropriate choice.

By understanding the specific role of savefig – to save editable .fig files – and how it complements other functions like exportgraphics, you can leverage the full power of MATLAB’s visualization capabilities. Incorporating programmatic saving with savefig and exportgraphics using best practices like explicit handle management, descriptive filenames, and organized directories will significantly enhance the reproducibility, efficiency, and professionalism of your MATLAB workflows. Stop clicking “Save As” and start scripting your figure saving for more robust and reliable results.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top