python-microscopy 25.6.5__cp39-cp39-win_amd64.whl

PYME/resources/web/static/recipe_editor.js

@@ -0,0 +1,119 @@
+
+condense=function(y){
+    var f = Math.floor(y);
+    var g = y-f;
+
+    return 5/8*(f/2) + g/4;
+};
+
+const zip = (arr2, arr1) => arr1.map((k, i) => [k, condense(arr2[i])]);
+const input_type_mappings = {string : 'text', number : 'number', boolean : 'checkbox'};
+
+var vm = undefined;
+// jigna.models are ready only when the deferred called ready is done.
+Vue.config.devtools = true;
+//Vue.config.debug = true;
+
+const cols = ['turquoise', 'emerald', 'peter-river', 'amethyst', 'wet-asphalt', 'sunflower', 'carrot', 'alizarin'];
+
+
+
+Vue.component('trait-input',{
+   props: ['value', 'type'],
+   template: `
+        <input :value="value" :checked="value" :type="input_type(type)" v-on:input="$emit('input', format_value($event))">`,
+   methods: {
+       input_type: function(type){return input_type_mappings[type];},
+       format_value: function(event){
+           var val = event.target.value;
+           switch(this.type){
+               case 'number':
+                   return parseFloat(val);
+               case 'boolean':
+                   val = event.target.checked;
+                   console.log(val, typeof(val));
+                   return val;
+               default:
+                   return val;
+           }
+       }
+   }
+
+});
+
+Vue.component('rec-module',{
+   props: ['module'],
+   template: `
+    <div class="container">
+            <div class="recipe_module">
+                <h4 class="module_name">{{module.get_name()}}</h4>
+            <table>
+            <tr v-for="param in module.get_params()[2]">
+                <td>{{param}}:</td><td><trait-input v-model="module[param]" :type="typeof(module[param])"></trait-input></td>
+            </tr>
+            </table>
+            </div>
+                </div>
+        `,
+   methods: {
+
+   }
+
+});
+
+
+var editor;
+
+
+jigna.ready.done(function() {
+   vm = new Vue({
+       el: '#app',
+       data: jigna.models, // Attach to the body tag.
+       methods: {
+           threaded: function(obj, method_name, args) {
+               jigna.threaded.apply(jigna, arguments);
+           },
+           line_fmt: function (line) {
+               return zip(line[0], line[1]).join(' ');
+
+           } ,
+           input_type: function (param, module) {
+               // take module argument for an improved future version which gets more trait info
+               return input_type_mappings[typeof(param)];
+           },
+           cond: function(y){return condense(y);},
+           get_colour: function(index) {return cols[index % 8]},
+       },
+       watch: {
+           recipe: function(new_data, old_data){
+               console.log('Model changed');
+           }
+       }
+   });
+
+   ace.config.set("basePath", "https://cdnjs.cloudflare.com/ajax/libs/ace/1.4.12/");
+   editor = ace.edit("editor");
+   editor.setTheme("ace/theme/monokai");
+   editor.session.setMode("ace/mode/yaml");
+   editor.setValue(vm.recipe.toYAML());
+   editor.clearSelection();
+   editor.on('blur', function(){vm.recipe.update_from_yaml(editor.getValue());});
+
+   jigna.add_listener('jigna', 'object_changed', function(event){editor.setValue(vm.recipe.toYAML());editor.clearSelection();});
+});
+
+load_recipe = function(){
+    console.log('clicked load recipe');
+    select_file(function(path){
+     console.log('Selected: ', path);
+     vm.recipe.update_from_file('PYME-CLUSTER:///' + path)
+    }, 'Select a file');
+};
+
+save_recipe = function(){
+    console.log('clicked save recipe');
+    select_file_save(function(path){
+     console.log('Selected: ', path);
+     vm.recipe.save_yaml('PYME-CLUSTER:///' + path)
+    }, 'Save as', '', 'RECIPES/');
+};

PYME/resources/web/static/shaders/fragment/lut.glsl

@@ -0,0 +1,20 @@
+precision mediump float;
+uniform sampler2D u_tile;
+uniform vec2 u_tile_size;
+varying vec2 v_tile_pos;
+uniform float u_scale;
+
+//
+// Sample the color at offset
+//
+vec4 rgba(float dx, float dy) {
+  // calculate the color of sampler at an offset from position
+
+  return texture2D(u_tile, v_tile_pos + vec2(dx, dy));
+}
+
+void main() {
+  float v = u_scale*rgba(0., 0.).r;
+  //gl_FragColor = rgba(0.,0.);
+  gl_FragColor = vec4(v, v, v, 1);
+}

