pyfast 4.12.0__cp36-abi3-macosx_10_13_x86_64.whl

fast/kernels/Visualization/ImageRenderer/ImageRendererFLOAT.frag

@@ -0,0 +1,18 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D ourTexture;
+uniform float window;
+uniform float level;
+uniform float opacity;
+
+void main()
+{
+    vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y)));
+    color.rgb = (color.rgb - level + window/2.0f) / window;
+    if(opacity >= 0.0)
+        color.w = opacity;
+    FragColor = clamp(color, 0.0f, 1.0f);
+}

fast/kernels/Visualization/ImageRenderer/ImageRendererINT.frag

@@ -0,0 +1,18 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform isampler2D ourTexture;
+uniform float window;
+uniform float level;
+uniform float opacity;
+
+void main()
+{
+    vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y)));
+    color.rgb = (color.rgb - level + window/2.0f) / window;
+    if(opacity >= 0.0)
+        color.w = opacity;
+    FragColor = clamp(color, 0.0f, 1.0f);
+}

fast/kernels/Visualization/ImageRenderer/ImageRendererUINT.frag

@@ -0,0 +1,18 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform usampler2D ourTexture;
+uniform float window;
+uniform float level;
+uniform float opacity;
+
+void main() {
+    vec4 color = vec4(texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y)));
+    color.rgb = (color.rgb - level + window/2.0f) / window; // Normalize RGB
+    color.a = color.a/255.0; // Normalize alpha
+    if(opacity >= 0.0)
+        color.w = opacity;
+    FragColor = clamp(color, 0.0f, 1.0f);
+}

fast/kernels/Visualization/LineRenderer/LineRenderer.frag

@@ -0,0 +1,8 @@
+#version 330 core
+
+in vec4 geomColor;
+out vec4 FragColor;
+
+void main() {
+    FragColor = geomColor;
+}

fast/kernels/Visualization/LineRenderer/LineRenderer.geom

@@ -0,0 +1,35 @@
+#version 330
+
+layout (lines) in;                              // now we can access 2 vertices
+layout (triangle_strip, max_vertices = 4) out;  // always (for now) producing 2 triangles (so 4 vertices)
+in vec4 vertexColor[];
+out vec4 geomColor;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform float thickness;
+//uniform int viewportWidth;
+//uniform int viewportHeight;
+
+void main()
+{
+    geomColor = vertexColor[0];
+    vec4 p1 = gl_in[0].gl_Position;
+    vec4 p2 = gl_in[1].gl_Position;
+
+    float size = (thickness/100.0)/(perspectiveTransform[0][0]/2.0); // percent to mm
+    vec2 dir    = normalize((p2.xy - p1.xy));
+    vec4 offset = vec4(-dir.y, dir.x, 0, 0) * size * 0.5;
+
+    gl_Position = perspectiveTransform * viewTransform * transform * (p1 + offset);
+    EmitVertex();
+    gl_Position = perspectiveTransform * viewTransform * transform * (p1 - offset);
+    EmitVertex();
+    gl_Position = perspectiveTransform * viewTransform * transform * (p2 + offset);
+    EmitVertex();
+    gl_Position = perspectiveTransform * viewTransform * transform * (p2 - offset);
+    EmitVertex();
+
+    EndPrimitive();
+}

fast/kernels/Visualization/LineRenderer/LineRenderer.vert

@@ -0,0 +1,20 @@
+#version 330 core
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec3 in_color;
+
+out vec4 vertexColor;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform bool useGlobalColor;
+uniform vec3 globalColor;
+
+void main() {
+    gl_Position = vec4(in_position, 1.0);
+    if(useGlobalColor) {
+        vertexColor = vec4(globalColor, 1.0);
+    } else {
+        vertexColor = vec4(in_color, 1.0);
+    }
+}

fast/kernels/Visualization/LineRenderer/LineRenderer3D.frag

@@ -0,0 +1,8 @@
+#version 330 core
+
+in vec4 vertexColor;
+out vec4 FragColor;
+
+void main() {
+    FragColor = vertexColor;
+}

fast/kernels/Visualization/LineRenderer/LineRenderer3D.vert

