tifffile 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23dd0e7c0379cdaa6ccc08bb996a297150f30298
-  data.tar.gz: 213b127a798ce4cba57936321ca94983b72c28ea
+  metadata.gz: 73ee12cfcfb7b19f45966c553780006c9e2ea981
+  data.tar.gz: aadabb05a8725757870334ebdffec87f22d0451d
 SHA512:
-  metadata.gz: 904c860a603bee5fd5bd0a7549e5fc3a5102e799e4457615a7e01b0b1c7f77b266609edb35dc61f05577b3692a324caabb3df14ef121abba9297c2b7049350c1
-  data.tar.gz: 8a1a2da681b979a680ae321ded5f3291ff3f004a4b372ea8c1eca3de7fb59bf594af8b77992506087d07f94da39ac3ec789e74d0a2108d7808925e9af8a8fd16
+  metadata.gz: 7713c2989ad9be58d24c32cdb9dc63ea10971f32c376102627e442efe013b0e7d5492118ace195b65af387c0538a3e77b96d93f1d23a06f955880712d57a590a
+  data.tar.gz: 072ec891538ef01d00efd6210417ad0d90e7cf6b877f716cf72a8caab050841f14bfc9c50d4c37d9dee9373d60d8da2bab112f53c187e30aa64d1a2f55f23612

data/.gemspec

