export_fig.m

Go to the documentation of this file.

/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

function [im , alpha ] = export_fig(varargin) {
drawnow;
/*  Parse the input arguments */
[fig, options] = parse_args(nargout, varargin[:]);
/*  Isolate the subplot, if it is one */
cls = all(ismember(get(fig, " Type "), [" axes ", " uipanel "]));
if cls
    /*  Given handles of one or more axes, so isolate them from the rest */
    fig = isolate_axes(fig);
else
    /*  Check we have a figure */
    if ~isequal(get(fig, " Type "), " figure ");
        error(" Handle must be that of a figure, axes or uipanel ");
    end
    /*  Get the old InvertHardcopy mode */
    old_mode = get(fig, " InvertHardcopy ");
end
/*  Hack the font units where necessary (due to a font rendering bug in
 * print?). This may not work perfectly in all cases. Also it can change the
 * figure layout if reverted, so use a copy. */
magnify = options.magnify * options.aa_factor;
if isbitmap(options) && magnify ~= 1
    fontu = findobj(fig, " FontUnits ", " normalized ");
    if ~isempty(fontu)
        /*  Some normalized font units found */
        if ~cls
            fig = copyfig(fig);
            set(fig, " Visible ", " off ");
            fontu = findobj(fig, " FontUnits ", " normalized ");
            cls = true;
        end
        set(fontu, " FontUnits ", " points ");
    end
end
/*  MATLAB "feature": axes limits and tick marks can change when printing */
Hlims = findall(fig, " Type ", " axes ");
if ~cls
    /*  Record the old axes limit and tick modes */
    Xlims = make_cell(get(Hlims, " XLimMode "));
    Ylims = make_cell(get(Hlims, " YLimMode "));
    Zlims = make_cell(get(Hlims, " ZLimMode "));
    Xtick = make_cell(get(Hlims, " XTickMode "));
    Ytick = make_cell(get(Hlims, " YTickMode "));
    Ztick = make_cell(get(Hlims, " ZTickMode "));
end
/*  Set all axes limit and tick modes to manual, so the limits and ticks can't change */
set(Hlims, " XLimMode ", " manual ", " YLimMode ", " manual ", " ZLimMode ", " manual ", " XTickMode ", " manual ", " YTickMode ", " manual ", " ZTickMode ", " manual ");
/*  Set to print exactly what is there */
set(fig, " InvertHardcopy ", " off ");
/*  Set the renderer */
switch options.renderer
    case 1
        renderer = " -opengl ";
    case 2
        renderer = " -zbuffer ";
    case 3
        renderer = " -painters ";
    otherwise
        renderer = " -opengl "; /*  Default for bitmaps */

end
/*  Do the bitmap formats first */
if isbitmap(options)
    /*  Get the background colour */
    if options.transparent && (options.png || options.alpha)
        /*  Get out an alpha channel
         * MATLAB "feature": black colorbar axes can change to white and vice versa! */
        hCB = findobj(fig, " Type ", " axes ", " Tag ", " Colorbar ");
        if isempty(hCB)
            yCol = [];
            xCol = [];
        else
            yCol = get(hCB, " YColor ");
            xCol = get(hCB, " XColor ");
            if iscell(yCol)
                yCol = cell2mat(yCol);
                xCol = cell2mat(xCol);
            end
            yCol = sum(yCol, 2);
            xCol = sum(xCol, 2);
        end
        /*  MATLAB "feature": apparently figure size can change when changing
         * colour in -nodisplay mode */
        pos = get(fig, " Position ");
        /*  Set the background colour to black, and set size in case it was
         * changed internally */
        tcol = get(fig, " Color ");
        set(fig, " Color ", " k ", " Position ", pos);
        /*  Correct the colorbar axes colours */
        set(hCB(yCol==0), " YColor ", [0 0 0]);
        set(hCB(xCol==0), " XColor ", [0 0 0]);
        /*  Print large version to array */
        B = print2array(fig, magnify, renderer);
        /*  Downscale the image */
        B = downsize(single(B), options.aa_factor);
        /*  Set background to white (and set size) */
        set(fig, " Color ", " w ", " Position ", pos);
        /*  Correct the colorbar axes colours */
        set(hCB(yCol==3), " YColor ", [1 1 1]);
        set(hCB(xCol==3), " XColor ", [1 1 1]);
        /*  Print large version to array */
        A = print2array(fig, magnify, renderer);
        /*  Downscale the image */
        A = downsize(single(A), options.aa_factor);
        /*  Set the background colour (and size) back to normal */
        set(fig, " Color ", tcol, " Position ", pos);
        /*  Compute the alpha map */
        alpha = round(sum(B - A, 3)) / (255 * 3) + 1;
        A = alpha;
        A(A==0) = 1;
        A = B ./ A(:,:,[1 1 1]);
        clear B
        /*  Convert to greyscale */
        if options.colourspace == 2
            A = rgb2grey(A);
        end
        A = uint8(A);
        /*  Crop the background */
        if options.crop
            [alpha, v] = crop_background(alpha, 0);
            A = A(v(1):v(2),v(3):v(4),:);
        end
        if options.png
            /*  Compute the resolution */
            res = options.magnify * get(0, " ScreenPixelsPerInch ") / 25.4e-3;
            /*  Save the png */
            imwrite(A, [options.name " .png "], " Alpha ", double(alpha), " ResolutionUnit ", " meter ", " XResolution ", res, " YResolution ", res);
            /*  Clear the png bit */
            options.png= false;
        end
        /*  Return only one channel for greyscale */
        if isbitmap(options)
            A = check_greyscale(A);
        end
        if options.alpha
            /*  Store the image */
            im = A;
            /*  Clear the alpha bit */
            options.alpha= false;
        end
        /*  Get the non-alpha image */
        if isbitmap(options)
            alph = alpha(:,:,ones(1, size(A, 3)));
            A = uint8(single(A) .* alph + 255 * (1 - alph));
            clear alph
        end
        if options.im
            /*  Store the new image */
            im = A;
        end
    else
        /*  Print large version to array */
        if options.transparent
            /*  MATLAB "feature": apparently figure size can change when changing
             * colour in -nodisplay mode */
            pos = get(fig, " Position ");
            tcol = get(fig, " Color ");
            set(fig, " Color ", " w ", " Position ", pos);
            A = print2array(fig, magnify, renderer);
            set(fig, " Color ", tcol, " Position ", pos);
            tcol = 255;
        else
            [A, tcol] = print2array(fig, magnify, renderer);
        end
        /*  Crop the background */
        if options.crop
            A = crop_background(A, tcol);
        end
        /*  Downscale the image */
        A = downsize(A, options.aa_factor);
        if options.colourspace == 2
            /*  Convert to greyscale */
            A = rgb2grey(A);
        else
            /*  Return only one channel for greyscale */
            A = check_greyscale(A);
        end
        /*  Outputs */
        if options.im
            im = A;
        end
        if options.alpha
            im = A;
            alpha = zeros(size(A, 1), size(A, 2), " single ");
        end
    end
    /*  Save the images */
    if options.png
        res = options.magnify * get(0, " ScreenPixelsPerInch ") / 25.4e-3;
        imwrite(A, [options.name " .png "], " ResolutionUnit ", " meter ", " XResolution ", res, " YResolution ", res);
    end
    if options.bmp
        imwrite(A, [options.name " .bmp "]);
    end
    /*  Save jpeg with given quality */
    if options.jpg
        quality = options.quality;
        if isempty(quality)
            quality = 95;
        end
        if quality > 100
            imwrite(A, [options.name " .jpg "], " Mode ", " lossless ");
        else
            imwrite(A, [options.name " .jpg "], " Quality ", quality);
        end
    end
    /*  Save tif images in cmyk if wanted (and possible) */
    if options.tif
        if options.colourspace == 1 && size(A, 3) == 3
            A = double(255 - A);
            K = min(A, [], 3);
            K_ = 255 ./ max(255 - K, 1);
            C = (A(:,:,1) - K) .* K_;
            M = (A(:,:,2) - K) .* K_;
            Y = (A(:,:,3) - K) .* K_;
            A = uint8(cat(3, C, M, Y, K));
            clear C M Y K K_
        end
        append_mode = [" overwrite ", " append "];
        imwrite(A, [options.name " .tif "], " Resolution ", options.magnify*get(0, " ScreenPixelsPerInch "), " WriteMode ", append_mode[options.append+1]);
    end
end
/*  Now do the vector formats */
if isvector(options)
    /*  Set the default renderer to painters */
    if ~options.renderer
        renderer = " -painters ";
    end
    /*  Generate some filenames */
    tmp_nam = [tempname " .eps "];
    if options.pdf
        pdf_nam = [options.name " .pdf "];
    else
        pdf_nam = [tempname " .pdf "];
    end
    /*  Generate the options for print */
    p2eArgs = [renderer];
    if options.colourspace == 1
        p2eArgs = [p2eArgs [" -cmyk "]];
    end
    if ~options.crop
        p2eArgs = [p2eArgs [" -loose "]];
    end
    try
        /*  Generate an eps */
        print2eps(tmp_nam, fig, p2eArgs[:]);
        /*  Remove the background, if desired */
        if options.transparent && ~isequal(get(fig, " Color "), " none ")
            eps_remove_background(tmp_nam);
        end
        /*  Add a bookmark to the PDF if desired */
        if options.bookmark
            fig_nam = get(fig, " Name ");
            if isempty(fig_nam)
                warning(" export_fig:EmptyBookmark ", " Bookmark requested for figure with no name. Bookmark will be empty. ");
            end
            add_bookmark(tmp_nam, fig_nam);
        end
        /*  Generate a pdf */
        eps2pdf(tmp_nam, pdf_nam, 1, options.append, options.colourspace==2, options.quality);
    catch ex
        /*  Delete the eps */
        delete(tmp_nam);
        rethrow(ex);
    end
    /*  Delete the eps */
    delete(tmp_nam);
    if options.eps
        try
            /*  Generate an eps from the pdf */
            pdf2eps(pdf_nam, [options.name " .eps "]);
        catch ex
            if ~options.pdf
                /*  Delete the pdf */
                delete(pdf_nam);
            end
            rethrow(ex);
        end
        if ~options.pdf
            /*  Delete the pdf */
            delete(pdf_nam);
        end
    end
end
if cls
    /*  Close the created figure */
    close(fig);
else
    /*  Reset the hardcopy mode */
    set(fig, " InvertHardcopy ", old_mode);
    /*  Reset the axes limit and tick modes */
    for a = 1:numel(Hlims)
        set(Hlims(a), " XLimMode ", Xlims[a], " YLimMode ", Ylims[a], " ZLimMode ", Zlims[a], " XTickMode ", Xtick[a], " YTickMode ", Ytick[a], " ZTickMode ", Ztick[a]);
    end
end
return

}
function [fig , options ] = exportfig>parse_args(nout,varargin) {
fig = get(0, " CurrentFigure ");
options = struct(" name ", " export_fig_out ", ...
                 " crop ", true, ...
                 " transparent ", false, ...
                 " renderer ", 0, ... /*  0: default, 1: OpenGL, 2: ZBuffer, 3: Painters */

                 " pdf ", false, ...
                 " eps ", false, ...
                 " png ", false, ...
                 " tif ", false, ...
                 " jpg ", false, ...
                 " bmp ", false, ...
                 " colourspace ", 0, ... /*  0: RGB/gray, 1: CMYK, 2: gray */

                 " append ", false, ...
                 " im ", nout == 1, ...
                 " alpha ", nout == 2, ...
                 " aa_factor ", 3, ...
                 " magnify ", 1, ...
                 " bookmark ", false, ...
                 " quality ", []);
native = false; /*  Set resolution to native of an image */


/*  Go through the other arguments */
for a = 1:nargin-1
    if all(ishandle(varargin[a]))
        fig = varargin[a];
    elseif ischar(varargin[a]) && ~isempty(varargin[a])
        if varargin[a](1) == " - "
            switch lower(varargin[a](2:end))
                case " nocrop "
                    options.crop= false;
                case [" trans ", " transparent "]
                    options.transparent= true;
                case " opengl "
                    options.renderer= 1;
                case " zbuffer "
                    options.renderer= 2;
                case " painters "
                    options.renderer= 3;
                case " pdf "
                    options.pdf= true;
                case " eps "
                    options.eps= true;
                case " png "
                    options.png= true;
                case [" tif ", " tiff "]
                    options.tif= true;
                case [" jpg ", " jpeg "]
                    options.jpg= true;
                case " bmp "
                    options.bmp= true;
                case " rgb "
                    options.colourspace= 0;
                case " cmyk "
                    options.colourspace= 1;
                case [" gray ", " grey "]
                    options.colourspace= 2;
                case [" a1 ", " a2 ", " a3 ", " a4 "]
                    options.aa_factor= str2double(varargin[a](3));
                case " append "
                    options.append= true;
                case " bookmark "
                    options.bookmark= true;
                case " native "
                    native = true;
                otherwise
                    val = str2double(regexp(varargin[a], " (?<=-(m|M|r|R|q|Q))(\d*\.)?\d+(e-?\d+)? ", " match "));
                    if ~isscalar(val)
                        error(" option %s not recognised ", varargin[a]);
                    end
                    switch lower(varargin[a](2))
                        case " m "
                            options.magnify= val;
                        case " r "
                            options.magnify= val ./ get(0, " ScreenPixelsPerInch ");
                        case " q "
                            options.quality= max(val, 0);
                    end
            end
        else
            [p, options.name, ext] = fileparts(varargin[a]);
            if ~isempty(p)
                options.name= [p filesep options.name];
            end
            switch lower(ext)
                case [" .tif ", " .tiff "]
                    options.tif= true;
                case [" .jpg ", " .jpeg "]
                    options.jpg= true;
                case " .png "
                    options.png= true;
                case " .bmp "
                    options.bmp= true;
                case " .eps "
                    options.eps= true;
                case " .pdf "
                    options.pdf= true;
                otherwise
                    options.name= varargin[a];
            end
        end
    end
end

/*  Check we have a figure handle */
if isempty(fig)
    error(" No figure found ");
end

/*  Set the default format */
if ~isvector(options) && ~isbitmap(options)
    options.png= true;
end

/*  Check whether transparent background is wanted (old way) */
if isequal(get(ancestor(fig, " figure "), " Color "), " none ")
    options.transparent= true;
end

/*  If requested, set the resolution to the native vertical resolution of the
 * first suitable image found */
if native && isbitmap(options)
    /*  Find a suitable image */
    list = findobj(fig, " Type ", " image ", " Tag ", " export_fig_native ");
    if isempty(list)
        list = findobj(fig, " Type ", " image ", " Visible ", " on ");
    end
    for hIm = list(:)^t
        /*  Check height is >= 2 */
        height = size(get(hIm, " CData "), 1);
        if height < 2
            continue
        end
        /*  Account for the image filling only part of the axes, or vice
         * versa */
        yl = get(hIm, " YData ");
        if isscalar(yl)
            yl = [yl(1)-0.5 yl(1)+height+0.5];
        else
            if ~diff(yl)
                continue
            end
            yl = yl + [-0.5 0.5] * (diff(yl) / (height - 1));
        end
        hAx = get(hIm, " Parent ");
        yl2 = get(hAx, " YLim ");
        /*  Find the pixel height of the axes */
        oldUnits = get(hAx, " Units ");
        set(hAx, " Units ", " pixels ");
        pos = get(hAx, " Position ");
        set(hAx, " Units ", oldUnits);
        if ~pos(4)
            continue
        end
        /*  Found a suitable image
         * Account for stretch-to-fill being disabled */
        pbar = get(hAx, " PlotBoxAspectRatio ");
        pos = min(pos(4), pbar(2)*pos(3)/pbar(1));
        /*  Set the magnification to give native resolution */
        options.magnify= (height * diff(yl2)) / (pos * diff(yl));
        break
    end
end
return

}

