# How do I extract data from MATLAB figures?

2,970 views (last 30 days)
MathWorks Support Team on 10 Jul 2013
Commented: Walter Roberson on 22 Apr 2022
I have a few MATLAB figures, but no MATLAB code associated with it. I want to extract the data from the curves in the figures.

MathWorks Support Team on 11 Nov 2020
Edited: MathWorks Support Team on 5 Nov 2020
This example shows how to extract data from a MATLAB figure.
If the figure is stored in a file, such as 'example.fig', then open the figure file using 'openfig'. Assign the Figure object to the variable 'fig'.
fig = openfig('example.fig');
If the figure is already open, then use 'gcf' to access the Figure object and assign it to the variable 'fig'.
fig = gcf;
There are several ways to access the data for the plotted graphics objects. You can use the Children property or you can use 'findobj'.
Use Children Property
Access the plotted graphics objects through the Children properties. The Axes objects are children of the figure. The plotted graphics objects are typically children of the Axes object.
axObjs = fig.Children
dataObjs = axObjs.Children
The 'dataObjs' array that appears in the Command Window indicates the types of graphics objects in the axes. Different graphics objects store data differently. For example, Line objects store the data in the 'XData', 'YData', and 'ZData' properties. If the first element in 'dataObjs' is a Line object, then access its data using this code.
x = dataObjs(1).XData
y = dataObjs(1).YData
z = dataObjs(1).ZData
If the figure contains other types of graphics objects, then use the appropriate properties to access the data. For a list of graphics objects and their properties, see:
Use findobj Function
Alternatively, you can find all the graphics objects in a figure with a certain data property. For example, find all graphics objects that have a 'YData' property. Then access the 'YData' values for the first object.
dataObjs = findobj(fig,'-property','YData')
y1 = dataObjs(1).YData
Walter Roberson on 8 May 2015
lineObjs = findobj(dataObjs, 'type', 'line');
xdata = get(lineObjs, 'XData');
Walter Roberson on 4 Dec 2017
When you plot a matrix by columns, then the order of handles returned from the plot() call is the order of the columns:
data = sort(rand(20,5),2);
h = plot(data);
Now h(1) corresponds to column 1, h(2) corresponds to column 2, and so on. You can confirm this with:
h(1).DisplayName = 'col1';
h(2).DisplayName = 'col2';
h(3).DisplayName = 'col3';
h(4).DisplayName = 'col4';
h(5).DisplayName = 'col5';
legend();
and see that indeed the item labeled col5 is the one with highest average Y (it was constructed that way by the sort() call).
However, the order of axes children defaults to the reverse of this:
>> get(gca,'Children')
ans =
5×1 Line array:
Line (col5)
Line (col4)
Line (col3)
Line (col2)
Line (col1)
because the rule is that the axes children are (by default) painted from last to first (first is on top, last is on bottom). This can be altered in a few ways, including some obscure specialized settings that were new in R2014b, but also the order can be changed with good old uistack()
When you recall a figure file and pull out the axes children, the axes children are going to be in the same order as was present in the axes when it was saved to the figure file. If nothing in the original code altered the order, that is going to be last column first. So if you retrieve the YData and mat2cell() it into a 2D matrix, make sure to fliplr() to get the original order.

I was having the same error message mentioned before: "Error using get Conversion to double from cell is not possible."
I solved this issue with Walter Roberson's answer, using the following code:
open('example.fig');
a = get(gca,'Children');
xdata = get(a, 'XData');
ydata = get(a, 'YData');
zdata = get(a, 'ZData');

