Merge branch 'release/v0.1.0'

Author: t-sommer

+SDF/+NDTable/interpolate.m

@@ -0,0 +1,58 @@
+function y = interpolate(points, data, scales, varargin)
+
+assert(mod(numel(varargin), 2) == 0, 'Wrong number of arguments')
+
+interp_method = 2;
+extrap_method = 2;
+
+for i = 1:2:numel(varargin)
+    
+    name = varargin{i};
+    value = varargin{i + 1};
+    
+    if strcmpi(name, 'InterpMethod')
+        
+        if strcmpi(value, 'Hold')
+            interp_method = 1;
+        elseif strcmpi(value, 'Nearest')
+            interp_method = 2;
+        elseif strcmpi(value, 'Linear')
+            interp_method = 3;
+        elseif strcmpi(value, 'Akima')
+            interp_method = 4;
+        elseif strcmpi(value, 'FritschButland')
+            interp_method = 5;
+        elseif strcmpi(value, 'Steffen')
+            interp_method = 6;
+        else
+            error('InterpMethod must be one of Hold, Nearest, Linear, Akima, FritschButland or Steffen')
+        end
+        
+    elseif strcmpi(name, 'ExtrapMethod')
+        
+        if strcmpi(value, 'Hold')
+            extrap_method = 1;
+        elseif strcmpi(value, 'Linear')
+            extrap_method = 2;
+        elseif strcmpi(value, 'None')
+            extrap_method = 3;
+        else
+            error('ExtrapMethod must be one of Hold, Linear or None')
+        end
+        
+    else
+        
+        error(['Unknown key: ' name])
+        
+    end
+    
+    
+end
+
+% convert from column-major (FORTRAN) to row-major (C) order
+order = fliplr(1:ndims(data));
+data = permute(data, order);
+
+y = mex_ndtable(fliplr(points)', data, scales, interp_method, extrap_method);
+
+end

+SDF/Dataset.m

@@ -0,0 +1,47 @@
+% Copyright (c) 2016 Dassault Systemes. All rights reserved.
+
+classdef Dataset < handle
+    
+    properties
+        name = ''
+        comment = ''
+        attributes = struct([])
+        data = []
+        display_name = ''
+        relative_quantity = false
+        unit = ''
+        display_unit = ''
+        is_scale = false
+        scales = SDF.Dataset.empty
+    end
+    
+    properties (Dependent)
+        rank
+    end
+    
+    methods
+
+        function self = Dataset()
+            self.attributes = struct();
+            self.relative_quantity = false;
+            self.is_scale = 0;
+        end
+        
+        function value = get.rank(obj)
+            s = size(obj.data);
+            nd = ndims(obj.data);
+            
+            if nd > 2
+                value = nd;
+            elseif s(1) <= 1 && s(2) <= 1
+                value = 0;
+            elseif s(1) == 1 || s(2) == 1
+                value = 1;
+            else
+                value = nd;
+            end
+        end
+        
+    end
+    
+end

+SDF/Group.m

@@ -0,0 +1,60 @@
+% Copyright (c) 2016 Dassault Systemes. All rights reserved.
+
+classdef Group < handle
+    
+    properties
+        name = ''
+        comment = ''
+        attributes = struct([])
+        datasets = SDF.Dataset.empty
+        groups = SDF.Group.empty
+    end
+    
+    methods
+
+        function object = find_object(self, object_name)
+            
+            object = [];
+            
+            segments = strsplit(object_name, '/');
+            
+            first = '';
+            
+            while isempty(first) && ~isempty(segments)
+                first = segments{1};
+                segments = segments(2:end);
+            end
+            
+            if isempty(first)
+                % path is empty
+                return
+            end
+                      
+            % search the datasets
+            for i = 1:numel(self.datasets)
+                dataset = self.datasets(i);
+                if strcmp(dataset.name, first)
+                    object = dataset;
+                    return
+                end
+            end
+            
+            % search the groups
+            for i = 1:numel(self.groups)
+                group = self.groups(i);
+                if strcmp(group.name, first)
+                    if isempty(segments)
+                        object = group;
+                    else
+                        % continue the search
+                        path = strjoin(segments, '/');
+                        object = group.find_object(path);
+                    end                    
+                end
+            end
+                        
+        end
+        
+   end
+    
+end

+SDF/load.m

@@ -0,0 +1,67 @@
+%SDF.LOAD Load a dataset from an SDF file
+%
+%   g = SDF.load(FILENAME) loads the whole file and returns an SDF.Group
+%
+%   obj = SDF.load(FILENAME, OBJECT_NAME) loads an object from an SDF file
+%   and returns an SDF.Group or SDF.Dataset
+%
+%   ds = SDF.load(FILENAME, DATASET_NAME, UNIT) loads a dataset, asserts 
+%   the unit and returns an SDF.Dataset
+%
+%   ds = SDF.load(FILENAME, DATASET_NAME, UNIT, SCALE_UNITS) loads a 
+%   dataset, asserts the unit, dimensions, scale units and returns an SDF.Dataset
+%
+%   Example:
+%     
+%       ds = SDF.load('data.sdf', '/signals/v')              % load the dataset 'v' in group 'singals
+%       ds = SDF.load('data.sdf', '/signals/v', 'V')         % assert the unit 'V'
+%       ds = SDF.load('data.sdf', '/signals/v', 'V', {'s'})  % assert the unit 's' of the scale for dimension 1
+%       ds = SDF.load('data.sdf', '/signals/v', '', {''})    % assert that /v is a 1-d dataset
+
+function object = load(filename, varargin)
+
+    % check if the file exists
+    assert(exist(filename, 'file') == 2, ['The file ''' filename ''' does not exist'])
+
+    [~, ~, ext] = fileparts(filename);
+    
+    object_name = '/';
+    
+    if numel(varargin) >= 1
+        object_name = varargin{1};
+    end
+
+    if strcmp(ext, '.sdf')
+        object = read_hdf5(filename, object_name);
+    elseif strcmp(ext, '.mat')
+        object = read_dsres(filename, object_name);
+    else
+        error('Unknown file format')
+    end
+    
+    if numel(varargin) >= 2
+        % check the unit
+        assert(isa(object, 'SDF.Dataset'), ['Unit was provided but ' object_name ' is not a dataset.'])
+        unit = varargin{2};
+        if ~isempty(unit)
+            assert(strcmp(object.unit, unit), ['Dataset ' object_name ' has the wrong unit. Expected ''' unit ''' but was ''' object.unit '''.'])
+        end
+    end
+    
+    if numel(varargin) >= 3
+        
+        % check the rank
+        scale_units = varargin{3};
+        rank = numel(scale_units);
+        assert(object.rank == rank, ['Dataset has the wrong rank. Expected ' num2str(rank) ' but was ' num2str(object.rank) '.'])
+        
+        % check the scale units
+        for i = 1:numel(scale_units)
+            scale_unit = scale_units{i};
+            if ~isempty(scale_unit)
+                scale = object.scales(i);
+                assert(strcmp(scale.unit, scale_unit), ['The scale for dimension ' num2str(i) ' has the wrong unit. Expected ''' scale_unit ''' but was ''' scale.unit '''.'])
+            end 
+        end
+        
+    end

+SDF/private/read_dsres.m

@@ -0,0 +1,146 @@
+function object = read_dsres(filename, object_name)
+
+mat = load(filename);
+
+% get the arrays
+file_info = mat.Aclass;
+
+if strcmp(file_info(2,1:3), '1.1') 
+    if strcmp(file_info(4,1:8), 'binTrans')
+        info = mat.dataInfo;
+        desc = mat.description';
+        cons = mat.data_1';
+        vars = mat.data_2';
+        names = mat.name';
+    elseif strcmp(file_info(4,1:9), 'binNormal')
+        info = mat.dataInfo';
+        desc = mat.description;
+        cons = mat.data_1;
+        vars = mat.data_2;
+        names = mat.name;
+    else
+        error('Format not supported')
+    end
+elseif strcmp(file_info(2,1:3), '1.0')
+    
+    names = mat.names;
+    vars = mat.data;
+    n = size(vars, 2);
+    desc = char(zeros(n,1));
+    info = [ones(n,1).*2, [1:n]']';
+
+else
+    error('Format not supported')
+end
+
+% remove the string terminators so strtrim() works correctly
+names(names == 0) = ' ';
+desc(desc == 0) = ' ';
+
+n = size(info, 2);
+
+root = SDF.Group();
+
+ds_time = SDF.Dataset();
+ds_time.name = strtrim(names(1, :));
+ds_time.comment = strtrim(desc(1, :));
+ds_time.unit = 's';
+ds_time.data = vars(:, 1);
+ds_time.is_scale = true;
+
+root.datasets(end+1) = ds_time;
+
+for i = 2:n
+    
+    ds = SDF.Dataset();
+    
+    d = info(1, i); % variability (constant=1, variable=2)
+    x = info(2, i);
+    c = abs(x);     % colum
+    s = sign(x);    % sign
+    
+    path = strtrim(names(i, :));
+    
+    path_elements = strsplit(path, '.');
+    
+    parent_group = root;
+    
+    for j = 1:numel(path_elements)-1
+        path_element = path_elements{j};
+        pg = [];
+        
+        for k = 1:numel(parent_group.groups)
+            if strcmp(parent_group.groups(k).name, path_element)
+                pg = parent_group.groups(k);
+                break
+            end
+        end
+        
+        if isempty(pg)
+            pg = SDF.Group();
+            pg.name = path_element;
+            parent_group.groups(end+1) = pg;
+        end
+        
+        parent_group = pg;
+    end
+    
+    comment = strtrim(desc(i, :));
+    last = find(comment == '[', 1, 'last');
+
+    if d == 1
+        data = cons(1, c);
+    else
+        data = vars(:, c);
+        ds.scales = ds_time;
+    end
+    
+    unit = '';
+    display_unit = '';
+    
+    if ~isempty(comment) && comment(end) == ']' && last
+        type_info = comment(last+1:end-1);
+        comment = comment(1:last-1);
+        elements = strsplit(type_info, ':#');
+        for j = 1:numel(elements)
+            element = elements{j};
+            if strcmp(element, '(type=Integer)')
+                % change type
+                data = int32(data);
+            elseif strcmp(element, '(type=Boolean)')
+                % change type
+                data = logical(data);
+            elseif ~isempty(element)
+                unit = element;
+            end
+        end
+    end
+    
+    j = find(unit == '|');
+    
+    if j
+        display_unit = unit(j+1:end);
+        unit = unit(1:j-1);
+    end
+    
+    if s < 0
+        data = -data;
+    end
+    
+    ds.name = path_elements{end};
+    ds.comment = strtrim(comment);
+    ds.unit = unit;
+    ds.display_unit = display_unit;
+    ds.data = data;
+    
+    parent_group.datasets(end+1) = ds;
+
+end
+
+if strcmp(object_name, '/')
+    object = root;
+else
+    object = root.find_object(object_name);
+end
+
+end