function A = exportfig>downsize(A,factor) {
if factor == 1
    /*  Nothing to do */
    return
end
try
    /*  Faster, but requires image processing toolbox */
    A = imresize(A, 1/factor, " bilinear ");
catch
    /*  No image processing toolbox - resize manually
     * Lowpass filter - use Gaussian as is separable, so faster
     * Compute the 1d Gaussian filter */
    filt = (-factor-1:factor+1) / (factor * 0.6);
    filt = exp(-filt .* filt);
    /*  Normalize the filter */
    filt = single(filt / sum(filt));
    /*  Filter the image */
    padding = floor(numel(filt) / 2);
    for a = 1:size(A, 3)
        A(:,:,a) = conv2(filt, filt" , single(A([ones(1, padding) 1:end repmat(end, 1, padding)],[ones(1, padding) 1:end repmat(end, 1, padding)],a)),  "valid^t);
    end
    /*  Subsample */
    A = A(1+floor(mod(end-1, factor)/2):factor:end,1+floor(mod(end-1, factor)/2):factor:end,:);
end
return

}

function A = exportfig>rgb2grey(A) {
A = cast(reshape(reshape(single(A), [], 3) * single([0.299; 0.587; 0.114]), size(A, 1), size(A, 2)), class(A));
return

}

function A = exportfig>check_greyscale(A) {
if size(A, 3) == 3 && ...
        all(reshape(A(:,:,1) == A(:,:,2), [], 1)) && ...
        all(reshape(A(:,:,2) == A(:,:,3), [], 1))
    A = A(:,:,1); /*  Save only one channel for 8-bit output */

end
return

}

