pyfast 4.13.1__cp36-abi3-win_amd64.whl → 4.14.0__cp36-abi3-win_amd64.whl

fast/fast.py

@@ -154,6 +154,8 @@ def getDefaultIntensityWindow(type: "fast::DataType") -> "float":
 
 def deleteArray(data: "void *", type: "fast::DataType") -> "void":
     return _fast.deleteArray(data, type)
+PixelConnectivity_Closests = _fast.PixelConnectivity_Closests
+PixelConnectivity_All = _fast.PixelConnectivity_All
 class vectori(object):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
@@ -6568,6 +6570,222 @@ def ColorToGrayscale_getStaticNameOfClass() -> "std::string":
 def ColorToGrayscale_create() -> "std::shared_ptr< fast::ColorToGrayscale >":
     return _fast.ColorToGrayscale_create()
 
+class DrawCubicHermiteSpline(ProcessObject):
+    r"""
+    Draw cubic hermite splines on an input Image
+
+    Inputs:
+    - 0: Image
+
+    Outputs
+    - 0: Image
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
+    __repr__ = _swig_repr
+
+    @staticmethod
+    def New() -> "std::shared_ptr< fast::DrawCubicHermiteSpline >":
+        return _fast.DrawCubicHermiteSpline_New()
+
+    def getNameOfClass(self) -> "std::string":
+        return _fast.DrawCubicHermiteSpline_getNameOfClass(self)
+
+    @staticmethod
+    def getStaticNameOfClass() -> "std::string":
+        return _fast.DrawCubicHermiteSpline_getStaticNameOfClass()
+    CloseSpline_No = _fast.DrawCubicHermiteSpline_CloseSpline_No
+    CloseSpline_Smooth = _fast.DrawCubicHermiteSpline_CloseSpline_Smooth
+    CloseSpline_Straight = _fast.DrawCubicHermiteSpline_CloseSpline_Straight
+
+    @staticmethod
+    def create(*args, **kwargs) -> "std::shared_ptr< fast::DrawCubicHermiteSpline >":
+        r"""
+        Create instance
+
+        :type controlPoints: std::vector< Vector2f,std::allocator< Vector2f > >
+        :param controlPoints:
+        :type close: int
+        :param close:
+        :type value: float
+        :param value:
+        :type color: :py:class:`Color`
+        :param color:
+        :type fill: boolean
+        :param fill:
+        :type controlPointsInPixels: boolean
+        :param controlPointsInPixels:
+        :rtype: :py:class:`DrawCubicHermiteSpline`
+        :return: instance
+        """
+        return _fast.DrawCubicHermiteSpline_create(*args, **kwargs)
+
+    def setControlPoints(self, controlPoints: "std::vector< Vector2f,std::allocator< Vector2f > >") -> "void":
+        return _fast.DrawCubicHermiteSpline_setControlPoints(self, controlPoints)
+    __swig_destroy__ = _fast.delete_DrawCubicHermiteSpline
+
+# Register DrawCubicHermiteSpline in _fast:
+_fast.DrawCubicHermiteSpline_swigregister(DrawCubicHermiteSpline)
+
+def DrawCubicHermiteSpline_New() -> "std::shared_ptr< fast::DrawCubicHermiteSpline >":
+    return _fast.DrawCubicHermiteSpline_New()
+
+def DrawCubicHermiteSpline_getStaticNameOfClass() -> "std::string":
+    return _fast.DrawCubicHermiteSpline_getStaticNameOfClass()
+
+def DrawCubicHermiteSpline_create(*args, **kwargs) -> "std::shared_ptr< fast::DrawCubicHermiteSpline >":
+    r"""
+    Create instance
+
+    :type controlPoints: std::vector< Vector2f,std::allocator< Vector2f > >
+    :param controlPoints:
+    :type close: int
+    :param close:
+    :type value: float
+    :param value:
+    :type color: :py:class:`Color`
+    :param color:
+    :type fill: boolean
+    :param fill:
+    :type controlPointsInPixels: boolean
+    :param controlPointsInPixels:
+    :rtype: :py:class:`DrawCubicHermiteSpline`
+    :return: instance
+    """
+    return _fast.DrawCubicHermiteSpline_create(*args, **kwargs)
+
+class FillHoles(ProcessObject):
+    r"""
+    Fill holes in image/segmentation
+
+    Inputs:
+    - 0: Image
+
+    Outputs
+    - 0: Image
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
+    __repr__ = _swig_repr
+
+    @staticmethod
+    def New() -> "std::shared_ptr< fast::FillHoles >":
+        return _fast.FillHoles_New()
+
+    def getNameOfClass(self) -> "std::string":
+        return _fast.FillHoles_getNameOfClass(self)
+
+    @staticmethod
+    def getStaticNameOfClass() -> "std::string":
+        return _fast.FillHoles_getStaticNameOfClass()
+
+    @staticmethod
+    def create() -> "std::shared_ptr< fast::FillHoles >":
+        return _fast.FillHoles_create()
+    __swig_destroy__ = _fast.delete_FillHoles
+
+# Register FillHoles in _fast:
+_fast.FillHoles_swigregister(FillHoles)
+
+def FillHoles_New() -> "std::shared_ptr< fast::FillHoles >":
+    return _fast.FillHoles_New()
+
+def FillHoles_getStaticNameOfClass() -> "std::string":
+    return _fast.FillHoles_getStaticNameOfClass()
+
+def FillHoles_create() -> "std::shared_ptr< fast::FillHoles >":
+    return _fast.FillHoles_create()
+
+class DrawCircle(ProcessObject):
+    r"""
+    Draw circles on an input Image
+
+    Inputs:
+    - 0: Image
+
+    Outputs
+    - 0: Image
+
+    """
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined")
+    __repr__ = _swig_repr
+
+    @staticmethod
+    def New() -> "std::shared_ptr< fast::DrawCircle >":
+        return _fast.DrawCircle_New()
+
+    def getNameOfClass(self) -> "std::string":
+        return _fast.DrawCircle_getNameOfClass(self)
+
+    @staticmethod
+    def getStaticNameOfClass() -> "std::string":
+        return _fast.DrawCircle_getStaticNameOfClass()
+
+    @staticmethod
+    def create(*args, **kwargs) -> "std::shared_ptr< fast::DrawCircle >":
+        r"""
+        Create instance
+
+        :type centroids: std::vector< Vector2f,std::allocator< Vector2f > >
+        :param centroids: List of centroid coordinates.
+        :type radii: std::vector< float,std::allocator< float > >
+        :param radii: Radius for each circle/centroid. If only one radius is given, it will be used for all circles.
+        :type value: float
+        :param value: Value to use to draw circles
+        :type color: :py:class:`Color`
+        :param color: Color to use to draw circles
+        :type fill: boolean
+        :param fill: Whether to fill the circle or not
+        :type inPixels: boolean
+        :param inPixels: Whether the centroids and radii are given in pixels or in millimeters
+        :rtype: :py:class:`DrawCircle`
+        :return: instance
+        """
+        return _fast.DrawCircle_create(*args, **kwargs)
+    __swig_destroy__ = _fast.delete_DrawCircle
+
+# Register DrawCircle in _fast:
+_fast.DrawCircle_swigregister(DrawCircle)
+
+def DrawCircle_New() -> "std::shared_ptr< fast::DrawCircle >":
+    return _fast.DrawCircle_New()
+
+def DrawCircle_getStaticNameOfClass() -> "std::string":
+    return _fast.DrawCircle_getStaticNameOfClass()
+
+def DrawCircle_create(*args, **kwargs) -> "std::shared_ptr< fast::DrawCircle >":
+    r"""
+    Create instance
+
+    :type centroids: std::vector< Vector2f,std::allocator< Vector2f > >
+    :param centroids: List of centroid coordinates.
+    :type radii: std::vector< float,std::allocator< float > >
+    :param radii: Radius for each circle/centroid. If only one radius is given, it will be used for all circles.
+    :type value: float
+    :param value: Value to use to draw circles
+    :type color: :py:class:`Color`
+    :param color: Color to use to draw circles
+    :type fill: boolean
+    :param fill: Whether to fill the circle or not
+    :type inPixels: boolean
+    :param inPixels: Whether the centroids and radii are given in pixels or in millimeters
+    :rtype: :py:class:`DrawCircle`
+    :return: instance
+    """
+    return _fast.DrawCircle_create(*args, **kwargs)
+
 class GaussianSmoothing(ProcessObject):
     r"""
     Smoothing by convolution with a Gaussian mask
@@ -12146,7 +12364,7 @@ class SeededRegionGrowing(ProcessObject):
         return _fast.SeededRegionGrowing_connect(self, *args)
 
     @staticmethod
-    def create(intensityMinimum: "float", intensityMaximum: "float", seedPoints: "std::vector< Vector3i,std::allocator< Vector3i > >") -> "std::shared_ptr< fast::SeededRegionGrowing >":
+    def create(*args, **kwargs) -> "std::shared_ptr< fast::SeededRegionGrowing >":
         r"""
         Create instance
         :type intensityMinimum: float
