Merge pull request #57 from asobolev/master

gicmo · gicmo · commit 0549027f4388 · 2015-03-06T13:42:30.000+01:00
Create data array / write_all methods

LGTM
diff --git a/+nix/Block.m b/+nix/Block.m
@@ -37,6 +37,21 @@
             end;
         end;
         
+        function da = create_data_array(obj, name, nixtype, dtype, shape)
+            handle = nix_mx('Block::createDataArray', obj.nix_handle, ...
+                name, nixtype, dtype, shape);
+            da = nix.DataArray(handle);
+            obj.dataArraysCache.lastUpdate = 0;
+        end
+        
+        function da = create_data_array_from_data(obj, name, nixtype, data)
+            shape = size(data);
+            dtype = class(data);
+            
+            da = obj.create_data_array(name, nixtype, dtype, shape);
+            da.write_all(data);
+        end
+        
         % -----------------
         % Sources methods
         % -----------------
diff --git a/+nix/DataArray.m b/+nix/DataArray.m
@@ -71,13 +71,24 @@
            polynom_coefficients = obj.info.polynom_coefficients;
         end;
         
+        % -----------------
+        % Data access methods
+        % -----------------
+
         function data = read_all(obj)
            tmp = nix_mx('DataArray::readAll', obj.nix_handle);
            % data must agree with file & dimensions
            % see mkarray.cc(42)
            data = permute(tmp, length(size(tmp)):-1:1);
         end;
         
+        function write_all(obj, data)  % TODO add (optional) offset
+           % data must agree with file & dimensions
+           % see mkarray.cc(42)
+           tmp = permute(data, length(size(data)):-1:1);
+           nix_mx('DataArray::writeAll', obj.nix_handle, tmp);
+        end;
+        
         % -----------------
         % Sources methods
         % -----------------