@@ -2,8 +2,8 @@ require File.expand_path("../lib/tifffile/version", __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name    = 'tifffile'
-  gem.version = TiffFile::VERSION
-  gem.date    = '2016-03-21'
+  gem.version = TiffFileVersion::VERSION
+  gem.date    = '2016-03-22'
 
   gem.summary = "TIFF reader and writer"
   gem.description = ""

data/Rakefile

@@ -1,6 +1,14 @@
 require "rake/extensiontask"
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
 
 Rake::ExtensionTask.new "tifffile" do |ext|
   ext.lib_dir = "lib/tifffile"
 end
 
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  Rake::Task['compile'].invoke
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+

data/analyzer.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+
+import numpy as np
+from libtiff import TIFFfile
+from libtiff import TIFF
+
+def read(fileName):
+    """
+    Script to import tif file from imageJ,
+    usage: zstack =  tiff.read(inFileName)
+    PTW 2015/01/29
+    """
+    tiff = TIFFfile(fileName)
+    samples, sample_names = tiff.get_samples()
+    
+    outList = []
+    for sample in samples:
+        outList.append(np.copy(sample)[...,np.newaxis])
+        
+    out = np.concatenate(outList,axis=-1)
+    out = np.rollaxis(out,0,3)
+    out = np.flipud(out)
+    
+    tiff.close()
+    
+    return out
+
+print(read('a.tiff'))

data/ext/tifffile/extconf.rb

@@ -1,7 +1,12 @@
 require "mkmf"
 
-#LIBDIR      = Config::CONFIG['libdir']
-#INCLUDEDIR  = Config::CONFIG['includedir']
+# Add C++ support
+
+have_library( 'stdc++' );
+$CFLAGS << " -Wall"
+
+
+
 
 HEADER_DIRS = [
     # First search /opt/local for macports

data/ext/tifffile/tifffile.cpp

@@ -0,0 +1,237 @@
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include "tiffio.h"
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+template <class T>
+static bool rows_size_compare(std::vector<T> & a, std::vector<T> & b)
+{
+    return (a.size() < b.size());
+}
+
+template <class T>
+void calculate_width_height(std::vector<std::vector<T> > & data, uint32 & width, uint32 & height){
+    height = data.size();
+    width = std::max_element(data.begin(), data.end(), rows_size_compare<T>)->size();
+}
+
+
+template <class T>
+void write_data_to_row_buffer(std::vector<T> & data, unsigned char *buf, uint64 buff_size, uint8 sampleperpixel, uint8 bitspersample){
+    memset(buf, 0, buff_size);
+    buff_size = std::min<uint64>(buff_size, sizeof(T) * data.size());
+    memcpy(buf, (void *)(&(data[0])), buff_size);
+}
+
+
+template <class T>
+bool write_tiff_file(std::string filename, std::vector<std::vector<T> > & data, uint8 sampleperpixel, uint8 bitspersample, std::string description, std::string software){
+    try {
+        TIFF* tif = TIFFOpen(filename.c_str(), "w");
+
+        uint32 width, height;
+        calculate_width_height(data, width, height);
+
+        TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, width);
+        TIFFSetField(tif, TIFFTAG_IMAGELENGTH, height);
+        TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, sampleperpixel);
+        TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, bitspersample);
+        TIFFSetField(tif, TIFFTAG_ORIENTATION, (int)ORIENTATION_TOPLEFT);
+        TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
+        TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
+        TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
+        TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, (char*)description.c_str());
+        TIFFSetField(tif, TIFFTAG_SOFTWARE, (char*)software.c_str());
+
+        uint64 linebytes = sampleperpixel * width * (bitspersample / 8);
+        unsigned char *buf = NULL;
+        buf = (unsigned char *)_TIFFmalloc(linebytes);
+
+        TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
+
+        for (uint32 row = 0; row < height; row++){
+            std::vector<T> row_data = data[row];
+            write_data_to_row_buffer(row_data, buf, linebytes, sampleperpixel, bitspersample);
+            if (TIFFWriteScanline(tif, buf, row, 0) < 0)
+                break;
+        }
+
+        if (buf)
+            _TIFFfree(buf);
+
+        TIFFClose(tif);
+    }
+    catch (...){
+        return false;
+    }
+    return true;
+}
+
+
+bool get_matrix_element_type(VALUE data_matrix, bool &is_float){
+    if (!RB_TYPE_P(data_matrix, T_ARRAY) || RARRAY_LEN(data_matrix) < 1)
+        return false;
+
+    VALUE first_row = RARRAY_PTR(data_matrix)[0];
+
+    if (!RB_TYPE_P(first_row, T_ARRAY) || RARRAY_LEN(first_row) < 1)
+        return false;
+
+    VALUE first_item = RARRAY_PTR(first_row)[0];
+
+    if (!RB_TYPE_P(first_item, T_FIXNUM) && !RB_TYPE_P(first_item, T_FLOAT))
+        return false;
+
+    is_float = RB_TYPE_P(first_item, T_FLOAT);
+
+    return true;
+}
+
+template <class F, class T>
+vector<vector<T> > matrix_type_cast(vector<vector<F> > & from){
+    vector<vector<T> > result;
+    result.resize(from.size());
+
+    for (int i = 0; i < from.size(); i++)
+        result[i].assign(from[i].begin(), from[i].end());
+
+    return result;
+};
+
+VALUE TiffFile = Qnil;
+
+VALUE method_tifffile_converter_to_tiff(VALUE self, VALUE filename, VALUE data_matrix, VALUE sample_size, VALUE sample_unsigned, VALUE description, VALUE software){
+    data_matrix = rb_check_array_type(data_matrix);
+
+
+    Check_Type(filename,        T_STRING);
+    Check_Type(data_matrix,     T_ARRAY);
+    Check_Type(sample_size,     T_FIXNUM);
+    Check_Type(description,     T_STRING);
+    Check_Type(software,        T_STRING);
+
+    uint8 size = std::min<uint8>(NUM2USHORT(sample_size), 8);
+
+    bool unsigned_flag = RTEST(sample_unsigned);
+
+    bool is_float_matrix;
+    if (!get_matrix_element_type(data_matrix, is_float_matrix))
+        rb_raise(rb_eRuntimeError, "Invalid matrix items type");
+
+    if (size != 1 && size != 2 && size != 4 && size != 8)
+        rb_raise(rb_eRuntimeError, "Sample size should be in range [1, 2, 4, 8]");
+
+    if (is_float_matrix && (size % 4) != 0)
+        rb_raise(rb_eRuntimeError, "Sample size should be 4 or 8 on non-fixnum matrix");
+
+    vector<vector<double> > data_d;
+    vector<double>  temp_d;
+    vector<vector<int64> >   data_i;
+    vector<int64>  temp_i;
+
+    VALUE row, item;
+
+    if (is_float_matrix)
+        data_d.resize(RARRAY_LEN(data_matrix));
+    else
+        data_i.resize(RARRAY_LEN(data_matrix));
+
+
+    for (long i = 0; i < RARRAY_LEN(data_matrix); i++){
+        row = RARRAY_PTR(data_matrix)[i];
+
+        if (!RB_TYPE_P(row, T_ARRAY))
+            rb_raise(rb_eRuntimeError, "Matrix row %ld is not an array", i);
+
+        // Clear row buffer
+        if (is_float_matrix){
+            temp_d.clear();
+            temp_d.resize(RARRAY_LEN(row));
+        } else {
+            temp_i.clear();
+            temp_i.resize(RARRAY_LEN(row));
+        }
+
+
+        // Read row
+        for (long j = 0; j < RARRAY_LEN(row); j++){
+            item = RARRAY_PTR(row)[j];
+            Check_Type(item, is_float_matrix ? T_FLOAT : T_FIXNUM);
+            if (is_float_matrix)
+                temp_d[j] = RFLOAT_VALUE(item);
+            else
+                temp_i[j] = FIX2LONG(item);
+        }
+
+        if (is_float_matrix)
+            data_d[i] = temp_d;
+        else
+            data_i[i] = temp_i;
+    }
+
+
+    bool result = false;
+    if (is_float_matrix){
+        if (size == 8)
+            result = write_tiff_file<double>(StringValuePtr(filename), data_d, 1, 64, StringValuePtr(description), StringValuePtr(software));
+        else if (size == 4){
+            vector<vector<float> > cast_buffer = matrix_type_cast<double, float>(data_d);
+            result = write_tiff_file<float>(StringValuePtr(filename), cast_buffer, 1, 32, StringValuePtr(description), StringValuePtr(software));
+        }
+        else
+            rb_raise(rb_eRuntimeError, "unrecognized sample size for float matrix : %d", size);
+    }
+    else {
+        if (unsigned_flag){
+            if (size == 8){
+                vector<vector<uint64> > cast_buffer = matrix_type_cast<int64, uint64>(data_i);
+                result = write_tiff_file<uint64>(StringValuePtr(filename), cast_buffer, 1, 64, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 4){
+                vector<vector<uint32> > cast_buffer = matrix_type_cast<int64, uint32>(data_i);
+                result = write_tiff_file<uint32>(StringValuePtr(filename), cast_buffer, 1, 32, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 2){
+                vector<vector<uint16> > cast_buffer = matrix_type_cast<int64, uint16>(data_i);
+                result = write_tiff_file<uint16>(StringValuePtr(filename), cast_buffer, 1, 16, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 1){
+                vector<vector<uint8> > cast_buffer = matrix_type_cast<int64, uint8>(data_i);
+                result = write_tiff_file<uint8>(StringValuePtr(filename), cast_buffer, 1, 8, StringValuePtr(description), StringValuePtr(software));
+            }
+            else
+                rb_raise(rb_eRuntimeError, "unrecognized sample size for unsigned numeric matrix : %d", size);
+        }
+        else {
+            if (size == 8){
+                result = write_tiff_file<int64>(StringValuePtr(filename), data_i, 1, 64, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 4){
+                vector<vector<int32> > cast_buffer = matrix_type_cast<int64, int32>(data_i);
+                result = write_tiff_file<int32>(StringValuePtr(filename), cast_buffer, 1, 32, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 2){
+                vector<vector<int16> > cast_buffer = matrix_type_cast<int64, int16>(data_i);
+                result = write_tiff_file<int16>(StringValuePtr(filename), cast_buffer, 1, 16, StringValuePtr(description), StringValuePtr(software));
+            }
+            else if (size == 1){
+                vector<vector<int8> > cast_buffer = matrix_type_cast<int64, int8>(data_i);
+                result = write_tiff_file<int8>(StringValuePtr(filename), cast_buffer, 1, 8, StringValuePtr(description), StringValuePtr(software));
+            }
+            else
+                rb_raise(rb_eRuntimeError, "unrecognized sample size for signed numeric matrix : %d", size);
+        }
+    }
+
+    return result ? Qtrue : Qfalse;
+}
+
+extern "C" void Init_tifffile(){
+    TiffFile = rb_define_module("TiffFile");
+    rb_define_singleton_method(TiffFile, "to_tiff", (VALUE(*)(ANYARGS))method_tifffile_converter_to_tiff, 6);
+}

data/lib/tifffile.rb

@@ -1,2 +1,28 @@
 require 'tifffile/version'
 require "tifffile/tifffile"
+
+module TiffFile
+
+  include TiffFileVersion
+
+  # Will write a TIFF file +destination+, that contains +values+ matrix (in one channel), each sample has +sample_size+ in bytes (1, 2, 4 or 8), +sample_unsigned+.
+  # Also, image have +description+ and reference to +software+
+  def self.tiff2file(destination, values, sample_size=16, sample_unsigned=false, description=nil, software=nil)
+    self.to_tiff(destination.to_s, values, sample_size.to_i, sample_unsigned == true, description.to_s, software.to_s)
+  end
+
+
+  # Binary get TIFF file that contains +values+ matrix (in one channel), each sample has +sample_size+ in bytes (1, 2, 4 or 8), +sample_unsigned+.
+  # Also, image have +description+ and reference to +software+
+  def self.tiff2binary(values, sample_size=16, description=nil, software=nil)
+    file = Tempfile.new('tiff2binary')
+    file.close
+
+    tiff2file(file.path, values, sample_size, description, software)
+
+    data = File.read(file)
+    file.unlink
+    data
+  end
+
+end

data/lib/tifffile/version.rb

@@ -1,3 +1,3 @@
-module TiffFile
-  VERSION = "0.0.1"
+module TiffFileVersion
+  VERSION = "0.0.2"
 end

data/spec/tifffile_spec.rb

@@ -0,0 +1,7 @@
+require 'tifffile'
+
+describe "TiffFile" do
+  it "building tiff file" do
+    p TiffFile.tiff2file 'a.tiff', [[10, 21], [20, 30]], 8, false, "Image description", "SOFTWARE"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tifffile
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kirill Makhonin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-21 00:00:00.000000000 Z
+date: 2016-03-22 00:00:00.000000000 Z
 dependencies: []
 description: ''
 email: kroks.rus@gmail.com
@@ -25,11 +25,12 @@ files:
 - ".idea/tifffile-ruby.iml"
 - LICENSE
 - Rakefile
+- analyzer.py
 - ext/tifffile/extconf.rb
-- ext/tifffile/tifffile.c
-- ext/tifffile/tifffile.h
+- ext/tifffile/tifffile.cpp
 - lib/tifffile.rb
 - lib/tifffile/version.rb
+- spec/tifffile_spec.rb
 homepage: https://github.com/kirillmakhonin/tifffile-ruby
 licenses:
 - MIT

data/ext/tifffile/tifffile.c

@@ -1,74 +0,0 @@
-#include <tifffile.h>
-
-struct my_malloc {
-  size_t size;
-  void *ptr;
-};
-
-static void
-my_malloc_free(void *p) {
-  struct my_malloc *ptr = p;
-
-  if (ptr->size > 0)
-    free(ptr->ptr);
-}
-
-static VALUE
-my_malloc_alloc(VALUE klass) {
-  VALUE obj;
-  struct my_malloc *ptr;
-
-  obj = Data_Make_Struct(klass, struct my_malloc, NULL, my_malloc_free, ptr);
-
-  ptr->size = 0;
-  ptr->ptr  = NULL;
-
-  return obj;
-}
-
-static VALUE
-my_malloc_init(VALUE self, VALUE size) {
-  struct my_malloc *ptr;
-  size_t requested = NUM2SIZET(size);
-
-  if (0 == requested)
-    rb_raise(rb_eArgError, "unable to allocate 0 bytes");
-
-  Data_Get_Struct(self, struct my_malloc, ptr);
-
-  ptr->ptr = malloc(requested);
-
-  if (NULL == ptr->ptr)
-    rb_raise(rb_eNoMemError, "unable to allocate %ld bytes", requested);
-
-  ptr->size = requested;
-
-  return self;
-}
-
-static VALUE
-my_malloc_release(VALUE self) {
-  struct my_malloc *ptr;
-
-  Data_Get_Struct(self, struct my_malloc, ptr);
-
-  if (0 == ptr->size)
-    return self;
-
-  ptr->size = 0;
-  free(ptr->ptr);
-
-  return self;
-}
-
-void
-Init_my_malloc(void) {
-  VALUE cMyMalloc;
-
-  cMyMalloc = rb_const_get(rb_cObject, rb_intern("TiffFile"));
-
-  rb_define_alloc_func(cMyMalloc, my_malloc_alloc);
-  rb_define_method(cMyMalloc, "initialize", my_malloc_init, 1);
-  rb_define_method(cMyMalloc, "free", my_malloc_release, 0);
-}
-

data/ext/tifffile/tifffile.h

@@ -1 +0,0 @@
-#include <ruby.h>