@@ -0,0 +1,20 @@
+#version 330 core
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec3 in_color;
+
+out vec4 vertexColor;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform bool useGlobalColor;
+uniform vec3 globalColor;
+
+void main() {
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(in_position, 1.0);
+    if(useGlobalColor) {
+        vertexColor = vec4(globalColor, 1.0);
+    } else {
+        vertexColor = vec4(in_color, 1.0);
+    }
+}

fast/kernels/Visualization/LineRenderer/LineRendererJoints.frag

@@ -0,0 +1,15 @@
+#version 330 core
+
+out vec4 FragColor;
+in vec4 vertex_color;
+
+void main()
+{
+    // Convert squares to circles
+    vec2 circCoord = gl_PointCoord - vec2(0.5, 0.5);
+    if(dot(circCoord, circCoord) > 0.25) { // x dot x = |x|*|x| = r^2, radius = 0.5, r^2=0.25
+        discard;
+    } else {
+        FragColor = vertex_color;
+    }
+}

fast/kernels/Visualization/LineRenderer/LineRendererJoints.vert

@@ -0,0 +1,24 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+out vec4 vertex_color;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform float pointSize;
+uniform bool useGlobalColor;
+uniform vec3 globalColor;
+uniform int viewportWidth;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    gl_PointSize = (pointSize/100.0)*viewportWidth; // gl_PointSize unit is in pixels
+    if(useGlobalColor) {
+        vertex_color = vec4(globalColor, 1.0);
+    } else {
+        vertex_color = vec4(aColor, 1.0);
+    }
+}

fast/kernels/Visualization/SegmentationLabelRenderer/SegmentationLabelRenderer.frag

@@ -0,0 +1,11 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D ourTexture;
+
+void main()
+{
+    FragColor = texture(ourTexture, TexCoord);
+}

fast/kernels/Visualization/SegmentationLabelRenderer/SegmentationLabelRenderer.vert

@@ -0,0 +1,16 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform int positionType;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+}

fast/kernels/Visualization/SegmentationRenderer/SegmentationPyramidRenderer.frag

@@ -0,0 +1,53 @@
+#version 330 core
+layout (std140) uniform Colors {
+    vec4 color[256];
+};
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+// Using sampler2D here instead of usampler2d, due to texture compression
+uniform sampler2D ourTexture;
+uniform float opacity;
+uniform float borderOpacity;
+uniform int borderRadius;
+
+void main()
+{
+    uint in_label = uint(round(texture(ourTexture, vec2(TexCoord.x, TexCoord.y)).r*255)); // Texture compression is normalized
+    FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    vec2 size = textureSize(ourTexture, 0);
+    uint borderLabel = uint(0);
+
+    // Border check
+    bool isBorder = false;
+    if(borderRadius > 1 || borderOpacity != opacity) {
+        // Check neighbors
+        // If any neighbors have a different label, we are at the border
+        for(int a = -borderRadius; a <= borderRadius; ++a) {
+            for(int b = -borderRadius; b <= borderRadius; ++b) {
+                if(uint(round(texture(ourTexture, vec2(TexCoord.x + float(a)/size.x, (TexCoord.y + float(b)/size.y))).r*255)) != in_label){
+                    if(borderRadius == 1 || length(vec2(a, b)) < borderRadius) {
+                				if(in_label == uint(0)) {
+                  					// Outside
+                            if(borderRadius > 1) {
+  						                     borderLabel = uint(round(texture(ourTexture, vec2(TexCoord.x + float(a)/size.x, (TexCoord.y + float(b)/size.y))).r*255));
+  						                     isBorder = true;
+  					                }
+			                  } else {
+                    				// Inside
+                    				isBorder = true;
+                  			}
+                		}
+                }
+            }
+        }
+    }
+
+    if((in_label > uint(0) && in_label < uint(256)) || isBorder) {
+        if(isBorder && in_label == uint(0))
+            in_label = borderLabel;
+        FragColor = color[in_label];
+        FragColor.a = isBorder ? borderOpacity : opacity;
+    }
+}

fast/kernels/Visualization/SegmentationRenderer/SegmentationRenderer.frag

