[c++/m] Refactor nix.MultiTag retrieveFeatureData

- rename existing function to retrieveFeatureDataIdx
- remove index manipulation on Matlab side
- rewrite existing test

Author: mpsonntag

+nix/MultiTag.m

@@ -111,15 +111,11 @@
                 'MultiTag::openFeatureIdx', idx, @nix.Feature);
         end;
 
-        function data = retrieve_feature_data(obj, pos_index, fea_index)
-            % convert Matlab-like to C-like index
-            assert(pos_index > 0, 'Position index must be positive');
-            assert(fea_index > 0, 'Feature index must be positive');
-            tmp = nix_mx('MultiTag::featureRetrieveData', obj.nix_handle, ...
-                pos_index - 1, fea_index - 1);
+        function data = retrieve_feature_data_idx(obj, pos_idx, feat_idx)
+            tmp = nix_mx('MultiTag::featureRetrieveDataIdx', ...
+                            obj.nix_handle, pos_idx, feat_idx);
 
-            % data must agree with file & dimensions
-            % see mkarray.cc(42)
+            % data must agree with file & dimensions; see mkarray.cc(42)
             data = permute(tmp, length(size(tmp)):-1:1);
         end;
 

nix_mx.cc

@@ -364,7 +364,6 @@ void mexFunction(int            nlhs,
             .reg("sourceCount", GETTER(nix::ndsize_t, nix::MultiTag, sourceCount))
             .reg("referenceCount", GETTER(nix::ndsize_t, nix::MultiTag, referenceCount))
             .reg("featureCount", GETTER(nix::ndsize_t, nix::MultiTag, featureCount));
-        methods->add("MultiTag::featureRetrieveData", nixmultitag::retrieveFeatureData);
         methods->add("MultiTag::addReference", nixmultitag::addReference);
         methods->add("MultiTag::addReferences", nixmultitag::addReferences);
         methods->add("MultiTag::addSource", nixmultitag::addSource);
@@ -379,6 +378,7 @@ void mexFunction(int            nlhs,
         methods->add("MultiTag::referencesFiltered", nixmultitag::referencesFiltered);
         methods->add("MultiTag::featuresFiltered", nixmultitag::featuresFiltered);
         methods->add("MultiTag::retrieveDataIdx", nixmultitag::retrieveDataIdx);
+        methods->add("MultiTag::featureRetrieveDataIdx", nixmultitag::retrieveFeatureDataIdx);
 
         classdef<nix::Section>("Section", methods)
             .desc(&nixsection::describe)

src/nixmultitag.cc

@@ -61,15 +61,6 @@ namespace nixmultitag {
         output.set(0, handle(newFeat));
     }
 
-    void retrieveFeatureData(const extractor &input, infusor &output) {
-        nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
-        double p_index = input.num<double>(2);
-        double f_index = input.num<double>(3);
-
-        mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(p_index, f_index));
-        output.set(0, data);
-    }
-
     void addPositions(const extractor &input, infusor &output) {
         nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
         currObj.positions(input.str(2));
@@ -135,4 +126,13 @@ namespace nixmultitag {
         output.set(0, data);
     }
 
+    void retrieveFeatureDataIdx(const extractor &input, infusor &output) {
+        nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
+        size_t pos_idx = (size_t)input.num<double>(2);
+        size_t ref_idx = (size_t)input.num<double>(3);
+
+        mxArray *data = make_mx_array_from_ds(currObj.retrieveFeatureData(pos_idx, ref_idx));
+        output.set(0, data);
+    }
+
 } // namespace nixmultitag

src/nixmultitag.h

@@ -25,8 +25,6 @@ namespace nixmultitag {
 
     void createFeature(const extractor &input, infusor &output);
 
-    void retrieveFeatureData(const extractor &input, infusor &output);
-
     void addPositions(const extractor &input, infusor &output);
 
     void openReferenceIdx(const extractor &input, infusor &output);
@@ -45,6 +43,8 @@ namespace nixmultitag {
 
     void retrieveDataIdx(const extractor &input, infusor &output);
 
+    void retrieveFeatureDataIdx(const extractor &input, infusor &output);
+
 } // namespace nixmultitag
 
 #endif

tests/TestMultiTag.m

@@ -41,7 +41,7 @@
     funcs{end+1} = @test_set_metadata;
     funcs{end+1} = @test_open_metadata;
     funcs{end+1} = @test_retrieve_data_idx;
-    funcs{end+1} = @test_retrieve_feature_data;
+    funcs{end+1} = @test_retrieve_feature_data_idx;
     funcs{end+1} = @test_set_units;
     funcs{end+1} = @test_attrs;
     funcs{end+1} = @test_compare;
@@ -704,9 +704,92 @@
 end
 
 %% Test: Retrieve feature data
-function [] = test_retrieve_feature_data( varargin )
-    % TODO
-    disp('Test MultiTag: retrieve feature ... TODO (proper testfile)');
+function [] = test_retrieve_feature_data_idx( varargin )
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.create_block('testBlock', 'nixBlock');
+
+    % create feature data arrays
+    raw_feat1 = [11 12 13 14 15 16 17 18];
+    da_feat1 = b.create_data_array_from_data('feature1', 'nixDataArray', raw_feat1);
+    da_feat1.append_sampled_dimension(1);
+
+    raw_feat2 = [21 22 23 24 25 26 27 28];
+    da_feat2 = b.create_data_array_from_data('feature2', 'nixDataArray', raw_feat2);
+    da_feat2.append_sampled_dimension(1);
+
+    % create referenced data array
+    raw_feat3 = [31 32 33 34 35 36 37 38];
+    da_feat3 = b.create_data_array_from_data('reference', 'nixDataArray', raw_feat3);
+    da_feat3.append_sampled_dimension(1);
+
+    % create position, extents DA and multi tag
+    pos = [0; 3; 5];
+    ext = [1; 1; 3];
+
+    da_pos = b.create_data_array_from_data('positions', 'nixDataArray', pos);
+    da_ext = b.create_data_array_from_data('extents', 'nixDataArray', ext);
+
+    da_pos.append_sampled_dimension(0);
+    da_ext.append_sampled_dimension(0);
+
+    t = b.create_multi_tag('testMultiTag', 'nixMultiTag', da_pos);
+    t.set_extents(da_ext);
+
+    % add feature data_arrays
+    t.add_feature(da_feat1, nix.LinkType.Untagged);
+    t.add_feature(da_feat2, nix.LinkType.Tagged);
+    t.add_feature(da_feat3, nix.LinkType.Indexed);
+
+    % test invalid position idx
+    try
+        t.retrieve_feature_data_idx(100, 1);
+    catch ME
+        assert(isempty(strfind(ME.message, 'ounds of positions or extents')), ...
+            'Invalid position index failed');
+    end
+    assert(exist('ME') == 1, 'Invalid position index fail, error not raised');
+    clear ME;
+
+    % test invalid feature idx
+    try
+        t.retrieve_feature_data_idx(0, 100);
+    catch ME
+        assert(~isempty(strfind(ME.message, 'out of bounds')), ...
+            'Invalid reference index failed');
+    end
+    assert(exist('ME') == 1, 'Invalid reference index fail, error not raised');
+    clear ME;
+
+    % test untagged ignores position and returns full data
+    retData = t.retrieve_feature_data_idx(100, 0);
+    assert(isequal(raw_feat1, retData), 'Untagged fail');
+
+    % test tagged properly applies position and extents
+    retData = t.retrieve_feature_data_idx(0, 1);
+    assert(isequal(retData, [21]), 'Tagged pos 1 fail');
+
+    retData = t.retrieve_feature_data_idx(1, 1);
+    assert(isequal(retData, [24]), 'Tagged pos 2 fail');
+
+    retData = t.retrieve_feature_data_idx(2, 1);
+    assert(isequal(retData, [26, 27, 28]), 'Tagged pos 3 fail');
+
+    % test indexed returns first and last index value
+    retData = t.retrieve_feature_data_idx(0, 2);
+    assert(isequal(retData, raw_feat3(1)), 'Indexed first pos fail');
+    
+    retData = t.retrieve_feature_data_idx(7, 2);
+    assert(isequal(retData, raw_feat3(end)), 'Indexed last pos fail');
+    
+    % test indexed fail when accessing position > length of referenced array
+    try
+        t.retrieve_feature_data_idx(size(raw_feat3, 2) + 1, 2);
+    catch ME
+        assert(~isempty(strfind(ME.message, 'than the data stored in the feature')), ...
+            'Indexed out of length fail');
+    end
+    assert(exist('ME') == 1, 'Indexed out of length fail, error not raised');
+    clear ME;
 end
 
 %% Test: nix.MultiTag has feature by ID