Add groundwork for data flag & outlier marking

+DataKit/+Metadata/+validators/@validFlag/listAllValidFlagInfo.m

@@ -0,0 +1,23 @@
+function tbl = listAllValidFlagInfo()
+
+
+    flagList   	= enumeration('DataKit.Metadata.validators.validFlag');
+    flagProps	= properties('DataKit.Metadata.validators.validFlag');
+
+    propClass   = cellfun(@class,cellfun(@(p) flagList(1).(p),flagProps,'un',0),'un',0);
+    tblStruct   = struct();
+    for prop = 1:numel(flagProps)
+        switch propClass{prop}
+            case 'char'
+                column  = {flagList(:).(flagProps{prop})}';
+            case {'single','double','int8','int16','int32','uint8','uint16','uint32','uint64'}
+                column  = cat(1,flagList(:).(flagProps{prop}));
+            otherwise
+                error('%s is not implemented yet.',propClass{prop})
+        end
+
+        tblStruct.(flagProps{prop})     = column;
+    end
+    tbl     	= struct2table(tblStruct);
+    tbl.Flag	= flagList;
+end

+DataKit/+Metadata/+validators/@validFlag/validFlag.m

@@ -0,0 +1,37 @@
+classdef validFlag
+    enumeration
+        % quality flag                   id     description
+        undefined                       (0,     '')
+        OutOfCalibrationRange           (1,     'Value out of calibration range')
+        BelowDetectionLimit             (2,     'Value below the detection limit')
+        MarkedRejected                  (3,     'Value was manually rejected')
+    end
+    properties
+        Id uint8
+        Description char
+    end
+    properties (Dependent)
+        Bitmask uint64
+    end
+    methods
+        function obj = validFlag(id,description,varargin)
+            obj.Id              = id;
+            obj.Description     = description;
+        end
+    end
+
+    methods (Static)
+        tbl = listAllValidFlagInfo()
+    end
+
+    % get methods
+    methods
+        function Bitmask = get.Bitmask(obj)
+            if obj.Id == 0
+                Bitmask = 0;
+            else
+                Bitmask = bitset(0,obj.Id,1);
+            end
+        end
+    end
+end

+DataKit/+Metadata/@dataFlag/cat.m

@@ -0,0 +1,19 @@
+function obj = cat(dim,varargin)
+
+    import DataKit.Metadata.dataFlag
+
+    isaDataFlag = cellfun(@(in) isa(in,'DataKit.Metadata.dataFlag'),varargin);
+    if ~all(isaDataFlag)
+        error('DataKit:Metadata:dataFlag:cat:invalidInputType',...
+            'All inputs must be data flags')
+    end
+
+    % extract all bitmasks
+    bitmasks    = cellfun(@(in) in.Bitmask,varargin,'un',0);
+
+    % concatenate the bitmask
+    bitmask     = cat(dim,bitmasks{:});
+
+    % create new sparse bitmask object
+    obj         = dataFlag(bitmask);
+end

+DataKit/+Metadata/@dataFlag/dataFlag.m

@@ -0,0 +1,57 @@
+classdef dataFlag < DataKit.Metadata.sparseBitmask
+
+    methods
+        function obj = dataFlag(varargin)
+
+            obj     = [email protected](varargin{:});
+
+            % validate input ids
+            switch nargin
+                case 0
+                    return
+                case 1
+                    bitmasks	= varargin{1}(:);
+                    isNotZero  	= bitmasks ~= 0;
+                    bitmasks    = full(bitmasks(isNotZero));
+                    n           = sum(isNotZero);
+                    bitmask   	= zeros(n,52);
+                    for ii = 1:n
+                        bitmask(ii,:) = bitget(bitmasks(ii),1:52);
+                    end
+                    [~,flagId]  = find(bitmask);
+                case 2
+                    flagId  = 0;
+                case 3
+                    flagId	= varargin{3}(:);
+                case 5
+                    flagId	= varargin{3}(:);
+                otherwise
+                    error('DataKit:Metadata:dataFlag:invalidNumberOfInputs',...
+                        'Invalid number of inputs.')
+            end
+            isValid = DataKit.Metadata.dataFlag.validateId(flagId);
+            if any(~isValid)
+                error('DataKit:Metadata:dataFlag:dataFlag:invalidFlagId',...
+                    '%u is an invalid flag id.',flagId(find(~isValid,1)))
+            end
+        end
+    end
+
+    methods
+        tf = isFlag(obj,flag)
+    end
+
+    methods (Static)
+    	[bool,info] = validateId(id)
+        obj = id2validflag(id)
+    end
+
+    % Overloaded methods
+    methods
+        varargout = subsref(obj,s)
+        obj = cat(dim,varargin)
+        obj = horzcat(varargin)
+        obj = vertcat(varargin)
+        tf = eq(obj1,obj2)
+    end
+end

