melage 0.0.65__py3-none-any.whl

melage/utils/Shaders_bu.py

@@ -0,0 +1,314 @@
+
+__AUTHOR__ = 'Bahram Jafrasteh'
+
+# vTexCoord=[0.0,0.0,  1.0,0.0,  1.0,1.0,  0.0,1.0]
+# vVertices= [-1.0,-1.0,  1.0,-1.0,  1.0,1.0,  -1.0,1.0]
+
+# self.coord = [(0, 0), (0, 1), (1, 1), (1, 0)]
+# self.vertex = [(0, 0), (0, self.imHeight), (self.imWidth, self.imHeight), (self.imWidth, 0)]
+
+vsrc = """
+#version 330 
+in vec2 in_Vertex;
+in vec2 vertTexCoord;
+out vec2 fragTexCoord;
+uniform mat4 g_matModelView;
+void main(void)
+{
+gl_Position = vec4(in_Vertex, 0.0, 1.0)*g_matModelView;
+
+fragTexCoord = vertTexCoord;
+}
+"""
+
+fsrc = """
+#version 330
+#extension GL_ARB_explicit_uniform_location : enable
+#extension GL_ARB_explicit_attrib_location : enable
+
+//GPU FFT using a Stockham formulation
+#define HORIZONTAL
+
+//precision mediump float;
+
+const float PI = 3.14159265359;
+uniform float u_transformSize;
+uniform float u_subtransformSize;
+
+
+
+
+uniform sampler2D u_input;
+uniform sampler2D tex;
+uniform float threshold;
+uniform	  float			contrastMult;		/* IN: contrast multiplier */
+uniform	  float			brightnessAdd;		/* IN: brightness summand */			
+uniform	  vec3			deinterlace;		/* IN: de-interlacing information:
+												   s .. interlacing offset [pixel/texture size]
+												   t .. texture size [pixel]
+												   p .. mirror y axis, if 1.0 */
+uniform vec2 mousePos;
+uniform vec2 iResolution;
+uniform float maxRadius;
+uniform float Ilum;
+
+const float	fZero= 0.0;
+const float	fOne= 1.0;
+const float	fTwo= 2.0;
+const float	fColScal= 256.0;
+const float Epsilon= 1e-10;
+
+
+in vec2 fragTexCoord;
+out vec4 fragColor;
+
+
+uniform	 int sobel;
+uniform float sobel_threshold;
+
+
+vec2 multiplyComplex (vec2 a, vec2 b) {
+    return vec2(a[0] * b[0] - a[1] * b[1], a[1] * b[0] + a[0] * b[1]);
+}
+
+vec4 fft(vec2 vUV, float u_transformSize, float u_subtransformSize){
+    #ifdef HORIZONTAL
+        float index = vUV.x * u_transformSize - 0.5;
+    #else
+        float index = vUV.y * u_transformSize - 0.5;
+    #endif
+
+    float evenIndex = floor(index / u_subtransformSize) * (u_subtransformSize * 0.5) + mod(index, u_subtransformSize * 0.5);
+
+    //transform two complex sequences simultaneously
+    #ifdef HORIZONTAL
+        vec4 even = texture2D(u_input, vec2(evenIndex + 0.5, gl_FragCoord.y) / u_transformSize).rgba;
+        vec4 odd = texture2D(u_input, vec2(evenIndex + u_transformSize * 0.5 + 0.5, gl_FragCoord.y) / u_transformSize).rgba;
+    #else
+        vec4 even = texture2D(u_input, vec2(gl_FragCoord.x, evenIndex + 0.5) / u_transformSize).rgba;
+        vec4 odd = texture2D(u_input, vec2(gl_FragCoord.x, evenIndex + u_transformSize * 0.5 + 0.5) / u_transformSize).rgba;
+    #endif
+
+    float twiddleArgument1D = -2.0 * PI * (index / u_subtransformSize);
+    vec2 twiddle1D = vec2(cos(twiddleArgument1D), sin(twiddleArgument1D));
+
+    vec2 outputA = even.xy + multiplyComplex(twiddle1D, odd.xy);  //even.xy
+    vec2 outputB = even.zw + multiplyComplex(twiddle1D, odd.zw); //even.zw
+
+    //gl_gl_FragColor
+    return vec4(outputA,outputB);
+}
+
+vec4 sobel_kernel(sampler2D tex, vec2 coord)
+{
+	float w = maxRadius / iResolution.x;
+	float h = maxRadius / iResolution.y;
+
+	vec3 BL = texture2D(tex, coord + vec2( -w, -h)).rgb;
+	vec3 BM = texture2D(tex, coord + vec2(0.0, -h)).rgb;
+	vec3 BR = texture2D(tex, coord + vec2(  w, -h)).rgb;
+	vec3 ML = texture2D(tex, coord + vec2( -w, 0.0)).rgb;
+	vec3 MM = texture2D(tex, coord).rgb;
+	vec3 MR = texture2D(tex, coord + vec2(  w, 0.0)).rgb;
+	vec3 TL = texture2D(tex, coord + vec2( -w, h)).rgb;
+	vec3 TM = texture2D(tex, coord + vec2(0.0, h)).rgb;
+	vec3 TR = texture2D(tex, coord + vec2(  w, h)).rgb;
+	vec3 GradX = -TL + TR - 2.0 * ML + 2.0 * MR - BL + BR;
+    vec3 GradY = TL + 2.0 * TM + TR - BL - 2.0 * BM - BR;
+    return vec4 (length(vec2(GradX.r, GradY.r)), length(vec2(GradX.g, GradY.g)), length(vec2(GradX.b, GradY.b)), 1);
+	//vec4 sobel_edge_h = n[2] + (2.0*n[5]) + n[8] - (n[0] + (2.0*n[3]) + n[6]);
+  	//vec4 sobel_edge_v = n[0] + (2.0*n[1]) + n[2] - (n[6] + (2.0*n[7]) + n[8]);
+
+}
+
+vec3 RGBtoHSV(in vec3 RGB)
+{
+    vec4  P   = (RGB.g < RGB.b) ? vec4(RGB.bg, -1.0, 2.0/3.0) : vec4(RGB.gb, 0.0, -1.0/3.0);
+    vec4  Q   = (RGB.r < P.x) ? vec4(P.xyw, RGB.r) : vec4(RGB.r, P.yzx);
+    float C   = Q.x - min(Q.w, Q.y);
+    float H   = abs((Q.w - Q.y) / (6.0 * C + Epsilon) + Q.z);
+    vec3  HCV = vec3(H, C, Q.x);
+    float S   = HCV.y / (HCV.z + Epsilon);
+    return vec3(HCV.x, S, HCV.z);
+}
+vec3 HSVtoRGB(in vec3 HSV)
+{
+    float H   = HSV.x;
+    float R   = abs(H * 6.0 - 3.0) - 1.0;
+    float G   = 2.0 - abs(H * 6.0 - 2.0);
+    float B   = 2.0 - abs(H * 6.0 - 4.0);
+    vec3  RGB = clamp( vec3(R,G,B), 0.0, 1.0 );
+    return ((RGB - 1.0) * HSV.y + 1.0) * HSV.z;
+}
+
+mat3 kernel1 = mat3 (1.0, 0.0, -1.0,
+2.0, 0.0, 2.0,
+1.0, 0.0, -1.0);
+mat3 kernel2 = mat3 (1.0, 2.0, 1.0,
+0.0, 0.0, 0.0,
+-1.0, -2.0, -1.0);
+
+float toGrayscale(vec3 source) {
+float average = (source.x+source.y+source.z)/3.0;
+return average;
+}
+
+
+float doConvolution(mat3 kernel) {
+float sum = 0.0;
+float current_pixelColor = toGrayscale(texture2D(tex,fragTexCoord).xyz);
+float xOffset = float(1)/1024.0;
+float yOffset = float(1)/768.0;
+float new_pixel00 = toGrayscale(texture2D(tex, vec2(fragTexCoord.x-xOffset,fragTexCoord.y-yOffset)).xyz);
+float new_pixel01 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x,fragTexCoord.y-yOffset)).xyz);
+float new_pixel02 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x+xOffset,fragTexCoord.y-yOffset)).xyz);
+vec3 pixelRow0 = vec3(new_pixel00,new_pixel01,new_pixel02);
+float new_pixel10 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x-xOffset,fragTexCoord.y)).xyz);
+float new_pixel11 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x,fragTexCoord.y)).xyz);
+float new_pixel12 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x+xOffset,fragTexCoord.y)).xyz);
+vec3 pixelRow1 = vec3(new_pixel10,new_pixel11,new_pixel12);
+float new_pixel20 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x-xOffset,fragTexCoord.y+yOffset)).xyz);
+float new_pixel21 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x,fragTexCoord.y+yOffset)).xyz);
+float new_pixel22 = toGrayscale(texture2D(tex,vec2(fragTexCoord.x+xOffset,fragTexCoord.y+yOffset)).xyz);
+vec3 pixelRow2 = vec3(new_pixel20,new_pixel21,new_pixel22);
+vec3 mult1 = (kernel[0]*pixelRow0);
+vec3 mult2 = (kernel[1]*pixelRow1);
+vec3 mult3 = (kernel[2]*pixelRow2);
+sum= mult1.x+mult1.y+mult1.z+mult2.x+mult2.y+mult2.z+mult3.x+mult3.y+mult3.z;
+return sum;
+
+}
+
+
+void main(void)
+{
+int gaussianBlue = 0;
+
+if (sobel== 1) //soble kernel
+    {
+    vec4 color0 = texture2D(tex, fragTexCoord);
+vec4 bw = vec4(vec3(color0.r, color0.g, color0.b), color0.a);
+vec2 uv = gl_FragCoord.xy/iResolution.xy;
+vec2 mousePosition= mousePos/iResolution.xy;
+  float dist = distance(mousePosition, uv);
+  float distx = abs(mousePosition.x-uv.x);
+  float disty = abs(mousePosition.y-uv.y);
+  float mixAmount = clamp((dist - 0.0) / 0.2, 0., 1.);
+  //color0.r += mixAmount;
+  //vec4 mouseColor= texture2D(tex, mousePosition.xy); 
+  //float distcolor = distance(color0.rgb, mouseColor.rgb);
+  //float mixAmountc = clamp((distcolor - 0.0) / (1.0-maxRadius), 0., 1.);
+  //color0 = mix(color0, bw, mixAmount);
+  //color0 = mix(color0, bw, mixAmountc);
+  //color0.r += mixAmountc;
+//float luminanceM = dot (vec3(0.114 ,0.587,0.299 ),mouseColor.rgb);
+
+vec4 sobelk = sobel_kernel(tex, fragTexCoord.st);       
+
+
+    float luminance = dot (vec3(0.114 ,0.587,0.299 ),color0.rgb);
+
+    if(luminance<sobel_threshold)
+           fragColor = vec4(color0.rgba); 
+
+    else   
+    {   
+        //if ( (distx <  0.08) && (disty < 0.04))
+         //   fragColor = vec4(0.0,1,0,1);
+        //else
+        //    fragColor = vec4(color0.rgba); 
+        color0.r += sobelk.r;
+        color0.g = sobelk.g;
+        color0.b += sobelk.b;
+
+        }
+  fragColor = mix(color0, bw, mixAmount);
+
+    vec4 pixelColor = texture2D(tex, fragTexCoord);
+    float horizontalSum = 0.0;
+    float verticalSum = 0.0;
+    float averageSum = 0.0;
+    horizontalSum = doConvolution(kernel1);
+    verticalSum = doConvolution(kernel2);
+    if( (verticalSum > sobel_threshold)|| (horizontalSum >sobel_threshold)||(verticalSum < -sobel_threshold)|| (horizontalSum <-sobel_threshold))
+        averageSum = pixelColor.x;
+    else
+        averageSum = 1.0;
+    fragColor = vec4(averageSum,averageSum,averageSum,1.0);
+
+}
+else
+{
+	vec4 pixelColor = texture2D(tex, fragTexCoord);
+
+    pixelColor.rgb /= pixelColor.a;
+
+    // first apply brightness
+    pixelColor.rgb += brightnessAdd;
+
+    // then apply contrast
+    pixelColor.rgb = ((pixelColor.rgb - 0.5) * max(contrastMult, 0.0)) + 0.5;
+
+    // Return final pixel color
+    pixelColor.rgb *= pixelColor.a;
+
+    vec3 current_Color;
+
+    current_Color = vec3(pixelColor.r, pixelColor.g, pixelColor.b);
+
+    if (threshold>0)
+    {
+        float luminance = dot (vec3(0.114 ,0.587,0.299 ),current_Color);
+        if(luminance<threshold)
+            fragColor = vec4(1.0);
+        else
+            fragColor = vec4(0.0);
+    }
+    else
+    {
+        //vec3 col_hsv = RGBtoHSV(current_Color);
+        //uniform float     u_saturate;
+        //float     u_saturate;
+        //u_saturate = 10.0;
+        //col_hsv.y *= (u_saturate * 2.0);
+        //vec3 col_rgb = HSVtoRGB(col_hsv.rgb);
+        //fragColor = vec4(col_rgb.rgb, fOne);    
+        fragColor =	vec4(current_Color, fOne);
+
+        //fragColor = fft(gl_FragCoord.xy, u_transformSize,u_subtransformSize);
+    }
+
+
+}    
+}
+"""
+
+vsrcPaint = """
+#version 330 
+in vec2 in_Vertex;
+uniform mat4 g_matModelView;
+out vec4 positionGL;
+void main(void)
+{
+
+gl_Position = vec4(in_Vertex, 0.0, 1.0)*g_matModelView;
+positionGL = gl_Position;
+gl_PointSize = 200.0;
+}
+"""
+
+fsrcPaint = """
+#version 330 
+
+uniform vec4 my_color;
+out vec4 FragColor;
+in vec4 positionGL;
+
+
+
+void main(void)
+{
+FragColor = my_color;
+
+}
+"""

