quant1x 0.2.5__tar.gz → 0.3.0__tar.gz

{quant1x-0.2.5 → quant1x-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant1x
-Version: 0.2.5
+Version: 0.3.0
 Summary: Quant1X量化交易框架
 Home-page: https://gitee.com/quant1x/89k
 Author: WangFeng

{quant1x-0.2.5 → quant1x-0.3.0}/quant1x/__init__.py

@@ -5,7 +5,7 @@
 89K 努力打造一个适度的量化交易框架
 """
 
-__version__ = "0.2.5"
+__version__ = "0.3.0"
 __author__ = "WangFeng"
 
 import sys

quant1x-0.3.0/quant1x/data/futu-basicinfo.py

@@ -0,0 +1,27 @@
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+证券基本信息
+"""
+from futu import *
+
+quote_ctx = OpenQuoteContext(host='127.0.0.1', port=11111)
+print('******************************************')
+ret, data = quote_ctx.get_stock_basicinfo(Market.SH, SecurityType.STOCK)
+if ret == RET_OK:
+    data.to_csv('sh.csv', index=False)
+else:
+    print('error:', data)
+print('******************************************')
+ret, data = quote_ctx.get_stock_basicinfo(Market.SZ, SecurityType.STOCK)
+if ret == RET_OK:
+    data.to_csv('sz.csv', index=False)
+else:
+    print('error:', data)
+ret, data = quote_ctx.get_stock_basicinfo(Market.HK, SecurityType.STOCK)
+if ret == RET_OK:
+    data.to_csv('hk.csv', index=False)
+else:
+    print('error:', data)
+
+quote_ctx.close()  # 结束后记得关闭当条连接，防止连接条数用尽

quant1x-0.3.0/quant1x/findpeaks/__init__.py

@@ -0,0 +1,13 @@
+from quant1x.findpeaks.filters.frost import frost_filter
+from quant1x.findpeaks.filters.kuan import kuan_filter
+# Import the denosing filters
+from quant1x.findpeaks.filters.lee import lee_filter
+from quant1x.findpeaks.filters.lee_enhanced import lee_enhanced_filter
+from quant1x.findpeaks.filters.mean import mean_filter
+from quant1x.findpeaks.filters.median import median_filter
+from quant1x.findpeaks.findpeaks import findpeaks
+from quant1x.findpeaks.findpeaks import (
+    import_example,
+    stats,
+    interpolate,
+)

quant1x-0.3.0/quant1x/findpeaks/filters/frost.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2012 - 2013
+# Matías Herranz <matiasherranz@gmail.com>
+# Joaquín Tita <joaquintita@gmail.com>
+# https://github.com/PyRadar/pyradar
+#
+# 2020: Erdogan Taskesen: <erdogant@gmail.com> Converted to python3.
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+
+import numpy as np
+from scipy.stats import variation
+
+
+def compute_coef_var(image, x_start, x_end, y_start, y_end):
+    """
+    Compute coefficient of variation in a window of [x_start: x_end] and
+    [y_start:y_end] within the image.
+    """
+    if x_start < 0: raise Exception('ERROR: x_start must be >= 0.')
+    if y_start < 0: raise Exception('ERROR: y_start must be >= 0.')
+
+    x_size, y_size = image.shape
+    x_overflow = x_end > x_size
+    y_overflow = y_end > y_size
+
+    if x_overflow: raise Exception('ERROR: invalid parameters cause x window overflow.')
+    if y_overflow: raise Exception('ERROR: invalid parameters cause y window overflow.')
+
+    window = image[x_start:x_end, y_start:y_end]
+
+    coef_var = variation(window, None)
+
+    if not coef_var:  # dirty patch
+        coef_var = 0.01
+        # print "squared_coef was equal zero but replaced by %s" % coef_var
+    if coef_var <= 0: raise Exception('ERROR: coeffient of variation cannot be zero.')
+
+    return coef_var
+
+
+def calculate_all_Mi(window_flat, factor_A, window):
+    """
+    Compute all the weights of pixels in the window.
+    """
+    N, M = window.shape
+    center_pixel = np.float64(window[int(N / 2), int(M / 2)])
+    window_flat = np.float64(window_flat)
+
+    distances = np.abs(window_flat - center_pixel)
+
+    weights = np.exp(-factor_A * distances)
+
+    return weights
+
+
+def calculate_local_weight_matrix(window, factor_A):
+    """
+    Returns an array with the weights for the pixels in the given window.
+    """
+    weights_array = np.zeros(window.size)
+    window_flat = window.flatten()
+
+    weights_array = calculate_all_Mi(window_flat, factor_A, window)
+
+    return weights_array
+
+
+def frost_filter(img, damping_factor=2.0, win_size=3):
+    """Frost filter.
+    
+    Description
+    -----------
+    Apply frost filter to a numpy matrix containing the image, with a window of win_size x win_size. By default, the window size is 3x3.
+
+    Parameters
+    ----------
+    img : array-like
+        Input image.
+    damping_factor : float (default: 2.0)
+        Damping factor.
+    win_size : int, int (default: 3)
+        Window size.
+
+    Returns
+    -------
+    img_filtered : array-like
+        Filtered image.
+    
+    Examples
+    --------
+    >>> import findpeaks
+    >>> import matplotlib.pyplot as plt
+    >>> img = findpeaks.import_example('2dpeaks_image')
+    >>> # Resize
+    >>> img = findpeaks.stats.resize(img, size=(300,300))
+    >>> # Make grey image
+    >>> img = findpeaks.stats.togray(img)
+    >>> # Scale between [0-255]
+    >>> img = findpeaks.stats.scale(img)
+    >>> # frost filter
+    >>> img_filtered = findpeaks.stats.frost_filter(img.copy(), damping_factor=2, win_size=15)
+    >>>
+    >>> plt.figure()
+    >>> fig, axs = plt.subplots(1,2)
+    >>> axs[0].imshow(img, cmap='gray'); axs[0].set_title('Input')
+    >>> axs[1].imshow(img_filtered, cmap='gray'); axs[1].set_title('Frost filter')
+
+    """
+    if win_size < 3: raise Exception('[findpeaks] >ERROR: win size must be at least 3')
+    if len(img.shape) > 2: raise Exception(
+        '[findpeaks] >ERROR: Image should be 2D. Hint: set the parameter: togray=True')
+    if ((win_size % 2) == 0): print(
+        '[findpeaks] >It is highly recommended to user odd window sizes. You provided %s, an even number.' % (win_size))
+
+    img_filtered = np.zeros_like(img)
+    N, M = img.shape
+    win_offset = int(win_size / 2)
+
+    for i in np.arange(0, N):
+        xleft = i - win_offset
+        xright = i + win_offset
+        if xleft < 0:
+            xleft = 0
+        if xright >= N:
+            xright = N - 1
+        for j in np.arange(0, M):
+            yup = j - win_offset
+            ydown = j + win_offset
+            if yup < 0:
+                yup = 0
+            if ydown >= M:
+                ydown = M - 1
+
+            # inspired by http://www.pcigeomatics.com/cgi-bin/pcihlp/FFROST
+            variation_coef = compute_coef_var(img, xleft, xright, yup, ydown)
+            window = img[xleft:xright, yup:ydown]
+            window_mean = window.mean()
+            sigma_zero = variation_coef / window_mean  # var / u^2
+            factor_A = damping_factor * sigma_zero
+
+            weights_array = calculate_local_weight_matrix(window, factor_A)
+            pixels_array = window.flatten()
+
+            weighted_values = weights_array * pixels_array
+
+            new_pix_value = weighted_values.sum() / weights_array.sum()
+
+            if (new_pix_value is None) or np.isnan(new_pix_value):
+                new_pix_value = 0
+
+            img_filtered[i, j] = new_pix_value
+
+    return img_filtered

quant1x-0.3.0/quant1x/findpeaks/filters/kuan.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2012 - 2013
+# Matías Herranz <matiasherranz@gmail.com>
+# Joaquín Tita <joaquintita@gmail.com>
+# https://github.com/PyRadar/pyradar
+#
+# 2020: Erdogan Taskesen: <erdogant@gmail.com> Converted to python3.
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+
+import numpy as np
+from scipy.stats import variation
+
+
+def weighting(window, cu=0.25):
+    """
+    Computes the weighthing function for Kuan filter using cu as the noise
+    coefficient.
+    """
+    two_cu = cu * cu
+
+    ci = variation(window, None)
+    two_ci = ci * ci
+
+    if not two_ci:  # dirty patch to avoid zero division
+        two_ci = 0.01
+
+    divisor = 1.0 + two_cu
+
+    if not divisor:
+        divisor = 0.0001
+
+    if cu > ci:
+        w_t = 0.0
+    else:
+        w_t = (1.0 - (two_cu / two_ci)) / divisor
+
+    return w_t
+
+
+def kuan_filter(img, win_size=3, cu=0.25):
+    """Kuan filter.
+
+    Description
+    -----------
+    Apply kuan to a numpy matrix containing the image, with a window of win_size x win_size.
+
+    Parameters
+    ----------
+    img : array-like
+        Input image.
+    win_size : int, int (default: 3)
+        Window size.
+    cu : float (default: 0.25)
+        cu factor.
+
+    Returns
+    -------
+    img_filtered : array-like
+        Filtered image.
+
+    Examples
+    --------
+    >>> import findpeaks
+    >>> import matplotlib.pyplot as plt
+    >>> img = findpeaks.import_example('2dpeaks_image')
+    >>> # Resize
+    >>> img = findpeaks.stats.resize(img, size=(300,300))
+    >>> # Make grey image
+    >>> img = findpeaks.stats.togray(img)
+    >>> # Scale between [0-255]
+    >>> img = findpeaks.stats.scale(img)
+    >>> # Filter
+    >>> img_filtered = findpeaks.stats.kuan_filter(img.copy(), win_size=15, cu=0.25)
+    >>>
+    >>> plt.figure()
+    >>> fig, axs = plt.subplots(1,2)
+    >>> axs[0].imshow(img, cmap='gray'); axs[0].set_title('Input')
+    >>> axs[1].imshow(img_filtered, cmap='gray'); axs[1].set_title('Kuan filter')
+
+    """
+    if win_size < 3: raise Exception('[findpeaks] >ERROR: win size must be at least 3')
+    if len(img.shape) > 2: raise Exception(
+        '[findpeaks] >ERROR: Image should be 2D. Hint: set the parameter: togray=True')
+    if ((win_size % 2) == 0): print(
+        '[findpeaks] >It is highly recommended to user odd window sizes. You provided %s, an even number.' % (win_size))
+
+    # we process the entire img as float64 to avoid type overflow error
+    img = np.float64(img)
+    img_filtered = np.zeros_like(img)
+
+    N, M = img.shape
+    # win_offset = win_size / 2
+    win_offset = int(win_size / 2)
+
+    for i in np.arange(0, N):
+        xleft = i - win_offset
+        xright = i + win_offset
+
+        if xleft < 0:
+            xleft = 0
+        if xright >= N:
+            xright = N
+
+        for j in np.arange(0, M):
+            yup = j - win_offset
+            ydown = j + win_offset
+
+            if yup < 0:
+                yup = 0
+            if ydown >= M:
+                ydown = M
+
+            pix_value = img[i, j]
+            window = img[xleft:xright, yup:ydown]
+            w_t = weighting(window, cu)
+            window_mean = window.mean()
+            new_pix_value = (pix_value * w_t) + (window_mean * (1.0 - w_t))
+
+            if (new_pix_value is None) or np.isnan(new_pix_value):
+                new_pix_value = 0
+
+            img_filtered[i, j] = round(new_pix_value)
+
+    return img_filtered

quant1x-0.3.0/quant1x/findpeaks/filters/lee.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2012 - 2013
+# Matías Herranz <matiasherranz@gmail.com>
+# Joaquín Tita <joaquintita@gmail.com>
+# https://github.com/PyRadar/pyradar
+#
+# 2020: Erdogan Taskesen: <erdogant@gmail.com> Converted to python3.
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+
+import numpy as np
+
+
+def _weighting(window, cu=0.25):
+    """
+    Computes the weighthing function for Lee filter using cu as the noise
+    coefficient.
+    """
+    # cu is the noise variation coefficient
+    two_cu = cu * cu
+
+    # ci is the variation coefficient in the window
+    window_mean = window.mean()
+    window_std = window.std()
+    ci = window_std / window_mean
+
+    two_ci = ci * ci
+
+    if not two_ci:  # dirty patch to avoid zero division
+        two_ci = 0.01
+
+    if cu > ci:  # preserve the original value (I guess)
+        w_t = 0.0
+    else:  # use the filter
+        w_t = 1.0 - (two_cu / two_ci)
+
+    return w_t
+
+
+def lee_filter(img, win_size=3, cu=0.25):
+    """Lee filter.
+    
+    Description
+    -----------
+    The Additive Noise Lee Despeckling Filter.
+    Apply lee to a numpy matrix containing the image, with a window of win_size x win_size.
+    Let's assume that the despeckling noise is additive with a constant mean of zero, a constant variance, and drawn from a Gaussian distribution. Use a window (I x J pixels) to scan the image with a stride of 1 pixels (and I will use reflective boundary conditions). The despeckled value of the pixel in the center of the window located in the ith row and jth column is, zhat_ij = mu_k + W*(z_ij = mu_z), where mu_k is the mean value of all pixels in the window centered on pixel i,j, z_ij is the unfiltered value of the pixel, and W is a weight calculated as, W = var_k / (var_k + var_noise), where var_k is the variance of all pixels in the window and var_noise is the variance of the speckle noise. A possible alternative to using the actual value of the center pixel for z_ij is to use the median pixel value in the window.
+    The parameters of the filter are the window/kernel size and the variance of the noise (which is unknown but can perhaps be estimated from the image as the variance over a uniform feature smooth like the surface of still water). Using a larger window size and noise variance will increase radiometric resolution at the expense of spatial resolution.
+    For more info on the Lee Filter and other despeckling filters see http://desktop.arcgis.com/en/arcmap/10.3/manage-data/raster-and-images/speckle-function.htm
+    Assumes noise mean = 0
+    If you don't want the window to be a square of size x size, just replace uniform_filter with something else (convolution with a disk, gaussian filter, etc). Any type of (weighted) averaging filter will do, as long as it is the same for calculating both img_mean and img_square_mean.
+    The Lee filter seems rather old-fashioned as a filter. It won't behave well at edges because for any window that has an edge in it, the variance is going to be much higher than the overall image variance, and therefore the weights (of the unfiltered image relative to the filtered image) are going to be close to 1.
+
+    Parameters
+    ----------
+    img : array-like
+        Input image.
+    win_size : int, int (default: 3)
+        Window size.
+    cu : float (default: 0.25)
+        cu factor.
+
+    Returns
+    -------
+    img_filtered : array-like
+        Filtered image.
+
+    Examples
+    --------
+    >>> import findpeaks
+    >>> import matplotlib.pyplot as plt
+    >>> img = findpeaks.import_example('2dpeaks_image')
+    >>> # Resize
+    >>> img = findpeaks.stats.resize(img, size=(300,300))
+    >>> # Make grey image
+    >>> img = findpeaks.stats.togray(img)
+    >>> # Scale between [0-255]
+    >>> img = findpeaks.stats.scale(img)
+    >>> # Filter
+    >>> img_filtered = findpeaks.stats.lee_filter(img.copy(), win_size=15, cu=0.25)
+    >>>
+    >>> plt.figure()
+    >>> fig, axs = plt.subplots(1,2)
+    >>> axs[0].imshow(img, cmap='gray'); axs[0].set_title('Input')
+    >>> axs[1].imshow(img_filtered, cmap='gray'); axs[1].set_title('Lee filter')
+
+    """
+    if win_size < 3: raise Exception('[findpeaks] >ERROR: window size (win_size) must be at least 3')
+    if len(img.shape) > 2: raise Exception(
+        '[findpeaks] >ERROR: Image should be 2D. Hint: set the parameter: togray=True')
+    if ((win_size % 2) == 0): print(
+        '[findpeaks] >It is highly recommended to user odd window sizes. You provided %s, an even number.' % (win_size))
+
+    # we process the entire img as float64 to avoid type overflow error
+    img = np.float64(img)
+    img_filtered = np.zeros_like(img)
+    N, M = img.shape
+    win_offset = int(win_size / 2)
+
+    for i in np.arange(0, N):
+        xleft = i - win_offset
+        xright = i + win_offset
+
+        if xleft < 0:
+            xleft = 0
+        if xright >= N:
+            xright = N
+
+        for j in np.arange(0, M):
+            yup = j - win_offset
+            ydown = j + win_offset
+
+            if yup < 0:
+                yup = 0
+            if ydown >= M:
+                ydown = M
+
+            # assert_indices_in_range(N, M, xleft, xright, yup, ydown)
+
+            pix_value = img[i, j]
+            window = img[xleft:xright, yup:ydown]
+            w_t = _weighting(window, cu)
+            window_mean = window.mean()
+
+            new_pix_value = (pix_value * w_t) + (window_mean * (1.0 - w_t))
+
+            if new_pix_value < 0.0: raise Exception("ERROR: lee_filter(), pixel filtered can't be negative")
+            if (new_pix_value is None) or np.isnan(new_pix_value):
+                new_pix_value = 0
+
+            img_filtered[i, j] = round(new_pix_value)
+
+    return img_filtered

quant1x-0.3.0/quant1x/findpeaks/filters/lee_enhanced.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Copyright 2012 - 2013
+# Matías Herranz <matiasherranz@gmail.com>
+# Joaquín Tita <joaquintita@gmail.com>
+# https://github.com/PyRadar/pyradar
+# 
+# 2020: Erdogan Taskesen: <erdogant@gmail.com> Converted to python3.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+
+from math import exp
+
+import numpy as np
+
+K_DEFAULT = 1.0
+CU_DEFAULT = 0.523
+CMAX_DEFAULT = 1.73
+
+
+def weighting(pix_value, window, k=K_DEFAULT, cu=CU_DEFAULT, cmax=CMAX_DEFAULT):
+    """
+    Computes the weighthing function for Lee filter using cu as the noise
+    coefficient.
+    """
+
+    # cu is the noise variation coefficient
+
+    # ci is the variation coefficient in the window
+    window_mean = window.mean()
+    window_std = window.std()
+    ci = window_std / window_mean
+
+    if ci <= cu:  # use the mean value
+        w_t = 1.0
+    elif cu < ci < cmax:  # use the filter
+        w_t = exp((-k * (ci - cu)) / (cmax - ci))
+    elif ci >= cmax:  # preserve the original value
+        w_t = 0.0
+    else:  # use the mean value
+        w_t = 1.0
+
+    return w_t
+
+
+def assert_parameters(win_size, k, cu, cmax):
+    """
+    Asserts parameters in range.
+    Parameters:
+        - k: in [0:10]
+        - cu: positive
+        - cmax: positive and greater equal than cu
+    """
+
+    if 0 > k > 10: raise Exception("k parameter out of range 0<= k <= 10, submitted %s" % (k))
+    if cu < 0: raise Exception("cu can't be negative")
+    if cmax < 0 and cmax < cu: raise Exception("cmax must be positive and greater equal to cu: %s" % (cu))
+    if win_size < 3: raise Exception('ERROR: win size must be at least 3')
+
+
+def lee_enhanced_filter(img, win_size=3, k=K_DEFAULT, cu=CU_DEFAULT, cmax=CMAX_DEFAULT):
+    """Lee enhanced filter.
+
+    Description
+    -----------
+    Apply Enhanced Lee filter to a numpy matrix containing the image, with a window of win_size x win_size.
+
+    Parameters
+    ----------
+    img : array-like
+        Input image.
+    win_size : int, int (default: 3)
+        Window size.
+    cu : float (default: 0.25)
+        cu factor.
+    k : float, (default: 1.0)
+        Kvalue.
+    cmax : float, (default: 1.73)
+        cmax value.
+
+    Returns
+    -------
+    img_filtered : array-like
+        Filtered image.
+
+    Examples
+    --------
+    >>> import findpeaks
+    >>> import matplotlib.pyplot as plt
+    >>> img = findpeaks.import_example('2dpeaks_image')
+    >>> # Resize
+    >>> img = findpeaks.stats.resize(img, size=(300,300))
+    >>> # Make grey image
+    >>> img = findpeaks.stats.togray(img)
+    >>> # Scale between [0-255]
+    >>> img = findpeaks.stats.scale(img)
+    >>> # Filter
+    >>> img_filtered = findpeaks.stats.lee_enhanced_filter(img.copy(), win_size=15)
+    >>>
+    >>> plt.figure()
+    >>> fig, axs = plt.subplots(1,2)
+    >>> axs[0].imshow(img, cmap='gray'); axs[0].set_title('Input')
+    >>> axs[1].imshow(img_filtered, cmap='gray'); axs[1].set_title('Lee enhanced filter')
+
+    """
+    if win_size < 3: raise Exception('[findpeaks] >ERROR: win size must be at least 3')
+    if len(img.shape) > 2: raise Exception(
+        '[findpeaks] >ERROR: Image should be 2D. Hint: set the parameter: togray=True')
+    if ((win_size % 2) == 0): print(
+        '[findpeaks] >It is highly recommended to user odd window sizes. You provided %s, an even number.' % (win_size))
+    assert_parameters(win_size, k, cu, cmax)
+
+    # we process the entire img as float64 to avoid type overflow error
+    img = np.float64(img)
+    img_filtered = np.zeros_like(img)
+    N, M = img.shape
+    win_offset = int(win_size / 2)
+
+    for i in np.arange(0, N):
+        xleft = i - win_offset
+        xright = i + win_offset
+
+        if xleft < 0:
+            xleft = 0
+        if xright >= N:
+            xright = N
+
+        for j in np.arange(0, M):
+            yup = j - win_offset
+            ydown = j + win_offset
+
+            if yup < 0:
+                yup = 0
+            if ydown >= M:
+                ydown = M
+
+            pix_value = img[i, j]
+            window = img[xleft:xright, yup:ydown]
+            w_t = weighting(pix_value, window, k, cu, cmax)
+            window_mean = window.mean()
+
+            new_pix_value = (window_mean * w_t) + (pix_value * (1.0 - w_t))
+
+            if new_pix_value < 0.0: raise Exception("ERROR: lee_filter(), pixel filtered can't be negative")
+            if (new_pix_value is None) or np.isnan(new_pix_value):
+                new_pix_value = 0
+
+            img_filtered[i, j] = round(new_pix_value)
+
+    return img_filtered