function [A , v ] = exportfig>crop_background(A,bcol) {
[h, w, c] = size(A);
if isscalar(bcol) && c > 1
    bcol = bcol(ones(1, c));
end
bail = false;
for l = 1:w
    for a = 1:c
        if ~all(A(:,l,a) == bcol(a))
            bail = true;
            break;
        end
    end
    if bail
        break;
    end
end
bail = false;
for r = w:-1:l
    for a = 1:c
        if ~all(A(:,r,a) == bcol(a))
            bail = true;
            break;
        end
    end
    if bail
        break;
    end
end
bail = false;
for t = 1:h
    for a = 1:c
        if ~all(A(t,:,a) == bcol(a))
            bail = true;
            break;
        end
    end
    if bail
        break;
    end
end
bail = false;
for b = h:-1:t
    for a = 1:c
        if ~all(A(b,:,a) == bcol(a))
            bail = true;
            break;
        end
    end
    if bail
        break;
    end
end
/*  Crop the background, leaving one boundary pixel to avoid bleeding on
 * resize */
v = [max(t-1, 1) min(b+1, h) max(l-1, 1) min(r+1, w)];
A = A(v(1):v(2),v(3):v(4),:);
return

}

function  exportfig>eps_remove_background(fname) {
fh = fopen(fname, " r+ ");
if fh == -1
    error(" Not able to open file %s. ", fname);
end
/*  Read the file line by line */
while true
    /*  Get the next line */
    l = fgets(fh);
    if isequal(l, -1)
        break; /*  Quit, no rectangle found */

    end
    /*  Check if the line contains the background rectangle */
    if isequal(regexp(l, "  *0 +0 +\d+ +\d+ +rf *[\n\r]+ ", " start "), 1)
        /*  Set the line to whitespace and quit */
        l(1:regexp(l, " [\n\r] ", " start ", " once ")-1) = "   ";
        fseek(fh, -numel(l), 0);
        fprintf(fh, l);
        break;
    end
end
/*  Close the file */
fclose(fh);
return

}