PYME/resources/web/static/shaders/fragment/none.glsl

@@ -0,0 +1,17 @@
+precision mediump float;
+uniform sampler2D u_tile;
+uniform vec2 u_tile_size;
+varying vec2 v_tile_pos;
+
+//
+// Sample the color at offset
+//
+vec4 rgba(float dx, float dy) {
+  // calculate the color of sampler at an offset from position
+  return texture2D(u_tile, v_tile_pos+vec2(dx,dy));
+}
+
+void main() {
+
+  gl_FragColor = rgba(0.,0.);
+}

PYME/resources/web/static/shaders/fragment/outline.glsl

@@ -0,0 +1,43 @@
+precision mediump float;
+uniform sampler2D u_tile;
+uniform vec2 u_tile_size;
+varying vec2 v_tile_pos;
+
+//
+// FLOAT COMPARE FUNCTIONS WITH DELTA
+//
+bool equals4(vec4 id1, vec4 id2) {
+  return all(equal(id1,id2));
+}
+
+//
+// calculate the color of sampler at an offset from position
+//
+vec4 offset(sampler2D sam, vec2 pos, vec2 off) {
+  // calculate the color of sampler at an offset from position
+  return texture2D(sam, vec2(pos.x + off.x/u_tile_size.x, pos.y + off.y/u_tile_size.y));
+}
+
+//
+// Check whether nearby positions are the same
+//
+vec4 borders(sampler2D sam, vec2 pos) {
+  // calculate the color of sampler at an offset from position
+  vec4 here_id = offset(sam,pos,vec2(0., 0.));
+
+  bool left = equals4(here_id, offset(sam,pos,vec2(-1., 0.)));
+  bool right = equals4(here_id, offset(sam,pos,vec2(1., 0.)));
+  bool down = equals4(here_id, offset(sam,pos,vec2(0., -1.)));
+  bool top = equals4(here_id, offset(sam,pos,vec2(0., 1.)));
+
+  // If any are false, return false TODO: optimize
+  if (!left || !right || !down || !top) {
+    return vec4(0.,0.,0.,1.);
+  }
+  return here_id;
+}
+
+
+void main() {
+  gl_FragColor = borders(u_tile, v_tile_pos);
+}

PYME/resources/web/static/shaders/fragment/rect.glsl

@@ -0,0 +1,7 @@
+precision mediump float;
+varying vec2 v_tile_pos;
+
+void main() {
+
+  gl_FragColor = vec4(0., v_tile_pos.y, v_tile_pos.x, 1.);
+}

PYME/resources/web/static/shaders/fragment/sobel3.glsl

@@ -0,0 +1,71 @@
+precision mediump float;
+uniform sampler2D u_tile;
+uniform vec2 u_tile_size;
+varying vec2 v_tile_pos;
+
+// Sum a vector
+float sum3(vec3 v) {
+  return dot(v,vec3(1));
+}
+
+// Weight of a matrix
+float weigh3(mat3 m) {
+  return sum3(m[0])+sum3(m[1])+sum3(m[2]);
+}
+
+// Take the outer product
+mat3 outer3(vec3 c, vec3 r) {
+  mat3 goal;
+  for (int i =0; i<3; i++) {
+      goal[i] = r*c[i];
+  }
+  return goal;
+}
+
+//*~*~*~*~*~*~*~*~*~*~*~*~*~
+//  Now for the Sobel Program
+//*~
+
+// Sample the color at offset
+vec3 color(float dx, float dy) {
+  // calculate the color of sampler at an offset from position
+  return texture2D(u_tile, v_tile_pos+vec2(dx,dy)).rgb;
+}
+
+float sobel(mat3 kernel, vec3 near_in[9]) {
+
+  // nearest pixels
+  mat3 near_out[3];
+
+  // Get all near_in pixels
+  for (int i = 0; i < 3; i++) {
+      near_out[i][0] = kernel[0]*vec3(near_in[0][i],near_in[1][i],near_in[2][i]);
+      near_out[i][1] = kernel[1]*vec3(near_in[3][i],near_in[4][i],near_in[5][i]);
+      near_out[i][2] = kernel[2]*vec3(near_in[6][i],near_in[7][i],near_in[8][i]);
+  }
+
+  // convolve the kernel with the nearest pixels
+  return length(vec3(weigh3(near_out[0]),weigh3(near_out[1]),weigh3(near_out[2])));
+}
+
+void main() {
+  // Prep work
+  vec3 near_in[9];
+  vec3 mean = vec3(1,2,1);
+  vec3 slope = vec3(-1,0,1);
+  mat3 sobelX = outer3(mean,slope);
+  mat3 sobelY = outer3(slope,mean);
+  vec2 u = vec2(1./u_tile_size.x, 1./u_tile_size.y);
+  // Calculate coordinates of nearest points
+  for (int i = 0; i < 9; i++) {
+    near_in[i] = color(mod(float(i),3.)*u.x, float(i/3-1)*u.y);
+  }
+
+  // Show the mixed XY contrast
+  float edgeX = sobel(sobelX, near_in);
+  float edgeY = sobel(sobelY, near_in);
+  float mixed = length(vec2(edgeX,edgeY));
+//  mixed = (max(mixed,0.5)-0.5);
+
+  gl_FragColor = vec4(vec3(mixed),1);
+}