melage/utils/__init__0.py

@@ -0,0 +1,7 @@
+__author__='Bahram Jafrasteh'
+import sys
+import os
+
+__all__ = ['Shaders', 'Shadersv120', 'custom_QScrollBar', 'utils', 'DispalyIm', 'GMM', 'registration', 'brain_extraction_helper', 'readData', 'source_folder', 'Shaders_bu', 'glScientific']
+
+

melage/utils/brain_extraction_helper.py

@@ -0,0 +1,234 @@
+"""
+    Helper functions
+"""
+import numpy as np
+from numba import jit
+
+"""
+This code has been used from https://github.com/vanandrew/brainextractor/tree/main/brainextractor
+with small modification whenever it is needed.
+
+"""
+
+
+def sphere(shape: list, radius: float, position: list):
+    """
+    Creates a binary sphere
+    """
+    # assume shape and position are both a 3-tuple of int or float
+    # the units are pixels / voxels (px for short)
+    # radius is a int or float in px
+    semisizes = (radius,) * 3
+
+    # genereate the grid for the support points
+    # centered at the position indicated by position
+    grid = [slice(-x0, dim - x0) for x0, dim in zip(position, shape)]
+    position = np.ogrid[grid]
+    # calculate the distance of all points from `position` center
+    # scaled by the radius
+    arr = np.zeros(shape, dtype=float)
+    for x_i, semisize in zip(position, semisizes):
+        # this can be generalized for exponent != 2
+        # in which case `(x_i / semisize)`
+        # would become `np.abs(x_i / semisize)`
+        arr += (x_i / semisize) ** 2
+
+    # the inner part of the sphere will have distance below 1
+    return arr <= 1.0
+
+
+@jit(nopython=True, cache=True)
+def closest_integer_point(vertex: np.ndarray):
+    """
+    Gives the closest integer point based on euclidean distance
+    """
+    # get neighboring grid points to search
+    x = vertex[0]
+    y = vertex[1]
+    z = vertex[2]
+    x0 = np.floor(x)
+    y0 = np.floor(y)
+    z0 = np.floor(z)
+    x1 = x0 + 1
+    y1 = y0 + 1
+    z1 = z0 + 1
+
+    # initialize min euclidean distance
+    min_euclid = 99
+
+    # loop through each neighbor point
+    for i in [x0, x1]:
+        for j in [y0, y1]:
+            for k in [z0, z1]:
+                # compare coordinate and store if min euclid distance
+                coords = np.array([i, j, k])
+                dist = l2norm(vertex - coords)
+                if dist < min_euclid:
+                    min_euclid = dist
+                    final_coords = coords
+
+    # return the final coords
+    return final_coords.astype(np.int64)
+
+
+@jit(nopython=True, cache=True)
+def bresenham3d(v0: np.ndarray, v1: np.ndarray, shape):
+    """
+    Bresenham's algorithm for a 3-D line
+
+    https://www.geeksforgeeks.org/bresenhams-algorithm-for-3-d-line-drawing/
+    """
+    # initialize axis differences
+
+    dx = np.abs(v1[0] - v0[0])
+    dy = np.abs(v1[1] - v0[1])
+    dz = np.abs(v1[2] - v0[2])
+    maxx = shape[0]
+    maxy = shape[1]
+    maxz = shape[2]
+    v0[0] = v0[0]-1 if (v0[0] >= maxx) else v0[0]
+    v0[1] = v0[1]-1 if (v0[1] >= maxy) else v0[1]
+    v0[2] = v0[2]-1 if (v0[2] >= maxz) else v0[2]
+
+    v1[0] = v1[0]-1 if (v1[0] >= maxx) else v1[0]
+    v1[1] = v1[1]-1 if (v1[1] >= maxy) else v1[1]
+    v1[2] = v1[2]-1 if (v1[2] >= maxz) else v1[2]
+
+    xs = 1 if (v1[0] > v0[0]) else -1
+    ys = 1 if (v1[1] > v0[1]) else -1
+    zs = 1 if (v1[2] > v0[2]) else -1
+
+    # determine the driving axis
+    if dx >= dy and dx >= dz:
+        d0 = dx
+        d1 = dy
+        d2 = dz
+        s0 = xs
+        s1 = ys
+        s2 = zs
+        a0 = 0
+        a1 = 1
+        a2 = 2
+    elif dy >= dx and dy >= dz:
+        d0 = dy
+        d1 = dx
+        d2 = dz
+        s0 = ys
+        s1 = xs
+        s2 = zs
+        a0 = 1
+        a1 = 0
+        a2 = 2
+    elif dz >= dx and dz >= dy:
+        d0 = dz
+        d1 = dx
+        d2 = dy
+        s0 = zs
+        s1 = xs
+        s2 = ys
+        a0 = 2
+        a1 = 0
+        a2 = 1
+
+    # create line array
+    line = np.zeros((d0 + 1, 3), dtype=np.int64)
+    line[0] = v0
+
+    # get points
+    p1 = 2 * d1 - d0
+    p2 = 2 * d2 - d0
+    for i in range(d0):
+        c = line[i].copy()
+        c[a0] += s0
+        if p1 >= 0:
+            c[a1] += s1
+            p1 -= 2 * d0
+        if p2 >= 0:
+            c[a2] += s2
+            p2 -= 2 * d0
+        p1 += 2 * d1
+        p2 += 2 * d2
+        line[i + 1] = c
+
+    # return list
+    return line
+
+
+@jit(nopython=True, cache=True)
+def l2norm(vec: np.ndarray):
+    """
+    Computes the l2 norm for 3d vector
+    """
+    return np.sqrt(vec[0] ** 2 + vec[1] ** 2 + vec[2] ** 2)
+
+
+@jit(nopython=True, cache=True)
+def l2normarray(array: np.ndarray):
+    """
+    Computes the l2 norm for several 3d vectors
+    """
+    return np.sqrt(array[:, 0] ** 2 + array[:, 1] ** 2 + array[:, 2] ** 2)
+
+
+def diagonal_dot(a: np.ndarray, b: np.ndarray):
+    """
+    Dot product by row of a and b.
+    There are a lot of ways to do this though
+    performance varies very widely. This method
+    uses a dot product to sum the row and avoids
+    function calls if at all possible.
+    """
+    a = np.asanyarray(a)
+    return np.dot(a * b, [1.0] * a.shape[1])
+
+
+
+def bresenhamlines_getdata(start, end, data, tm, t2, mode):
+    #https://code.activestate.com/recipes/578112-bresenhams-line-algorithm-in-n-dimensions/
+    max_iter = np.amax(np.abs(end - start), axis=1)
+
+    slope = end - start
+    scale = np.amax(np.abs(slope), axis=1).reshape(-1, 1)
+    zeroslope = (scale == 0).all(1)
+    scale[zeroslope] = np.ones(1)
+    nslope = np.array(slope, dtype=np.double) / scale
+    nslope[zeroslope] = np.zeros(slope[0].shape)
+    npts, dim = 1, 3
+
+    # steps to iterate on
+
+    blines = []
+    Intensitymat = np.zeros(len(max_iter))
+    if mode=='min':
+        for i in range(len(max_iter)):
+            stepmat = np.ones((max_iter[i]+1, 3))*(np.arange(max_iter[i]+1).reshape(-1,1))
+            # some hacks for broadcasting properly
+            bline = np.rint(start[i, np.newaxis, :]+nslope[i,np.newaxis, :]*stepmat).astype(start.dtype)
+            intensity = data[bline[:,0], bline[:,1], bline[:,2]]
+            Intensitymat[i] = np.max([t2, np.min([np.min(intensity),tm])])  # min intensity from far distance
+
+    else:
+        for i in range(len(max_iter)):
+            stepmat = np.ones((max_iter[i]+1, 3))*(np.arange(max_iter[i]+1).reshape(-1,1))
+            # some hacks for broadcasting properly
+            bline = np.rint(start[i, np.newaxis, :]+nslope[i,np.newaxis, :]*stepmat).astype(start.dtype)
+            intensity = data[bline[:,0], bline[:,1], bline[:,2]]
+
+            Intensitymat[i] = np.min([t2, np.max([np.max(intensity), tm])])
+    return Intensitymat
+
+def bresenham3d_python(start: np.ndarray, end: np.ndarray):
+    ## BJ
+    slope = np.asanyarray(end - start)
+    scale = np.max(np.abs(slope), axis=1).reshape(-1, 1)
+    zeroslope = (scale == 0).all(1)
+    scale[zeroslope] = np.ones(1)
+    nslope = np.array(slope, dtype=np.double) / scale
+    nslope[zeroslope] = np.zeros(slope[0].shape)
+    max_iter = np.amax(np.abs(end - start), axis=1)
+    #stepseq = np.arange(1, max_iter + 1)
+    #stepmat = np.tile(stepseq, (dim, 1)).T
+    stepmat = np.ones((max_iter + 1, 3)) * (np.arange(max_iter + 1).reshape(-1, 1))
+    # some hacks for broadcasting properly
+    bline = np.rint(start[:, np.newaxis, :] + nslope[:, np.newaxis, :] * stepmat).astype(start.dtype)
+    return bline