+DataKit/+Metadata/@dataFlag/disp.m

@@ -0,0 +1,68 @@
+function disp(obj)
+% disp  Displays metadata of a dataFlag instance
+%   DISP displays metadata of a dataFlag instance. It overloads the
+%   builtin disp(x) function.
+%
+%   Syntax
+%     data = DISP(obj)
+%
+%   Description
+%     data = DISP(obj) displays metadata of a dataFlag instance.
+%
+%   Example(s)
+%     data = DISP(obj)
+%
+%
+%   Input Arguments
+%     obj - dataFlag
+%       dataFlag
+%         An instance of the dataFlag class.
+%
+%
+%   Output Arguments
+%
+%
+%   Name-Value Pair Arguments
+%
+%
+%   See also SPARSEBITMASK
+%
+%   Copyright 2021 David Clemens ([email protected])
+%
+
+    import DataKit.ndigits
+
+    [i,j,v]         = find(obj.Bitmask);
+    N               = numel(i);
+    sz              = size(obj.Bitmask);
+    Limit           = 99;
+    LimitIsReached  = N > Limit;
+    if LimitIsReached
+        n = Limit;
+    else
+        n = N;
+    end
+
+    tabLength       = max([10,5 + ndigits(max(i)) + ndigits(max(j))]);
+
+	fprintf('  %ux%u <a href="matlab:help(''DataKit.Metadata.dataFlag'')">data flag</a>\n\n',sz(1),sz(2))
+
+    if N > 0
+        for ii = 1:n
+            flagIds = find(bitget(v(ii),1:52));
+            flagCellstr = cellstr(DataKit.Metadata.dataFlag.id2validflag(flagIds));
+            indexStr = sprintf('(%u, %u)',i(ii),j(ii));
+            fprintf('%s%s%s\n',indexStr,repmat(' ',1,tabLength - numel(indexStr)),strjoin(flagCellstr,', '))
+        end
+        if LimitIsReached
+            fprintf('%s:\n',repmat(' ',1,tabLength))
+            fprintf('%s:\n',repmat(' ',1,tabLength))
+            fprintf('%sOnly showing %u of %u elements.\n\n',repmat(' ',1,tabLength),n,N)
+        else
+            fprintf('\n')
+            fprintf('%sShowing %u of %u elements.\n\n',repmat(' ',1,tabLength),n,N)
+        end
+    else
+        fprintf('%sNo flag is set.\n\n',repmat(' ',1,tabLength))
+    end
+end

+DataKit/+Metadata/@dataFlag/eq.m

@@ -0,0 +1,13 @@
+function tf = eq(obj1,obj2)
+
+    if isa(obj1,'DataKit.Metadata.dataFlag') && isa(obj2,'DataKit.Metadata.dataFlag')
+        tf = isequal(obj1,obj2);
+    elseif ischar(obj2)
+        tf = obj1.isFlag(obj2);
+    elseif ischar(obj1)
+        tf = obj2.isFlag(obj1);
+    else
+        error('DataKit:Metadata:sparseBitmask:eq:invalidInputCombination',...
+            'Undefined input combination.')
+    end
+end

+DataKit/+Metadata/@dataFlag/horzcat.m

@@ -0,0 +1,4 @@
+function obj = horzcat(varargin)
+
+    obj = cat(2,varargin{:});
+end

+DataKit/+Metadata/@dataFlag/id2validflag.m

@@ -0,0 +1,17 @@
+function obj = id2validflag(id)
+
+	if ~isnumeric(id)
+        error('DataKit:Metadata:dataFlag:id2flag:invalidDataType',...
+            'The input argument ''id'' has to be numeric.')
+	end
+
+    flagListInfo	= DataKit.Metadata.validators.validFlag.listAllValidFlagInfo();
+    [im,imIdx]   	= ismember(id,flagListInfo{:,'Id'});
+
+    if ~all(im)
+        error('DataKit:Metadata:dataFlag:id2flag:invalidFlagId',...
+            'The flag id %u is invalid.',id(find(~im,1)))
+    end
+
+    obj     = flagListInfo{imIdx,'Flag'};
+end