@@ -0,0 +1,52 @@
+#version 330 core
+layout (std140) uniform Colors {
+    vec4 color[256];
+};
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform usampler2D ourTexture;
+uniform float opacity;
+uniform float borderOpacity;
+uniform int borderRadius;
+
+void main()
+{
+    uint in_label = texture(ourTexture, vec2(TexCoord.x, 1.0 - TexCoord.y)).r;
+    FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+    vec2 size = textureSize(ourTexture, 0);
+  	uint borderLabel = uint(0);
+
+    // Border check
+    bool isBorder = false;
+    if(borderRadius > 1 || borderOpacity != opacity) {
+        // Check neighbors
+        // If any neighbors have a different label, we are at the border
+        for(int a = -borderRadius; a <= borderRadius; ++a) {
+            for(int b = -borderRadius; b <= borderRadius; ++b) {
+                if(uint(texture(ourTexture, vec2(TexCoord.x + float(a)/size.x, 1.0 - (TexCoord.y + float(b)/size.y))).r) != in_label) {
+                    if(borderRadius == 1 || length(vec2(a, b)) < borderRadius) {
+		                    if(in_label == uint(0)) {
+			                       // Outside
+			                       if(borderRadius > 1) {
+				                           borderLabel = uint(texture(ourTexture, vec2(TexCoord.x + float(a)/size.x, 1.0 - (TexCoord.y + float(b)/size.y))).r);
+				                           isBorder = true;
+                            }
+		                    } else {
+			                       // Inside
+			                       isBorder = true;
+		                    }
+                    }
+                }
+            }
+        }
+    }
+
+    if((in_label > uint(0) && in_label < uint(256)) || isBorder) {
+        if(isBorder && in_label == uint(0))
+            in_label = borderLabel;
+        FragColor = color[in_label];
+        FragColor.a = isBorder ? borderOpacity : opacity;
+    }
+}

fast/kernels/Visualization/SegmentationRenderer/SegmentationRenderer.vert

@@ -0,0 +1,15 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+}

fast/kernels/Visualization/TextRenderer/TextRenderer.frag

@@ -0,0 +1,11 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 TexCoord;
+
+uniform sampler2D ourTexture;
+
+void main()
+{
+    FragColor = texture(ourTexture, TexCoord);
+}

fast/kernels/Visualization/TextRenderer/TextRenderer.vert

@@ -0,0 +1,20 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCoord;
+
+out vec2 TexCoord;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform int positionType;
+
+void main()
+{
+    if(positionType == 2) {
+        gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    } else {
+        gl_Position = transform * vec4(aPos, 1.0);
+    }
+    TexCoord = aTexCoord;
+}

fast/kernels/Visualization/TriangleRenderer/TriangleRenderer.frag

@@ -0,0 +1,49 @@
+#version 330 core
+
+in vec3 Normal;
+in vec3 FragPos;
+in vec3 LightPos;
+in vec3 ViewPos;
+in vec3 Color;
+
+out vec4 FragColor;
+
+uniform float opacity;
+uniform bool mode2D;
+uniform bool ignoreInvertedNormals;
+
+void main()
+{
+    if(mode2D) {
+        FragColor = vec4(Color, opacity);
+    } else {
+        vec3 objectColor = Color;
+        vec3 lightColor = vec3(0.7, 0.7, 0.7);
+        vec3 ambientColor = vec3(0.2, 0.2, 0.2);
+        vec3 specularColor = vec3(1.0, 1.0, 1.0);
+        float shininess = 16;
+
+        // ambient
+        vec3 ambient = lightColor * ambientColor;
+
+        // diffuse
+        vec3 norm = normalize(Normal);
+        vec3 lightDir = normalize(LightPos - FragPos);
+        float diff;
+        if(ignoreInvertedNormals) {
+            diff = abs(dot(norm, lightDir));
+        } else {
+            diff = max(dot(norm, lightDir), 0.0);
+        }
+        vec3 diffuse = lightColor * (diff * objectColor);
+
+        // specular
+        vec3 viewDir = normalize(ViewPos - FragPos);
+        vec3 reflectDir = reflect(-lightDir, norm);
+        float spec = pow(max(dot(viewDir, reflectDir), 0.0), shininess);
+        vec3 specular = lightColor * (spec * specularColor);
+
+        vec3 result = ambient + diffuse + specular;
+        FragColor = vec4(result, opacity);
+    }
+}