@@ -12155,10 +12373,12 @@ class SeededRegionGrowing(ProcessObject):
         :param intensityMaximum: Maximum intensity to accept voxel as part of segmentation.
         :type seedPoints: std::vector< Vector3i,std::allocator< Vector3i > >
         :param seedPoints: List of seed points in pixel space. If 2D, z component is not used.
+        :type connectivity: int
+        :param connectivity: Which connectivity to use when growing
         :rtype: :py:class:`SeededRegionGrowing`
         :return: instance
         """
-        return _fast.SeededRegionGrowing_create(intensityMinimum, intensityMaximum, seedPoints)
+        return _fast.SeededRegionGrowing_create(*args, **kwargs)
 
     def setIntensityRange(self, min: "float", max: "float") -> "void":
         return _fast.SeededRegionGrowing_setIntensityRange(self, min, max)
@@ -12179,7 +12399,7 @@ def SeededRegionGrowing_New() -> "std::shared_ptr< fast::SeededRegionGrowing >":
 def SeededRegionGrowing_getStaticNameOfClass() -> "std::string":
     return _fast.SeededRegionGrowing_getStaticNameOfClass()
 
-def SeededRegionGrowing_create(intensityMinimum: "float", intensityMaximum: "float", seedPoints: "std::vector< Vector3i,std::allocator< Vector3i > >") -> "std::shared_ptr< fast::SeededRegionGrowing >":
+def SeededRegionGrowing_create(*args, **kwargs) -> "std::shared_ptr< fast::SeededRegionGrowing >":
     r"""
     Create instance
     :type intensityMinimum: float