+DataKit/+Metadata/@dataFlag/isFlag.m

@@ -0,0 +1,19 @@
+function tf = isFlag(obj,flag)
+
+    if ~ischar(flag) && ~isscalar(flag)
+        error('DataKit:Metadat:dataFlag:isFlag:onlyScalarContextAllowed',...
+            '''flag'' has to be scalar.')
+    end
+
+    if isnumeric(flag)
+        [isValid,info]	= DataKit.Metadata.dataFlag.validateId(flag);
+        Flag            = info{isValid,'Flag'};
+    else
+        Flag = DataKit.Metadata.validators.validFlag(flag);
+    end
+
+    [i,j,bm] = find(obj.Bitmask);
+
+    tf                       = false(size(obj));
+  	tf(sub2ind(obj.Sz,i,j))  = logical(bitget(bm,Flag.Id));
+end

+DataKit/+Metadata/@dataFlag/subsref.m

@@ -0,0 +1,44 @@
+function varargout = subsref(obj,s)
+
+    switch s(1).type
+        case '.'
+%             if length(s) == 1
+%                 % Implement obj.PropertyName
+%                 ...
+%             elseif length(s) == 2 && strcmp(s(2).type,'()')
+%                 % Implement obj.PropertyName(indices)
+%                 ...
+%             else
+%                 varargout = {builtin('subsref',obj,s)};
+%             end
+            varargout = {builtin('subsref',obj,s)};
+        case '()'
+            if length(s) == 1
+                % Implement obj(indices)
+                varargout = {DataKit.Metadata.dataFlag(obj.Bitmask(s.subs{:}))};
+%             elseif length(s) == 2 && strcmp(s(2).type,'.')
+%                 % Implement obj(ind).PropertyName
+%                 ...
+%             elseif length(s) == 3 && strcmp(s(2).type,'.') && strcmp(s(3).type,'()')
+%                 % Implement obj(indices).PropertyName(indices)
+%                 ...
+            else
+                % Use built-in for any other expression
+                varargout = {builtin('subsref',obj,s)};
+            end
+        case '{}'
+%             if length(s) == 1
+%                 % Implement obj{indices}
+%                 ...
+%             elseif length(s) == 2 && strcmp(s(2).type,'.')
+%                 % Implement obj{indices}.PropertyName
+%                 ...
+%             else
+%                 % Use built-in for any other expression
+%                 varargout = {builtin('subsref',obj,s)};
+%             end
+            varargout = {builtin('subsref',obj,s)};
+        otherwise
+            error('Not a valid indexing expression')
+    end
+end

+DataKit/+Metadata/@dataFlag/validateId.m

@@ -0,0 +1,11 @@
+function [bool,info] = validateId(id)
+
+    if ~isnumeric(id)
+        error('DataKit:Metadata:dataFlag:validateId:invalidIdDataType',...
+            '''id'' has to be numeric.')
+    end
+
+    infoAll         = DataKit.Metadata.validators.validFlag.listAllValidFlagInfo;
+    [bool,imIdx]  	= ismember(id,infoAll{:,'Id'});
+    info            = infoAll(imIdx(bool),:);
+end

+DataKit/+Metadata/@dataFlag/vertcat.m

@@ -0,0 +1,4 @@
+function obj = vertcat(varargin)
+
+    obj = cat(1,varargin{:});
+end

+DataKit/+Metadata/@info/info.m

@@ -59,6 +59,7 @@
         obj = removeVariable(obj,ind)
         tbl = info2table(obj)
         obj = selectVariable(obj,variableIdx)
+        tf = isequal(objA,objB)
     end
     methods (Access = private)
         obj = validateProperties(obj)

+DataKit/+Metadata/@info/info2table.m

@@ -1,7 +1,6 @@
 function tbl = info2table(obj)
 
     if numel(obj) == 1
-        try
         tbl     = table(...
                     (1:obj.VariableCount)',...
                     obj.Variable',...
@@ -14,9 +13,6 @@
                     obj.VariableOffset',...
                     obj.VariableMeasuringDevice',...
                     'VariableNames',{'VariableIndex','Variable','Id','Type','Unit','Description','Origin','Factor','Offset','MeasuringDevice'});
-        catch
-
-        end
     else
         error('Only works in a scalar context')
     end