Merge pull request #84 from asobolev/master

mpsonntag · mpsonntag · commit 981521a07104 · 2015-03-19T15:11:55.000+01:00
Dimensions (Matlab part)
diff --git a/+nix/DataArray.m b/+nix/DataArray.m
@@ -26,20 +26,57 @@
             
             obj.dimsCache = nix.CacheStruct();
         end;
+
+        % -----------------
+        % Dimensions
+        % -----------------
         
         function dimensions = get.dimensions(obj)
             if obj.dimsCache.lastUpdate ~= obj.updatedAt
                 currList = nix_mx('DataArray::dimensions', obj.nix_handle);
                 obj.dimsCache.data = cell(length(currList), 1);
                 for i = 1:length(currList)
-                    % TODO convert to a proper type 
-                	obj.dimsCache.data{i} = nix.SetDimension(currList{i});
+                    
+                    switch currList(i).dtype
+                        case 'set'
+                            obj.dimsCache.data{i} = nix.SetDimension(currList(i).dimension);
+                        case 'sample'
+                            obj.dimsCache.data{i} = nix.SampledDimension(currList(i).dimension);
+                        case 'range'
+                            obj.dimsCache.data{i} = nix.RangeDimension(currList(i).dimension);
+                        otherwise
+                           disp('some dimension type is unknown! skip')
+                    end
                 end;
                 obj.dimsCache.lastUpdate = obj.updatedAt;
             end;
             dimensions = obj.dimsCache.data;
         end;
         
+        function dim = append_set_dimension(obj)
+            func_name = strcat(obj.alias, '::append_set_dimension');
+            dim = nix.SetDimension(nix_mx(func_name, obj.nix_handle));
+            obj.dimsCache.lastUpdate = 0;
+        end
+        
+        function dim = append_sampled_dimension(obj, interval)
+            func_name = strcat(obj.alias, '::append_sampled_dimension');
+            dim = nix.SampledDimension(nix_mx(func_name, obj.nix_handle, interval));
+            obj.dimsCache.lastUpdate = 0;
+        end
+
+        function dim = append_range_dimension(obj, ticks)
+            func_name = strcat(obj.alias, '::append_range_dimension');
+            dim = nix.RangeDimension(nix_mx(func_name, obj.nix_handle, ticks));
+            obj.dimsCache.lastUpdate = 0;
+        end
+
+        function delCheck = delete_dimension(obj, index)
+            func_name = strcat(obj.alias, '::delete_dimension');
+            delCheck = nix_mx(func_name, obj.nix_handle, index);
+            obj.dimsCache.lastUpdate = 0;
+        end;
+        
         % -----------------
         % Data access methods
         % -----------------
diff --git a/+nix/Dynamic.m b/+nix/Dynamic.m
@@ -24,7 +24,7 @@ function set_method(obj, val)
                 end
                 
                 if (isempty(val))
-                    nix_mx(strcat(obj.alias, '::set_none_', prop), obj.nix_handle, val);
+                    nix_mx(strcat(obj.alias, '::set_none_', prop), obj.nix_handle, 0);
                 else
                     nix_mx(strcat(obj.alias, '::set_', prop), obj.nix_handle, val);
                 end
