www.gusucode.com > mbcdata 工具箱 matlab 源码程序 > mbcdata/@calibrationdata/@mbc2matinterface/pRead.m

    function calibration = pRead(obj, calibration, filename)
%PREAD  Private method.

%  PREAD reads a calibration from a MAT file.
%
%  CAL = PREAD(OBJ,CAL,FILENAME)
%
%  See also ROLLBACK, PWRITE.

%  Copyright 2000-2011 The MathWorks, Inc.


narginchk(3,3);
nargoutchk(1,1);

pm = obj.ProgressManager;
pm.reset;

% Load structure
pm.notify('Loading file from disk');
dataStructure = load(filename, '-mat');

% Process items to discover their types (value, axis, curve or map)
f = fieldnames(dataStructure);
% Store codes: 1 = value, 2 = axis, 3 = curve, 4 = map, 0 = unknown
t = zeros(size(f));
for i = 1:numel(f),
    thisS = dataStructure.(f{i});
    if isfield(thisS, 'X') && ~isfield(thisS, 'Y') && ~isfield(thisS, 'Z')
        % Constant
        t(i) = 1;
    elseif isfield(thisS, 'X') && isfield(thisS, 'Y') && ~isfield(thisS, 'Z')
        % Distinguish axes from curves by looking at monotonicity and rem
        if all(rem(thisS.Y.values,1)==0) && ~any(diff(thisS.Y.values)==0) && all(diff(sign(diff(thisS.Y.values)))==0)
            % Axis
            t(i) = 2;
        else
            % Curve
            t(i) = 3;
        end
    elseif isfield(thisS, 'X') && isfield(thisS, 'Y') && isfield(thisS, 'Z')
        % Map
        t(i) = 4;
    else
        % Unknown
        t(i) = 0;
    end
end

% Store lengths for convenience
iValues = find(t==1);
iAxes = find(t==2);
iCurves = find(t==3);
iMaps = find(t==4);
nValues = numel(iValues);
nAxes = numel(iAxes);
nCurves = numel(iCurves);
nMaps = numel(iMaps);

% Process values
if nValues > 0
    pm.notify(sprintf('Processing %d values', nValues));
    value = mbcutils.handleArray(nValues, 1); % preallocate
    for i = 1:nValues,
        thisValueS = dataStructure.(f{iValues(i)});
        % Value
        thisValue = calibrationdata.value;
        thisValue.Identifier = f{iValues(i)};
        thisValue.Value = thisValueS.X.values;
        % Store
        value(i) = thisValue;
        pm.update(i/(nValues+nAxes+nCurves+nMaps));
    end
    % Add to calibration
    pm.notify(sprintf('Storing %d values', nValues));
    calibration.addValue(value);
end

% Process axes
if nAxes > 0
    pm.notify(sprintf('Processing %d axes', nAxes));
    axis = mbcutils.handleArray(nAxes, 1); % preallocate
    for i = 1:nAxes,
        thisAxisS = dataStructure.(f{iAxes(i)});
        % Axis
        thisAxis = calibrationdata.axis;
        thisAxis.Identifier = f{iAxes(i)};
        thisAxis.Value = thisAxisS.X.values;
        thisAxis.Index = thisAxisS.Y.values+1; % CAGE is 0-based, axis is 1-based
        % Store
        axis(i) = thisAxis;
        pm.update((i+nValues)/(nValues+nAxes+nCurves+nMaps));
    end
    % Add to calibration
    pm.notify(sprintf('Storing %d axes', nAxes));
    calibration.addAxis(axis);
end

% Process curves
if nCurves > 0
    pm.notify(sprintf('Processing %d curves', nCurves));
    curve = mbcutils.handleArray(nCurves, 1); % preallocate
    xAxis = mbcutils.handleArray(nCurves, 1); % preallocate
    for i = 1:nCurves,
        thisCurveS = dataStructure.(f{iCurves(i)});
        % Curve
        thisCurve = calibrationdata.curve;
        thisCurve.Identifier = f{iCurves(i)};
        thisCurve.Value = thisCurveS.Y.values;
        % X axis
        thisXAxis = calibrationdata.axis;
        thisXAxis.Identifier = thisCurve.XAxisIdentifier;
        thisXAxis.Value = thisCurveS.X.values;
        % Store
        curve(i) = thisCurve;
        xAxis(i) = thisXAxis;
        pm.update((i+nValues+nAxes)/(nValues+nAxes+nCurves+nMaps));
    end
    % Add to calibration
    pm.notify(sprintf('Storing %d curves', nCurves));
    calibration.addCurve(curve);
    calibration.setAxis(xAxis);
end

% Process maps
if nMaps > 0
    pm.notify(sprintf('Processing %d maps', nMaps));
    map = mbcutils.handleArray(nMaps, 1); % preallocate
    xAxis = mbcutils.handleArray(nMaps, 1); % preallocate
    yAxis = mbcutils.handleArray(nMaps, 1); % preallocate
    for i = 1:nMaps,
        thisMapS = dataStructure.(f{iMaps(i)});
        % Map
        thisMap = calibrationdata.map;
        thisMap.Identifier = f{iMaps(i)};
        thisMap.Value = thisMapS.Z.values;
        % X axis
        thisXAxis = calibrationdata.axis;
        thisXAxis.Identifier = thisMap.XAxisIdentifier;
        thisXAxis.Value = thisMapS.X.values;
        % Y axis
        thisYAxis = calibrationdata.axis;
        thisYAxis.Identifier = thisMap.YAxisIdentifier;
        thisYAxis.Value = thisMapS.Y.values;
        % Store
        map(i) = thisMap;
        xAxis(i) = thisXAxis;
        yAxis(i) = thisYAxis;
        pm.update((i+nValues+nAxes+nCurves)/(nValues+nAxes+nCurves+nMaps));
    end
    % Add to calibration
    pm.notify(sprintf('Storing %d maps', nMaps));
    calibration.addMap(map);
    calibration.setAxis(xAxis);
    calibration.setAxis(yAxis);
end

pm.update(1);
pm.notify('Cleaning up');