PYME/resources/web/static/shaders/fragment/white.glsl

@@ -0,0 +1,4 @@
+precision mediump float;
+void main() {
+  gl_FragColor = vec4(1.);
+}

PYME/resources/web/static/shaders/vertex/rect.glsl

@@ -0,0 +1,22 @@
+attribute vec4 a_pos;
+uniform vec2 u_tile_where;
+uniform vec2 u_tile_shape;
+attribute vec2 a_tile_pos;
+varying vec2 v_tile_pos;
+
+// Tile to Image
+vec2 tile2image(vec2 tiled) {
+    return u_tile_where + u_tile_shape*tiled;
+}
+
+// Image to Tile
+vec2 image2tile(vec2 imaged) {
+    return (imaged - u_tile_where)/u_tile_shape;
+}
+
+
+void main() {
+  // Pass the overlay tiles
+  v_tile_pos = tile2image(a_tile_pos);
+  gl_Position = a_pos;
+}

PYME/resources/web/static/shaders/vertex/square.glsl

@@ -0,0 +1,9 @@
+attribute vec4 a_pos;
+attribute vec2 a_tile_pos;
+varying vec2 v_tile_pos;
+
+void main() {
+  // Pass the overlay tiles
+  v_tile_pos = a_tile_pos;
+  gl_Position = a_pos;
+}

PYME/resources/web/static/utils.js

@@ -0,0 +1,3 @@
+/**
+ * Created by david on 9/3/16.
+ */

PYME/resources/web/static/viaWebGL.js

