[c++/m] Refactor nix.MultiTag retrieveData function

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

Author: mpsonntag

+nix/MultiTag.m

@@ -62,15 +62,10 @@
                 'MultiTag::openReferenceIdx', idx, @nix.DataArray);
         end;
 
-        function data = retrieve_data(obj, pos_index, ref_index)
-            % convert Matlab-like to C-like index
-            assert(pos_index > 0, 'Position index must be positive');
-            assert(ref_index > 0, 'Reference index must be positive');
-            tmp = nix_mx('MultiTag::retrieveData', obj.nix_handle, ...
-                pos_index - 1, ref_index - 1);
+        function data = retrieve_data_idx(obj, pos_idx, ref_idx)
+            tmp = nix_mx('MultiTag::retrieveDataIdx', obj.nix_handle, pos_idx, ref_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::retrieveData", nixmultitag::retrieveData);
         methods->add("MultiTag::featureRetrieveData", nixmultitag::retrieveFeatureData);
         methods->add("MultiTag::addReference", nixmultitag::addReference);
         methods->add("MultiTag::addReferences", nixmultitag::addReferences);
@@ -379,6 +378,7 @@ void mexFunction(int            nlhs,
         methods->add("MultiTag::sourcesFiltered", nixmultitag::sourcesFiltered);
         methods->add("MultiTag::referencesFiltered", nixmultitag::referencesFiltered);
         methods->add("MultiTag::featuresFiltered", nixmultitag::featuresFiltered);
+        methods->add("MultiTag::retrieveDataIdx", nixmultitag::retrieveDataIdx);
 
         classdef<nix::Section>("Section", methods)
             .desc(&nixsection::describe)

src/nixmultitag.cc

@@ -61,15 +61,6 @@ namespace nixmultitag {
         output.set(0, handle(newFeat));
     }
 
-    void retrieveData(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.retrieveData(p_index, f_index));
-        output.set(0, data);
-    }
-
     void retrieveFeatureData(const extractor &input, infusor &output) {
         nix::MultiTag currObj = input.entity<nix::MultiTag>(1);
         double p_index = input.num<double>(2);
@@ -135,4 +126,13 @@ namespace nixmultitag {
         output.set(0, res);
     }
 
+    void retrieveDataIdx(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.retrieveData(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 retrieveData(const extractor &input, infusor &output);
-
     void retrieveFeatureData(const extractor &input, infusor &output);
 
     void addPositions(const extractor &input, infusor &output);
@@ -45,6 +43,8 @@ namespace nixmultitag {
 
     void featuresFiltered(const extractor &input, infusor &output);
 
+    void retrieveDataIdx(const extractor &input, infusor &output);
+
 } // namespace nixmultitag
 
 #endif

tests/TestMultiTag.m

@@ -40,7 +40,7 @@
     funcs{end+1} = @test_set_open_extents;
     funcs{end+1} = @test_set_metadata;
     funcs{end+1} = @test_open_metadata;
-    funcs{end+1} = @test_retrieve_data;
+    funcs{end+1} = @test_retrieve_data_idx;
     funcs{end+1} = @test_retrieve_feature_data;
     funcs{end+1} = @test_set_units;
     funcs{end+1} = @test_attrs;
@@ -644,14 +644,63 @@
     assert(strcmp(t.open_metadata.name, 'testSection'));
 end
 
-%% Test: Retrieve data
-function [] = test_retrieve_data( varargin )
-    f = nix.File(fullfile(pwd, 'tests', 'test.h5'), nix.FileMode.ReadOnly);
-    b = f.blocks{1};
-    tag = b.multiTags{1};
+%% Test: Retrieve reference data by index
+function [] = test_retrieve_data_idx( varargin )
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.create_block('testBlock', 'nixBlock');
+
+    pos(1,:) = [0, 0]; ext(1,:) = [0, 0]; % result 111
+    pos(2,:) = [1, 1]; ext(2,:) = [0, 3]; % result 122 123 124
+    pos(3,:) = [0, 2]; ext(3,:) = [2, 4]; % result 113 114 115 116
+                                          %        123 124 125 126
+
+	d_pos = b.create_data_array_from_data('positionsDA', 'nixDataArray', pos);
+    d_pos.append_sampled_dimension(0);
+    d_pos.append_sampled_dimension(0);
+
+    d_ext = b.create_data_array_from_data('extentsDA', 'nixDataArray', ext);
+    d_ext.append_sampled_dimension(0);
+    d_ext.append_sampled_dimension(0);
+
+    t = b.create_multi_tag('testMultiTag', 'nixMultiTag', d_pos);
+    t.set_extents(d_ext);
+
+    % create 2D reference data_arrays
+    raw1 = [111, 112, 113, 114, 115, 116, 117, 118; ...
+                121, 122, 123, 124, 125, 126, 127, 128];
+    d1 = b.create_data_array_from_data('reference1', 'nixDataArray', raw1);
+    d1.append_sampled_dimension(1);
+    d1.append_sampled_dimension(1);
+
+    raw2 = [211, 212, 213, 214, 215, 216, 217, 218; ...
+                221, 222, 223, 224, 225, 226, 227, 228];
+    d2 = b.create_data_array_from_data('reference2', 'nixDataArray', raw2);
+    d2.append_sampled_dimension(1);
+    d2.append_sampled_dimension(1);
+
+    % add data_arrays as references to multi tag
+    t.add_reference(d1);
+    t.add_reference(d2);
+
+    % test invalid position idx
+    try
+        t.retrieve_data_idx(100, 0);
+    catch ME
+        assert(~isempty(strfind(ME.message, 'ounds of positions or extents')), ...
+            'Invalid position index failed');
+    end
+
+    % test invalid reference idx
+    try
+        t.retrieve_data_idx(0, 100);
+    catch ME
+        assert(~isempty(strfind(ME.message, 'out of bounds')), ...
+            'Invalid reference index failed');
+    end
 
-    data = tag.retrieve_data(1, 1);
-    assert(~isempty(data));
+    assert(isequal(t.retrieve_data_idx(0, 0), raw1(1:1)), 'Retrieve pos 1, ref 1 fail');
+    assert(isequal(t.retrieve_data_idx(1, 0), raw1(2, 2:4)), 'Retrieve pos 2, ref 1 fail');
+    assert(isequal(t.retrieve_data_idx(2, 1), raw2(1:2, 3:6)), 'Retrieve pos 3, ref 2 fail');
 end
 
 %% Test: Retrieve feature data