diff --git a/+nix/RangeDimension.m b/+nix/RangeDimension.m
@@ -0,0 +1,40 @@
+classdef RangeDimension < nix.Entity
+    %RangeDimension nix RangeDimension object
+    
+    properties (Hidden)
+        % namespace reference for nix-mx functions
+        alias = 'RangeDimension'
+    end
+    
+    methods
+        function obj = RangeDimension(h)
+            obj@nix.Entity(h);
+            
+            % assign dynamic properties
+            nix.Dynamic.add_dyn_attr(obj, 'dimensionType', 'r');
+            nix.Dynamic.add_dyn_attr(obj, 'label', 'rw');
+            nix.Dynamic.add_dyn_attr(obj, 'unit', 'rw');
+            nix.Dynamic.add_dyn_attr(obj, 'ticks', 'rw');
+        end
+
+        function tickAt = tick_at(obj, index)
+            func_name = strcat(obj.alias, '::tick_at');
+            tickAt = nix_mx(func_name, obj.nix_handle, index);
+        end
+        
+        function indexOf = index_of(obj, position)
+            func_name = strcat(obj.alias, '::index_of');
+            indexOf = nix_mx(func_name, obj.nix_handle, position);
+        end
+
+        function axis = axis(obj, count, startIndex)
+            if nargin < 3
+                startIndex = 0;
+            end
+            
+            func_name = strcat(obj.alias, '::axis');
+            axis = nix_mx(func_name, obj.nix_handle, count, startIndex);
+        end
+    end
+end
+   
diff --git a/+nix/SampledDimension.m b/+nix/SampledDimension.m
@@ -0,0 +1,41 @@
+classdef SampledDimension < nix.Entity
+    %SampledDimension nix SampledDimension object
+    
+    properties (Hidden)
+        % namespace reference for nix-mx functions
+        alias = 'SampledDimension'
+    end
+    
+    methods
+        function obj = SampledDimension(h)
+            obj@nix.Entity(h);
+            
+            % assign dynamic properties
+            nix.Dynamic.add_dyn_attr(obj, 'dimensionType', 'r');
+            nix.Dynamic.add_dyn_attr(obj, 'label', 'rw');
+            nix.Dynamic.add_dyn_attr(obj, 'unit', 'rw');
+            nix.Dynamic.add_dyn_attr(obj, 'samplingInterval', 'rw');
+            nix.Dynamic.add_dyn_attr(obj, 'offset', 'rw');
+        end
+
+        function indexOf = index_of(obj, position)
+            func_name = strcat(obj.alias, '::index_of');
+            indexOf = nix_mx(func_name, obj.nix_handle, position);
+        end
+        
+        function posAt = position_at(obj, index)
+            func_name = strcat(obj.alias, '::position_at');
+            posAt = nix_mx(func_name, obj.nix_handle, index);
+        end
+
+        function axis = axis(obj, count, startIndex)
+            if nargin < 3
+                startIndex = 0;
+            end
+            
+            func_name = strcat(obj.alias, '::axis');
+            axis = nix_mx(func_name, obj.nix_handle, count, startIndex);
+        end
+    end
+end
+   
diff --git a/+nix/SetDimension.m b/+nix/SetDimension.m
@@ -9,11 +9,11 @@
     methods
         function obj = SetDimension(h)
             obj@nix.Entity(h);
+            
+            % assign dynamic properties
+            nix.Dynamic.add_dyn_attr(obj, 'dimensionType', 'r');
+            nix.Dynamic.add_dyn_attr(obj, 'labels', 'rw');
         end
-        
-        function ua = updatedAt(obj)
-            ua = 0;
-        end;
     end
 end
    