@@ -0,0 +1,217 @@
+/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~
+/* viaWebGL
+/* Set shaders on Image or Canvas with WebGL
+/* Built on 2016-9-9
+/* http://via.hoff.in
+*/
+ViaWebGL = function(incoming) {
+
+    /* Custom WebGL API calls
+    ~*~*~*~*~*~*~*~*~*~*~*~*/
+    this['gl-drawing'] = function(e) { return e; };
+    this['gl-loaded'] = function(e) { return e; };
+    this.ready = function(e) { return e; };
+
+    var gl = this.maker();
+    this.flat = document.createElement('canvas').getContext('2d');
+    this.tile_size = 'u_tile_size';
+    this.vShader = 'vShader.glsl';
+    this.fShader = 'fShader.glsl';
+    this.wrap = gl.CLAMP_TO_EDGE;
+    this.tile_pos = 'a_tile_pos';
+    this.filter = gl.NEAREST;
+    this.pos = 'a_pos';
+    this.scale = 'u_scale';
+    this.height = 128;
+    this.width = 128;
+    this.multiplier = 5.0;
+    this.on = 0;
+    this.gl = gl;
+    // Assign from incoming terms
+    for (var key in incoming) {
+        this[key] = incoming[key];
+    }
+};
+
+ViaWebGL.prototype = {
+
+    init: function(source) {
+        var ready = this.ready;
+        // Allow for mouse actions on click
+        if (this.hasOwnProperty('container') && this.hasOwnProperty('onclick')) {
+            this.container.onclick = this[this.onclick].bind(this);
+        }
+        if (source && source.height && source.width) {
+            this.ready = this.toCanvas.bind(this,source);
+            this.height = source.height;
+            this.width = source.width;
+        }
+        this.source = source;
+        this.gl.canvas.width = this.width;
+        this.gl.canvas.height = this.height;
+        this.gl.viewport(0, 0, this.width, this.height);
+        // Load the shaders when ready and return the promise
+        var step = [[this.vShader, this.fShader].map(this.getter)];
+        step.push(this.toProgram.bind(this), this.toBuffers.bind(this));
+        return Promise.all(step[0]).then(step[1]).then(step[2]).then(this.ready);
+
+    },
+    // Make a canvas
+    maker: function(options){
+        return this.context(document.createElement('canvas'));
+    },
+    context: function(a){
+        return a.getContext('experimental-webgl') || a.getContext('webgl');
+    },
+    // Get a file as a promise
+    getter: function(where) {
+        return new Promise(function(done){
+            // Return if not a valid filename
+            if (where.slice(-4) != 'glsl') {
+                return done(where);
+            }
+            var bid = new XMLHttpRequest();
+            var win = function(){
+                if (bid.status == 200) {
+                    return done(bid.response);
+                }
+                return done(where);
+            };
+            bid.open('GET', where, true);
+            bid.onerror = bid.onload = win;
+            bid.send();
+        });
+    },
+    // Link shaders from strings
+    toProgram: function(files) {
+        var gl = this.gl;
+        var program = gl.createProgram();
+        var ok = function(kind,status,value,sh) {
+            if (!gl['get'+kind+'Parameter'](value, gl[status+'_STATUS'])){
+                console.log((sh||'LINK')+':\n'+gl['get'+kind+'InfoLog'](value));
+            }
+            return value;
+        }
+        // 1st is vertex; 2nd is fragment
+        files.map(function(given,i) {
+            var sh = ['VERTEX_SHADER', 'FRAGMENT_SHADER'][i];
+            var shader = gl.createShader(gl[sh]);
+            gl.shaderSource(shader, given);
+            gl.compileShader(shader);
+            gl.attachShader(program, shader);
+            ok('Shader','COMPILE',shader,sh);
+        });
+        gl.linkProgram(program);
+        return ok('Program','LINK',program);
+    },
+    // Load data to the buffers
+    toBuffers: function(program) {
+
+        // Allow for custom loading
+        this.gl.useProgram(program);
+        this['gl-loaded'].call(this, program);
+
+        // Unchangeable square array buffer fills viewport with texture
+        var boxes = [[-1, 1,-1,-1, 1, 1, 1,-1], [0, 1, 0, 0, 1, 1, 1, 0]];
+        var buffer = new Float32Array([].concat.apply([], boxes));
+        var bytes = buffer.BYTES_PER_ELEMENT;
+        var gl = this.gl;
+        var count = 4;
+
+        // Get uniform term
+        var tile_size = gl.getUniformLocation(program, this.tile_size);
+        gl.uniform2f(tile_size, gl.canvas.height, gl.canvas.width);
+
+        this.multiplier_loc = gl.getUniformLocation(program, this.scale);
+        gl.uniform1f(this.multiplier_loc, this.multiplier);
+
+        // Get attribute terms
+        this.att = [this.pos, this.tile_pos].map(function(name, number) {
+
+            var index = Math.min(number, boxes.length-1);
+            var vec = Math.floor(boxes[index].length/count);
+            var vertex = gl.getAttribLocation(program, name);
+
+            return [vertex, vec, gl.FLOAT, 0, vec*bytes, count*index*vec*bytes];
+        });
+        // Get texture
+        this.tex = {
+            texParameteri: [
+                [gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.wrap],
+                [gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.wrap],
+                [gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.filter],
+                [gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.filter]
+            ],
+            texImage2D: [gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE],
+            bindTexture: [gl.TEXTURE_2D, gl.createTexture()],
+            drawArrays: [gl.TRIANGLE_STRIP, 0, count],
+            pixelStorei: [gl.UNPACK_FLIP_Y_WEBGL, 1]
+        };
+        // Build the position and texture buffer
+        gl.bindBuffer(gl.ARRAY_BUFFER, gl.createBuffer());
+        gl.bufferData(gl.ARRAY_BUFFER, buffer, gl.STATIC_DRAW);
+    },
+
+    render: function(){
+        var gl = this.gl;
+        gl.uniform1f(this.multiplier_loc, this.multiplier);
+        // Draw everything needed to canvas
+        gl.drawArrays.apply(gl, this.tex.drawArrays);
+    },
+
+    // Turns image or canvas into a rendered canvas
+    toCanvas: function(tile) {
+        // Stop Rendering
+        if (this.on%2 !== 0) {
+            if(tile.nodeName == 'IMG') {
+                this.flat.canvas.width = tile.width;
+                this.flat.canvas.height = tile.height;
+                this.flat.drawImage(tile,0,0,tile.width,tile.height);
+                return this.flat.canvas;
+            }
+            return tile;
+        }
+
+        // Allow for custom drawing in webGL
+        this['gl-drawing'].call(this,tile);
+        var gl = this.gl;
+
+
+
+        // Set Attributes for GLSL
+        this.att.map(function(x){
+
+            gl.enableVertexAttribArray(x.slice(0,1));
+            gl.vertexAttribPointer.apply(gl, x);
+        });
+
+        // Set Texture for GLSL
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture.apply(gl, this.tex.bindTexture);
+        gl.pixelStorei.apply(gl, this.tex.pixelStorei);
+
+        // Apply texture parameters
+        this.tex.texParameteri.map(function(x){
+            gl.texParameteri.apply(gl, x);
+        });
+        // Send the tile into the texture.
+        var output = this.tex.texImage2D.concat([tile]);
+        gl.texImage2D.apply(gl, output);
+
+        // Draw everything needed to canvas
+        //gl.drawArrays.apply(gl, this.tex.drawArrays);
+        this.render();
+
+        // Apply to container if needed
+        if (this.container) {
+            this.container.appendChild(this.gl.canvas);
+        }
+        return this.gl.canvas;
+    },
+    toggle: function() {
+        this.on ++;
+        this.container.innerHTML = '';
+        this.container.appendChild(this.toCanvas(this.source));
+
+    }
+}