@@ -12188,10 +12408,12 @@ def SeededRegionGrowing_create(intensityMinimum: "float", intensityMaximum: "flo
     :param intensityMaximum: Maximum intensity to accept voxel as part of segmentation.
     :type seedPoints: std::vector< Vector3i,std::allocator< Vector3i > >
     :param seedPoints: List of seed points in pixel space. If 2D, z component is not used.
+    :type connectivity: int
+    :param connectivity: Which connectivity to use when growing
     :rtype: :py:class:`SeededRegionGrowing`
     :return: instance
     """
-    return _fast.SeededRegionGrowing_create(intensityMinimum, intensityMaximum, seedPoints)
+    return _fast.SeededRegionGrowing_create(*args, **kwargs)
 
 class SegmentationVolumeReconstructor(ProcessObject):
     r"""

fast/kernels/Algorithms/Draw/DrawCircle.cl

@@ -0,0 +1,97 @@
+
+__kernel void drawFilledCircles(
+    __global float2* centroids,
+    __private int size,
+    __write_only image2d_t output,
+    __global float2* radii,
+    __private char singleRadius,
+    __private float value,
+    __private float3 color
+    ) {
+    const int index = get_global_id(0);
+    float2 centroid = centroids[index];
+    float2 radius;
+    if(singleRadius == 1) {
+        radius = radii[0];
+    } else {
+        radius = radii[index];
+    }
+
+    const int dataType = get_image_channel_data_type(output);
+
+    float4 write = {value, value, value, value};
+    if(value == 0.0f) {
+        // Use color instead
+        write.xyz = color;
+        if(dataType != CLK_FLOAT) {
+            write = round(write*255);
+        }
+    }
+
+    for(int a = -ceil(radius.x); a <= ceil(radius.x); ++a) {
+        for(int b = -ceil(radius.y); b <= ceil(radius.y); ++b) {
+            float2 current = round(centroid + (float2)(a, b));
+            float2 n = current - centroid;
+            float inside = (n.x*n.x)/(radius.x*radius.x) + (n.y*n.y)/(radius.y*radius.y);
+            if(inside <= 1.0f) { // Inside ellipse
+                int2 pos = convert_int2(current);
+                if(pos.x >= 0 && pos.y >= 0 && pos.x < get_image_width(output) && pos.y < get_image_height(output)) {
+                    if(dataType == CLK_FLOAT) {
+                        write_imagef(output, pos, write);
+                    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+                        write_imageui(output, pos, convert_uint4(write));
+                    } else {
+                        write_imagei(output, pos, convert_int4(write));
+                    }
+                }
+            }
+        }
+    }
+}
+
+__kernel void drawCircles(
+    __global float2* centroids,
+    __private int size,
+    __write_only image2d_t output,
+    __global float2* radii,
+    __private char singleRadius,
+    __private float value,
+    __private float3 color
+    ) {
+    const int index = get_global_id(0);
+    float2 centroid = centroids[index];
+    float2 radius;
+    if(singleRadius == 1) {
+        radius = radii[0];
+    } else {
+        radius = radii[index];
+    }
+    const int dataType = get_image_channel_data_type(output);
+
+    float4 write = {value, value, value, value};
+    if(value == 0.0f) {
+        // Use color instead
+        write.xyz = color;
+        if(dataType != CLK_FLOAT) {
+            write = round(write*255);
+        }
+    }
+
+    // Calculate circumference
+    const int N = ceil(2*M_PI_F*max(radius.x, radius.y)); // No closed formula for ellipse circumference
+    for(int i = 0; i < N; ++i) {
+        float angle = i*2.0f*M_PI_F/N;
+        int x = centroid.x + round(cos(angle)*radius.x);
+        int y = centroid.y + round(sin(angle)*radius.y);
+        printf("%d %d\n", x, y);
+
+        if(dataType == CLK_FLOAT) {
+            write_imagef(output, (int2)(x, y), write);
+        } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+            write_imageui(output, (int2)(x, y), convert_uint4(write));
+        } else {
+            write_imagei(output, (int2)(x, y), convert_int4(write));
+        }
+    }
+
+}