fast/kernels/Visualization/TriangleRenderer/TriangleRenderer.vert

@@ -0,0 +1,35 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aNormal;
+layout (location = 2) in vec3 aColor;
+
+out vec3 Normal;
+out vec3 FragPos;
+out vec3 LightPos;
+out vec3 ViewPos;
+out vec3 Color;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform bool use_normals;
+uniform bool useGlobalColor;
+uniform vec3 globalColor;
+
+void main()
+{
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    if(use_normals) {
+        Normal = mat3(transpose(inverse(transform))) * aNormal;
+    } else {
+        Normal = vec3(1,0,0);
+    }
+    FragPos = vec3(transform * vec4(aPos, 1.0));
+    LightPos = vec3(inverse(viewTransform) * vec4(0.0, 0.0, 0.0, 1.0));
+    ViewPos = vec3(inverse(viewTransform) * vec4(0.0, 0.0, 0.0, 1.0));
+    if(useGlobalColor) {
+        Color = globalColor;
+    } else {
+        Color = aColor;
+    }
+}

fast/kernels/Visualization/VectorFieldRenderer/VectorFieldColorRenderer.cl

@@ -0,0 +1,30 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+float3 hueToRGB(float H) {
+    float R = fabs(H * 6.0f - 3.0f) - 1;
+    float G = 2 - fabs(H * 6 - 2);
+    float B = 2 - fabs(H * 6 - 4);
+    return clamp((float3)(R, G, B), 0.0f, 1.0f);
+}
+
+__kernel void renderToTexture(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float maxOpacity,
+        __private float maxVectorMagnitude
+    ) {
+    const int2 position = {get_global_id(0), get_global_id(1)};
+
+    const float2 vector = read_imagef(input, sampler, position).xy;
+
+    // Calculate angle of vector
+    const float angle = (1.0f + atan2(vector.y, vector.x) / 3.141592f) / 2.0f; // mapping -pi,pi to 0,1
+
+    // Use angle as hue and then convert to RGB
+    const float3 color = hueToRGB(angle);
+
+    // Use vector magnitude as opacity
+    const float opacity = clamp(length(vector)/maxVectorMagnitude, 0.0f, maxOpacity);
+
+    write_imagef(output, position, (float4)(color.x, color.y, color.z, opacity));
+}

fast/kernels/Visualization/VertexRenderer/VertexRenderer.frag

@@ -0,0 +1,14 @@
+#version 330 core
+
+out vec4 FragColor;
+in vec4 vertex_color;
+
+void main()
+{
+    vec2 circCoord = gl_PointCoord - vec2(0.5, 0.5);
+    if(dot(circCoord, circCoord) > 0.25) {
+        discard;
+    } else {
+        FragColor = vertex_color;
+    }
+}

fast/kernels/Visualization/VertexRenderer/VertexRenderer.vert

@@ -0,0 +1,23 @@
+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec3 aColor;
+
+out vec4 vertex_color;
+
+uniform mat4 transform;
+uniform mat4 viewTransform;
+uniform mat4 perspectiveTransform;
+uniform float pointSize;
+uniform bool useGlobalColor;
+uniform vec3 globalColor;
+
+void main()
+{
+    gl_PointSize = pointSize;
+    gl_Position = perspectiveTransform * viewTransform * transform * vec4(aPos, 1.0);
+    if(useGlobalColor) {
+        vertex_color = vec4(globalColor, 1.0);
+    } else {
+        vertex_color = vec4(aColor, 1.0);
+    }
+}

fast/kernels/Visualization/View.cl

@@ -0,0 +1,10 @@
+
+__kernel void initializePBO(
+        __global float* PBO,
+        __private float red,
+        __private float green,
+        __private float blue
+        ) {
+    const float4 value = {red, green, blue, 1.0};
+    vstore4(value, get_global_id(0), PBO);
+}