PYME/setup.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python
+
+##################
+# setup.py
+#
+# Copyright David Baddeley, 2009
+# d.baddeley@auckland.ac.nz
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+##################
+import glob
+import sys
+import os
+import setuptools #to monkey-patch distutils for ms visualc for python
+
+def configuration(parent_package='',top_path=None):
+    from numpy.distutils.misc_util import Configuration
+    config = Configuration('PYME',parent_package,top_path)
+    config.add_subpackage('Analysis')
+    config.add_subpackage('Acquire')
+    config.add_subpackage('DSView')
+    #config.add_subpackage('PSFGen')
+    #config.add_subpackage('cSMI')
+    config.add_subpackage('ParallelTasks')
+    config.add_subpackage('IO')
+    config.add_subpackage('Deconv')
+    #config.add_subpackage('PSFEst')
+    config.add_subpackage('simulation')
+    config.add_subpackage('misc')
+    config.add_subpackage('LMVis')
+    config.add_subpackage('ui')
+    config.add_subpackage('util')
+    config.add_subpackage('util.shmarray')
+    config.add_subpackage('util.mProfile')
+    config.add_subpackage('util.fProfile')
+    config.add_data_dir('util/fProfile/html')
+    config.add_subpackage('localization')
+    
+    config.add_subpackage('recipes')
+    config.add_data_dir('recipes/Recipes')
+    
+    config.add_subpackage('cluster')
+    config.add_data_dir('cluster/clusterUI')
+    
+    #config.add_subpackage('pad')
+    #config.add_subpackage('bcl')
+    config.add_subpackage('resources')
+    config.add_subpackage('contrib')
+    config.add_subpackage('experimental')
+    config.add_subpackage('tileviewer')
+    config.add_data_dir('tileviewer/templates')
+    config.add_data_files('*.pxd', '*.pyx') #permit inheritance of cython classes
+    #config.add_subpackage('dataBrowser')
+    #config.add_subpackage('shmarray')
+    #config.add_subpackage('SampleDB2')
+    #config.add_subpackage('clusterUI')
+    
+    #config.add_scripts(glob.glob('scripts/*'))
+    if False:#not 'CONDA_BUILD' in os.environ.keys():
+        #entry points are defined in the condas meta.yaml - not needed here
+        #if running under conda
+        if sys.platform == 'win32':
+            config.add_scripts('scripts/*')
+        else:
+            #don't add .cmd files
+            config.add_scripts('scripts/*.py')
+        
+    config.get_version()
+    
+    #config.set_options()
+    
+    #config.make_svn_version_py()  # installs __svn_version__.py
+    #config.make_config_py()
+    return config
+
+if __name__ == '__main__':
+    #import setuptools
+    from numpy.distutils.core import setup
+    setup(description='Tools for (super-resolution) microscopy data analysis and microsope control',
+        author='David Baddeley',
+        author_email='david.baddeley@auckland.ac.nz',
+        url='https://github.com/python-microscopy/python-microscopy',
+        long_description='Tools for (super-resolution) microscopy data analysis and microsope control',
+        long_description_content_type="text/markdown",
+        license="GPLv3",
+        install_requires=['numpy'],
+        classifiers=[
+            'Development Status :: 3 - Alpha',
+            # Chose either "3 - Alpha", "4 - Beta" or "5 - Production/Stable" as the current state of your package
+            'License :: OSI Approved :: GNU General Public License v3 (GPLv3)', # Again, pick a license
+            'Programming Language :: Python :: 2.7', #Specify which python versions that you want to support
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+        ],
+          **configuration(top_path='').todict())
+    #setup(options = {'bdist_wininst':{'install-script=' : 'pyme_win_postinstall.py',
+    #                    'user-access-control=' : 'force'}}, **configuration(top_path='').todict())