fast/kernels/Algorithms/ImageInverter/ImageInverter2D.cl

@@ -0,0 +1,28 @@
+__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_NONE | CLK_FILTER_NEAREST;
+
+__kernel void invert2D(
+        __read_only image2d_t input,
+        __write_only image2d_t output,
+        __private float min,
+        __private float max
+        ) {
+    const int2 pos = {get_global_id(0), get_global_id(1)};
+    int dataType = get_image_channel_data_type(input);
+
+    float4 value;
+    if(dataType == CLK_FLOAT) {
+        value = read_imagef(input, sampler, pos);
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        value = convert_float4(read_imageui(input, sampler, pos));
+    } else {
+        value = convert_float4(read_imagei(input, sampler, pos));
+    }
+    value = (max - min) - value;
+    if(dataType == CLK_FLOAT) {
+        write_imagef(output, pos, value);
+    } else if(dataType == CLK_UNSIGNED_INT8 || dataType == CLK_UNSIGNED_INT16 || dataType == CLK_UNSIGNED_INT32) {
+        write_imageui(output, pos, convert_uint4(value));
+    } else {
+        write_imagei(output, pos, convert_int4(value));
+    }
+}

fast/kernels/Algorithms/SeededRegionGrowing/SeededRegionGrowing2D.cl