melage/utils/custom_QScrollBar.py

@@ -0,0 +1,61 @@
+from PyQt5.QtWidgets import QScrollBar
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QMenu, QAction, QDialog
+from PyQt5.QtCore import pyqtSignal
+from PyQt5 import QtWidgets
+class custom_qscrollbar(QScrollBar):
+    """
+    HORIZONTAL SLIDER
+    """
+    cut_limit = pyqtSignal(object)
+    def __init__(self, parent=None, id = 0):
+        self.id = id
+        QScrollBar.__init__(self, parent)
+        Dialog = self.window()
+        Dialog.setObjectName("Image info")
+        Dialog.resize(40, 200)
+        self.setContextMenuPolicy(Qt.CustomContextMenu)
+        self.customContextMenuRequested.connect(self.ShowContextMenu)
+        self._txtA = "A"
+        self._txtB = "B"
+        self._first = 0
+        self._second = 0
+
+
+
+    def ShowContextMenu(self, pos):
+        menu = QMenu('Menu')
+        first_action = QAction(self._txtA)
+        second_action = QAction(self._txtB)
+
+        cut_action = QAction("Cut")
+        menu.addAction(first_action)
+        menu.addAction(second_action)
+        menu.addAction(cut_action)
+        action = menu.exec_(self.mapToGlobal(pos))
+        if action==first_action:
+            #mouse_p = int((pos.x() / self.width()) * (self.maximum() - self.minimum()) + self.minimum())
+            #self.setSliderPosition(mouse_p)
+            self._first = self.value()
+            self._txtA = "A:{}".format(self._first)
+            #self.setSliderPosition(105)
+        elif action==second_action:
+            self._second = self.value()
+            self._txtB = "B:{}".format(self._second)
+        elif action == cut_action:
+            if self._first == self._second:
+                return
+            cut_limit = [self._first, self._second]
+            self.cut_limit.emit(cut_limit)
+
+def run():
+    import sys
+    from PyQt5 import QtWidgets, QtCore, QtGui
+    from PyQt5.QtCore import pyqtSignal
+    app = QtWidgets.QApplication(sys.argv)
+    window = custom_qscrollbar()
+    window.show()
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    run()