function b = exportfig>isvector(options) {
b = options.pdf || options.eps;
return

}

function b = exportfig>isbitmap(options) {
b = options.png || options.tif || options.jpg || options.bmp || options.im || options.alpha;
return

/*  Helper function */
}

function A = exportfig>make_cell(A) {
if ~iscell(A)
    A = [A];
end
return

}

function  exportfig>add_bookmark(fname,bookmark_text) {
fh = fopen(fname, " r ");
if fh == -1
    error(" File %s not found. ", fname);
end
try
    fstrm = fread(fh, " *char ")^t;
catch ex
    fclose(fh);
    rethrow(ex);
end
fclose(fh);

/*  Include standard pdfmark prolog to maximize compatibility */
fstrm = strrep(fstrm, " %%BeginProlog ", sprintf(" %%%%BeginProlog\n/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse "));
/*  Add page bookmark */
fstrm = strrep(fstrm, " %%EndPageSetup ", sprintf(" %%%%EndPageSetup\n[ /Title (%s) /OUT pdfmark ",bookmark_text));

/*  Write out the updated file */
fh = fopen(fname, " w ");
if fh == -1
    error(" Unable to open %s for writing. ", fname);
end
try
    fwrite(fh, fstrm, " char*1 ");
catch ex
    fclose(fh);
    rethrow(ex);
end
fclose(fh);
return
}