diff --git a/nix_mx.cc b/nix_mx.cc
@@ -142,7 +142,7 @@ void mexFunction(int            nlhs,
 
         methods = new registry{};
 
-        methods->add("Entity::destory", entity_destroy);
+        methods->add("Entity::destroy", entity_destroy);
         methods->add("Entity::updatedAt", entity_updated_at);
 
         classdef<nix::File>("File", methods)
@@ -157,7 +157,10 @@ void mexFunction(int            nlhs,
 
         classdef<nix::Block>("Block", methods)
             .reg("dataArrays", &nix::Block::dataArrays)
+            .reg("createSource", &nix::Block::createSource)
+            //.reg("createDataArray", static_cast<nix::DataArray(nix::Block::*)(const std::string &, const std::string &, nix::DataType, const nix::NDSize &)>(&nix::Block::createDataArray))
             .reg("createTag", &nix::Block::createTag)
+            .reg("createMultiTag", &nix::Block::createMultiTag)
             .reg("sources", &nix::Block::sources)
             .reg("tags", &nix::Block::tags)
             .reg("multiTags", &nix::Block::multiTags)
@@ -168,10 +171,12 @@ void mexFunction(int            nlhs,
             .reg("openTag", GETBYSTR(nix::Tag, nix::Block, getTag))
             .reg("openMultiTag", GETBYSTR(nix::MultiTag, nix::Block, getMultiTag))
             .reg("openMetadataSection", GETCONTENT(nix::Section, nix::Block, metadata));
+        methods->add("Block::createDataArray", nixblock::create_data_array);
 
         classdef<nix::DataArray>("DataArray", methods)
             .reg("sources", GETSOURCES(IDataArray))
             .reg("openMetadataSection", GETMETADATA(IDataArray));
+        methods->add("DataArray::writeAll", nixdataarray::write_all);
 
         classdef<nix::Source>("Source", methods)
             .reg("sources", &nix::Source::sources)
diff --git a/src/nixblock.cc b/src/nixblock.cc
@@ -25,6 +25,19 @@ namespace nixblock {
         output.set(0, sb.array());
     }
 
+    void create_data_array(const extractor &input, infusor &output)
+    {
+        nix::Block block = input.entity<nix::Block>(1);
+
+        std::string name = input.str(2);
+        std::string type = input.str(3);
+        nix::DataType dtype = nix::DataType::Double; // FIXME nix::string_to_data_type(input.str(3));
+        nix::NDSize size = input.ndsize(5);
+
+        nix::DataArray dt = block.createDataArray(name, type, dtype, size);
+        output.set(0, dt);
+    }
+
     void list_data_arrays(const extractor &input, infusor &output)
     {
         nix::Block block = input.entity<nix::Block>(1);
diff --git a/src/nixblock.h b/src/nixblock.h
@@ -7,6 +7,8 @@ namespace nixblock {
 
     void describe(const extractor &input, infusor &output);
 
+    void create_data_array(const extractor &input, infusor &output);
+
     void list_data_arrays(const extractor &input, infusor &output);
 
     void list_sources(const extractor &input, infusor &output);
diff --git a/src/nixdataarray.cc b/src/nixdataarray.cc
@@ -63,4 +63,16 @@ namespace nixdataarray {
         output.set(0, data);
     }
 
+    void write_all(const extractor &input, infusor &output)
+    {
+        nix::DataArray da = input.entity<nix::DataArray>(1);
+
+        nix::DataType dtype = input.dtype(2);
+        nix::NDSize count = input.ndsize(2);
+        nix::NDSize offset(0);
+        double *ptr = input.get_raw(2);
+
+        da.setData(dtype, ptr, count, offset);
+    }
+
 } // namespace nixdataarray
diff --git a/src/nixdataarray.h b/src/nixdataarray.h
@@ -9,6 +9,8 @@ namespace nixdataarray {
     
     void read_all(const extractor &input, infusor &output);
 
+    void write_all(const extractor &input, infusor &output);
+
 } // namespace nixdataarray
 
 #endif
diff --git a/src/utils/arguments.h b/src/utils/arguments.h
@@ -5,7 +5,7 @@
 #include "handle.h"
 #include "datatypes.h"
 #include "mkarray.h"
-
+#include "nix2mx.h"
 #include <stdexcept>
 
 // *** argument helpers ***
@@ -98,6 +98,14 @@ class extractor : public argument_helper<const mxArray> {
         return res;
     }
 
+    nix::NDSize ndsize(size_t pos) const {
+        return mx_array_to_ndsize(array[pos]);
+    }
+    
+    nix::DataType dtype(size_t pos) const {
+        return dtype_mex2nix(array[pos]);
+    }
+
 	bool logical(size_t pos) const {
 		check_arg_type(pos, nix::DataType::Bool);
 
@@ -124,6 +132,10 @@ class extractor : public argument_helper<const mxArray> {
         return category == mxCHAR_CLASS;
     }
 
+    double* get_raw(size_t pos) const {
+        return mxGetPr(array[pos]);
+    }
+
 private:
 };
 
diff --git a/src/utils/nix2mx.cc b/src/utils/nix2mx.cc
@@ -54,7 +54,6 @@ mxArray *dim_to_struct(nix::RangeDimension dim) {
     return sb.array();
 }
 
-/*
 nix::NDSize mx_array_to_ndsize(const mxArray *arr) {
 
     size_t m = mxGetM(arr);
@@ -72,4 +71,4 @@ nix::NDSize mx_array_to_ndsize(const mxArray *arr) {
 
     return size;
 }
-*/
+
diff --git a/src/utils/nix2mx.h b/src/utils/nix2mx.h
@@ -4,7 +4,7 @@
 #include "mex.h"
 #include <nix.hpp>
 
-//nix::NDSize mx_array_to_ndsize(const mxArray *arr);
+nix::NDSize mx_array_to_ndsize(const mxArray *arr);
 
 mxArray *nmCreateScalar(uint32_t val);
 
diff --git a/tests/TestBlock.m b/tests/TestBlock.m
@@ -16,6 +16,8 @@
     funcs{end+1} = @test_open_metadata;
     funcs{end+1} = @test_attrs;
     funcs{end+1} = @test_create_tag;
+    funcs{end+1} = @test_create_data_array;
+    funcs{end+1} = @test_create_data_array_from_data;
 end
 
 function [] = test_list_arrays( varargin )
@@ -174,3 +176,41 @@
     
     assert(~isempty(b.tags));
 end
+
+function [] = test_create_data_array( varargin )
+%% Test: Create Data Array
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.createBlock('arraytest', 'nixblock');
+    
+    assert(isempty(b.dataArrays));
+    
+    d1 = b.create_data_array('foo', 'bar', 'double', [2 3]);
+
+    assert(strcmp(d1.name, 'foo'));
+    assert(strcmp(d1.type, 'bar'));
+    tmp = d1.read_all();
+    assert(all(tmp(:) == 0));
+    
+    assert(~isempty(b.dataArrays));
+end
+
+function [] = test_create_data_array_from_data( varargin )
+%% Test: Create Data Array from data
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.createBlock('arraytest', 'nixblock');
+    
+    assert(isempty(b.dataArrays));
+    
+    data = [1, 2, 3; 4, 5, 6];
+    d1 = b.create_data_array_from_data('foo', 'bar', data);
+
+    assert(strcmp(d1.name, 'foo'));
+    assert(strcmp(d1.type, 'bar'));
+    
+    tmp = d1.read_all();
+    assert(strcmp(class(tmp), class(data)));
+    assert(isequal(size(tmp), size(data)));
+    assert(isequal(tmp, data));
+    
+    assert(~isempty(b.dataArrays));
+end
diff --git a/tests/TestDataArray.m b/tests/TestDataArray.m
@@ -6,6 +6,7 @@
     funcs{end+1} = @test_open_data;
     funcs{end+1} = @test_open_metadata;
     funcs{end+1} = @test_list_sources;
+    funcs{end+1} = @test_set_data;
 end
 
 %% Test: Read all data from DataArray
@@ -41,3 +42,17 @@
     assert(strcmp(d1.sources{1}.name, 'Unit 5'));
 end
 
+%% Test: Set Data
+function [] = test_set_data( varargin )
+    f = nix.File(fullfile(pwd, 'tests', 'testRW.h5'), nix.FileMode.Overwrite);
+    b = f.createBlock('tagtest', 'nixblock');
+
+    d1 = b.create_data_array('foo', 'bar', 'double', [2 3]);
+    tmp = d1.read_all();
+    assert(all(tmp(:) == 0));
+    
+    data = [1, 2, 3; 4, 5, 6];
+    d1.write_all(data);
+    assert(isequal(d1.read_all(), data));
+end
+

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,6 @@ mxArray *dim_to_struct(nix::RangeDimension dim) {`
`54`	`54`	`return sb.array();`
`55`	`55`	`}`
`56`	`56`
`57`		`-/*`
`58`	`57`	`nix::NDSize mx_array_to_ndsize(const mxArray *arr) {`
`59`	`58`
`60`	`59`	`size_t m = mxGetM(arr);`
`@@ -72,4 +71,4 @@ nix::NDSize mx_array_to_ndsize(const mxArray *arr) {`
`72`	`71`
`73`	`72`	`return size;`
`74`	`73`	`}`
`75`		`-*/`
	`74`	`+`