@@ -14,7 +14,8 @@ __kernel void seededRegionGrowing(
         __global char* segmentation,
         __global char* stopGrowing,
         __private float min,
-        __private float max
+        __private float max,
+        __private int connectivity
         ) {
     const int2 pos = {get_global_id(0), get_global_id(1)};
     const uint linearPos = pos.x + pos.y*get_global_size(0);
@@ -23,9 +24,9 @@ __kernel void seededRegionGrowing(
     int2 offset[8] = {
             {1,0},
             {0,1},
-            {1,1},
             {-1,0},
             {0,-1},
+            {1,1},
             {-1,-1},
             {-1,1},
             {1,-1}
@@ -36,7 +37,7 @@ __kernel void seededRegionGrowing(
         if(intensity >= min && intensity <= max) {
             segmentation[linearPos] = 1; // add pixel to segmentation
             // Add neighbor pixels to queue
-            for(int i = 0; i < 8; i++) {
+            for(int i = 0; i < connectivity; i++) {
                 // Out of bounds check
                 int2 neighborPos = pos + offset[i];
                 if(neighborPos.x < 0 || neighborPos.y < 0 || 

fast/kernels/Algorithms/SeededRegionGrowing/SeededRegionGrowing3D.cl

@@ -16,18 +16,40 @@ __kernel void seededRegionGrowing(
         __global char* segmentation,
         __global char* stopGrowing,
         __private float min,
-        __private float max
+        __private float max,
+        __private int connectivity
         ) {
     const int4 pos = {get_global_id(0), get_global_id(1), get_global_id(2), 0};
     const uint linearPos = pos.x + pos.y*get_global_size(0) + pos.z*get_global_size(0)*get_global_size(1);
 
-    const int4 offsets[6] = {
-        {0,0,1,0},
-        {0,1,0,0},
-        {1,0,0,0},
-        {0,0,-1,0},
-        {0,-1,0,0},
-        {-1,0,0,0},
+    const int4 offsets[26] = {
+      {-1, 0, 0, 0},
+      {0, -1, 0, 0},
+      {0, 0, -1, 0},
+      {0, 0, 1, 0},
+      {0, 1, 0, 0},
+      {1, 0, 0, 0},
+
+      {-1, -1, -1, 0},
+      {-1, -1, 0, 0},
+      {-1, -1, 1, 0},
+      {-1, 0, -1, 0},
+      {-1, 0, 1, 0},
+      {-1, 1, -1, 0},
+      {-1, 1, 0, 0},
+      {-1, 1, 1, 0},
+      {0, -1, -1, 0},
+      {0, -1, 1, 0},
+      {0, 1, -1, 0},
+      {0, 1, 1, 0},
+      {1, -1, -1, 0},
+      {1, -1, 0, 0},
+      {1, -1, 1, 0},
+      {1, 0, -1, 0},
+      {1, 0, 1, 0},
+      {1, 1, -1, 0},
+      {1, 1, 0, 0},
+      {1, 1, 1, 0}
     };
     
     if(segmentation[linearPos] == 2) { // pixel is in queue
@@ -35,7 +57,7 @@ __kernel void seededRegionGrowing(
         if(intensity >= min && intensity <= max) {
             segmentation[linearPos] = 1; // add pixel to segmentation
             // Add neighbor pixels to queue
-            for(int i = 0; i < 6; i++) {
+            for(int i = 0; i < connectivity; i++) {
                 // Out of bounds check. TODO something more efficient
                 int4 neighborPos = pos + offsets[i];
                 if(neighborPos.x < 0 || neighborPos.y < 0 || neighborPos.z < 0 || 

fast/kernels/Algorithms/SurfaceExtraction/SurfaceExtraction_no_3d_write.cl

@@ -681,10 +681,12 @@ __kernel void traverseHP(
             );
 
         const float value0 = READ_RAW_DATA(rawData, sampler, (int4)(point0.x, point0.y, point0.z, 0)).x;
+        const float value1 = READ_RAW_DATA(rawData, sampler, (int4)(point1.x, point1.y, point1.z, 0)).x;
         float diff = native_divide(
-            isolevel-value0,
-            READ_RAW_DATA(rawData, sampler, (int4)(point1.x, point1.y, point1.z, 0)).x - value0);
+            isolevel - value0,
+             value1 - value0);
 
+        diff = clamp(diff, 0.0f, 1.0f); // TODO Should not be needed
 
         // OpenCL on Mac is missing the mix function for some reason
 #ifdef MAC_HACK