Yair Altman on 21 May 2018
Edited: MathWorks Support Team on 19 Apr 2021
Note that the official MathWorks answer above relies on opening and displaying the figure (using the open() function) before extracting its contents. This is both slow and potentially unwanted (we don't always want to display the figures), especially if we're looping over many FIG files.
Instead, users can directly read and analyze the *.fig file by loading it into Matlab memory using the load() function, since *.fig files are basically simple MAT files with a .fig (rather than .mat) file extension.
Fortunately, the internal format of these files has changed very little over the years - a few fields have changed their name, but the basic file data structure remained the same. So essentially the same code can be used to extract data from .fig files created a decade ago, as well as the latest Matlab release.
Note that the fact that FIG files are basically just MAT files is an undocumented feature of Matlab, and so it might change one day. But for now it is a very handy feature to use.
Walter Roberson on 20 Apr 2022
fig = openfig('figure.fig');
all_ax = findobj(fig, 'type', 'axes');
all_titles = cellfun(@(T) T.String, get(all_ax, 'title'), 'uniform', 0);
all_lines = arrayfun(@(A) findobj(A, 'type', 'line'), all_ax, 'uniform', 0);
all_XData = cellfun(@(L) get(L,'XData'), all_lines, 'uniform', 0);
all_YData = cellfun(@(L) get(L,'YData'), all_lines, 'uniform', 0);
At this point,
• all_titles is a cell array of character vectors containing the title for each axes (in latex form)
• all_XData is a cell array with one entry for each axes, and the entry is a cell array of numeric row vectors, one entry for each line in the axes
• all_YData is a cell array with one entry for each axes, and the entry is a cell array of numeric row vectors, one entry for each line in the axes
WIth that figure, there are three lines in almost all of the axes, but one of them has four lines (the legend which is attached to one of the axes only has three names defined.)
Walter Roberson on 22 Apr 2022
[filename, filepath] = uigetfile('*.fig');
if ~ischar(filename)
error('cancel');
end
fullname = fullfile(filepath, filename);
fig = openfig(fullname);
all_ax = findobj(fig, 'type', 'axes');
all_titles = cellfun(@(T) T.String, get(all_ax, 'title'), 'uniform', 0);
all_lines = arrayfun(@(A) findobj(A, 'type', 'line'), all_ax, 'uniform', 0);
all_XData = cellfun(@(L) get(L,'XData'), all_lines, 'uniform', 0);
all_YData = cellfun(@(L) get(L,'YData'), all_lines, 'uniform', 0);
for axIdx = 1 : numel(all_YData)
if iscell(all_YData{axIdx})
mask = cellfun(@(Y) ~isequal(Y, [0 0]), all_YData{axIdx});
else
all_XData{axIdx} = {all_XData{axIdx}};
all_YData{axIdx} = {all_YData{axIdx}};
end
end
This code permits you to select a .fig file, and processes it. It outputs a cell array of character vectors named all_titles . It outputs a cell array named all_XData in which there is one celll array entry for each axes, that contains an entry for each line inside the axes, that is the line x coordinates. It outputs a cell array named all_YData in which there is one celll array entry for each axes, that contains an entry for each line inside the axes, that is the line y coordinates. The coordinate entries have been filtered to remove any lines with Y coordinate [0 0]
The difference between this code and the previous version is that this version filters out lines where the y coordinate is just [0 0]. This version also accounts for the possibility that an axes only has one line.
In the case where the axes had more than one line, the internal get() call would have returned a cell array of coordinates, but in the case where the axes had exactly one line, the internal get() call would have returned the numeric coordinates directly: this code detects the single-line case and deliberately wraps it inside a cell array, so that the outputs are consistent.
So, for axes #K,all_titles{K} is a character vector that is the axes title, and all_XData{K} is a cell array with one entry per line inside the axes for the X coordinates, and all_YData{K} is a cell array with one entry per line inside the axes for the Y coordinates.
This code does not assume that all of the lines inside an axes have the same number of points. If you are willing to assume that, then you can process the arrays further by
XData_matrices = cellfun(@cell2mat, all_XData);
YData_matrices = cellfun(@cell2mat, all_YData);
and then those would be cell arrays with one entry per axes, and the entries would be N x L numeric arrays where N is the number of lines and L is the number of points in the line.

### Categories

Find more on Graphics Object Programming in Help Center and File Exchange

### Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!