diff --git a/nix_mx.cc b/nix_mx.cc
@@ -150,8 +150,8 @@ void mexFunction(int            nlhs,
             .reg("append_sampled_dimension", &nix::DataArray::appendSampledDimension)
             .reg("create_set_dimension", &nix::DataArray::createSetDimension)
             .reg("create_range_dimension", &nix::DataArray::createRangeDimension)
-            .reg("create_sampled_dimension", &nix::DataArray::createSampledDimension)
-            .reg("deleteDimension", &nix::DataArray::deleteDimension);
+            .reg("create_sampled_dimension", &nix::DataArray::createSampledDimension);
+        methods->add("DataArray::delete_dimension", nixdataarray::delete_dimension);
         methods->add("DataArray::readAll", nixdataarray::read_all);
         methods->add("DataArray::writeAll", nixdataarray::write_all);
         methods->add("DataArray::addSource", nixdataarray::add_source);
@@ -272,7 +272,7 @@ void mexFunction(int            nlhs,
             .reg("set_none_label", SETTER(const boost::none_t, nix::SampledDimension, label))
             .reg("set_unit", SETTER(const std::string&, nix::SampledDimension, unit))
             .reg("set_none_unit", SETTER(const boost::none_t, nix::SampledDimension, unit))
-            .reg("set_sampling", SETTER(double, nix::SampledDimension, samplingInterval))
+            .reg("set_samplingInterval", SETTER(double, nix::SampledDimension, samplingInterval))
             .reg("set_offset", SETTER(double, nix::SampledDimension, offset))
             .reg("set_none_offset", SETTER(const boost::none_t, nix::SampledDimension, offset))
             .reg("index_of", &nix::SampledDimension::indexOf)
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -60,4 +60,13 @@ namespace nixdataarray {
         da.setData(dtype, ptr, count, offset);
     }
 
+    void delete_dimension(const extractor &input, infusor &output) {
+        nix::DataArray da = input.entity<nix::DataArray>(1);
+
+        const size_t idx = static_cast<size_t>(input.num<double>(2));
+        bool res = da.deleteDimension(idx);
+
+        output.set(0, res);
+    }
+
 } // namespace nixdataarray
diff --git a/src/nixdataarray.h b/src/nixdataarray.h
@@ -15,6 +15,8 @@ namespace nixdataarray {
 
     void write_all(const extractor &input, infusor &output);
 
+    void delete_dimension(const extractor &input, infusor &output);
+
 } // namespace nixdataarray
 
 #endif
diff --git a/src/nixdimensions.cc b/src/nixdimensions.cc
@@ -13,7 +13,7 @@ namespace nixdimensions {
 
     mxArray *describe(const nix::SetDimension &dim)
     {
-        struct_builder sb({ 1 }, { "dim_type", "labels" });
+        struct_builder sb({ 1 }, { "dimensionType", "labels" });
 
         sb.set(dim.dimensionType());
         sb.set(dim.labels());
@@ -23,7 +23,7 @@ namespace nixdimensions {
 
     mxArray *describe(const nix::SampledDimension &dim)
     {
-        struct_builder sb({ 1 }, { "dim_type", "label", "unit", "sampling_interval", "offset" });
+        struct_builder sb({ 1 }, { "dimensionType", "label", "unit", "samplingInterval", "offset" });
 
         sb.set(dim.dimensionType());
         sb.set(dim.label());
@@ -36,7 +36,7 @@ namespace nixdimensions {
 
     mxArray *describe(const nix::RangeDimension &dim)
     {
-        struct_builder sb({ 1 }, { "dim_type", "label", "unit", "ticks" });
+        struct_builder sb({ 1 }, { "dimensionType", "label", "unit", "ticks" });
 
         sb.set(dim.dimensionType());
         sb.set(dim.label());
diff --git a/src/utils/mkarray.cc b/src/utils/mkarray.cc
@@ -30,15 +30,15 @@ mxArray* make_mx_array(const nix::LinkType &ltype)
 
 mxArray* make_mx_array(const nix::DimensionType &dtype)
 {
-    uint8_t d_type;
+    const char *d_type;
 
     switch (dtype) {
-    case nix::DimensionType::Set: d_type = 0; break;
-    case nix::DimensionType::Sample: d_type = 1; break;
-    case nix::DimensionType::Range: d_type = 2; break;
+    case nix::DimensionType::Set: d_type = "set"; break;
+    case nix::DimensionType::Sample: d_type = "sample"; break;
+    case nix::DimensionType::Range: d_type = "range"; break;
     default: throw std::invalid_argument("unkown dimension type");
     }
-    mxArray *data = mxCreateDoubleScalar(d_type);
+    mxArray *data = mxCreateString(d_type);
 
     return data;
 }
diff --git a/src/utils/mkarray.h b/src/utils/mkarray.h
@@ -125,22 +125,26 @@ inline mxArray *make_mx_array(const std::vector<T> &v) {
 }
 
 inline mxArray* make_mx_array(const std::vector<nix::Dimension> &dims) {
-    if (dims.empty()) {
-        return nullptr;
-    }
-
+    const char *field_names[] = { "dtype", "dimension" };
+    mwSize dim_arr[2] = {1, dims.size()};
     nix::DimensionType dt;
 
-    mxArray *data = mxCreateCellMatrix(1, dims.size());
+    mxArray *data = mxCreateStructArray(2, dim_arr, 2, field_names);
     for (size_t i = 0; i < dims.size(); i++) {
         dt = dims[i].dimensionType();
 
         switch (dt) {
-        case nix::DimensionType::Set: mxSetCell(data, i, make_mx_array(dims[i].asSetDimension()));
+        case nix::DimensionType::Set: 
+            mxSetFieldByNumber(data, i, 0, mxCreateString("set"));
+            mxSetFieldByNumber(data, i, 1, make_mx_array(dims[i].asSetDimension()));
             break;
-        case nix::DimensionType::Range: mxSetCell(data, i, make_mx_array(dims[i].asRangeDimension()));
+        case nix::DimensionType::Range:
+            mxSetFieldByNumber(data, i, 0, mxCreateString("range"));
+            mxSetFieldByNumber(data, i, 1, make_mx_array(dims[i].asRangeDimension()));
             break;
-        case nix::DimensionType::Sample: mxSetCell(data, i, make_mx_array(dims[i].asSampledDimension()));
+        case nix::DimensionType::Sample:
+            mxSetFieldByNumber(data, i, 0, mxCreateString("sample"));
+            mxSetFieldByNumber(data, i, 1, make_mx_array(dims[i].asSampledDimension()));
             break;
         default: throw std::invalid_argument("Encountered unknown dimension type");
             break;
diff --git a/tests/RunTests.m b/tests/RunTests.m
@@ -31,9 +31,11 @@
 t8.tests = TestFeature();
 t9.name = 'PROPERTY';
 t9.tests = TestProperty();
+t10.name = 'DIMENSIONS';
+t10.tests = TestDimensions();
 
 % concatenate all test handles
-all_tests = {t1, t2, t3, t4, t5, t6, t7, t8, t9};
+all_tests = {t1, t2, t3, t4, t5, t6, t7, t8, t9, t10};
 
 for i = 1:length(all_tests)
     fprintf([10 'Execute ' all_tests{i}.name ' tests:\n\n']);
diff --git a/tests/TestDataArray.m b/tests/TestDataArray.m
@@ -11,6 +11,7 @@
     funcs{end+1} = @test_set_data;
     funcs{end+1} = @test_add_source;
     funcs{end+1} = @test_remove_source;
+    funcs{end+1} = @test_dimensions;
 end
 
 function [] = test_attrs( varargin )
@@ -144,3 +145,39 @@
     assert(getDataArray.remove_source('I do not exist'));
     assert(size(getSource.sources, 1) == 2);
 end
+
+%% Test: Dimensions
+function [] = test_dimensions( varargin )
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.createBlock('daTestBlock', 'test nixBlock');
+    da = b.create_data_array('daTest', 'test nixDataArray', 'double', [1 2]);
+    
+    assert(isempty(da.dimensions));
+    
+    da.append_set_dimension();
+    assert(length(da.dimensions) == 1);
+    assert(strcmp(da.dimensions{1}.dimensionType, 'set'));
+    
+    da.append_sampled_dimension(200);
+    assert(length(da.dimensions) == 2);
+    assert(strcmp(da.dimensions{2}.dimensionType, 'sample'));
+    assert(da.dimensions{2}.samplingInterval == 200);
+    
+    ticks = [1, 2, 3, 4];
+    da.append_range_dimension(ticks);
+    assert(length(da.dimensions) == 3);
+    assert(strcmp(da.dimensions{3}.dimensionType, 'range'));
+    assert(isequal(da.dimensions{3}.ticks, ticks));
+    
+    da.delete_dimension(2);
+    assert(length(da.dimensions) == 2);
+    assert(strcmp(da.dimensions{1}.dimensionType, 'set'));
+    assert(strcmp(da.dimensions{2}.dimensionType, 'range'));
+
+    da.delete_dimension(1);
+    assert(length(da.dimensions) == 1);
+    assert(strcmp(da.dimensions{1}.dimensionType, 'range'));
+    
+    da.delete_dimension(1);
+    assert(isempty(da.dimensions));
+end
diff --git a/tests/TestDimensions.m b/tests/TestDimensions.m

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace nixdimensions {`
`13`	`13`
`14`	`14`	`mxArray *describe(const nix::SetDimension &dim)`
`15`	`15`	`{`
`16`		`- struct_builder sb({ 1 }, { "dim_type", "labels" });`
	`16`	`+ struct_builder sb({ 1 }, { "dimensionType", "labels" });`
`17`	`17`
`18`	`18`	`sb.set(dim.dimensionType());`
`19`	`19`	`sb.set(dim.labels());`
`@@ -23,7 +23,7 @@ namespace nixdimensions {`
`23`	`23`
`24`	`24`	`mxArray *describe(const nix::SampledDimension &dim)`
`25`	`25`	`{`
`26`		`- struct_builder sb({ 1 }, { "dim_type", "label", "unit", "sampling_interval", "offset" });`
	`26`	`+ struct_builder sb({ 1 }, { "dimensionType", "label", "unit", "samplingInterval", "offset" });`
`27`	`27`
`28`	`28`	`sb.set(dim.dimensionType());`
`29`	`29`	`sb.set(dim.label());`
`@@ -36,7 +36,7 @@ namespace nixdimensions {`
`36`	`36`
`37`	`37`	`mxArray *describe(const nix::RangeDimension &dim)`
`38`	`38`	`{`
`39`		`- struct_builder sb({ 1 }, { "dim_type", "label", "unit", "ticks" });`
	`39`	`+ struct_builder sb({ 1 }, { "dimensionType", "label", "unit", "ticks" });`
`40`	`40`
`41`	`41`	`sb.set(dim.dimensionType());`
`42`	`42`	`sb.set(dim.label());`
Original file line number	Diff line number	Diff line change
`@@ -30,15 +30,15 @@ mxArray* make_mx_array(const nix::LinkType &ltype)`
`30`	`30`
`31`	`31`	`mxArray* make_mx_array(const nix::DimensionType &dtype)`
`32`	`32`	`{`
`33`		`- uint8_t d_type;`
	`33`	`+ const char *d_type;`
`34`	`34`
`35`	`35`	`switch (dtype) {`
`36`		`- case nix::DimensionType::Set: d_type = 0; break;`
`37`		`- case nix::DimensionType::Sample: d_type = 1; break;`
`38`		`- case nix::DimensionType::Range: d_type = 2; break;`
	`36`	`+ case nix::DimensionType::Set: d_type = "set"; break;`
	`37`	`+ case nix::DimensionType::Sample: d_type = "sample"; break;`
	`38`	`+ case nix::DimensionType::Range: d_type = "range"; break;`
`39`	`39`	`default: throw std::invalid_argument("unkown dimension type");`
`40`	`40`	`}`
`41`		`- mxArray *data = mxCreateDoubleScalar(d_type);`
	`41`	`+ mxArray *data = mxCreateString(d_type);`
`42`	`42`
`43`	`43`	`return data;`
`44`	`44`	`}`