pixrr 0.1.0__tar.gz

pixrr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) <2025> <Hrishikesh Tiwari>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pixrr-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: pixrr
+Version: 0.1.0
+Summary: A lightweight image processing toolkit for Python
+Author-email: Hrishikesh Tiwari <tiwarihrishikesh686@gmail.com>
+License: MIT License
+        
+        Copyright (c) <2025> <Hrishikesh Tiwari>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/Hrishi11572/pixrr
+Project-URL: Documentation, https://github.com/Hrishi11572/pixrr/tree/main/docs
+Keywords: image-processing,computer-vision,education,filters,numpy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.3.5
+Requires-Dist: scipy>=1.16.3
+Requires-Dist: matplotlib>=3.10.7
+Requires-Dist: pillow>=12.0.0
+Requires-Dist: numba>=0.63.1
+Dynamic: license-file
+
+# **pixrr : A lightweight image processing toolkit for python**
+
+`pixrr` is a lightweight, beginner-friendly image processing library built for fast experimentation and teaching.
+It focuses on simplicity, clean function names, and easy-to-understand code, making it useful both for quick image tasks and for pedagogical environments such as introductory image processing courses.
+
+---
+
+##  Features (Planned & Implemented)
+
+### **Core Utilities**
+
+* Convert color images to grayscale and binary
+* Basic I/O helpers (read, write, display)
+* Plot and analyze histograms
+* Image thresholding
+* Image Cropping and Rotation (planned)
+
+### **Filtering & Enhancement**
+
+* Convolution using masks
+* Convolution using FFT (planned)
+* Contrast enhancement
+* Histogram equalization
+* Smoothing filters (Gaussian, median, weighted median)
+* Sharpening and Laplacian operators
+
+### **Edge and Gradient Detection**
+
+* Prewitt and Sobel (horizontal & vertical)
+* Second-order derivatives
+* Canny edge detector (planned)
+
+### **Segmentation & Classification**
+
+* Otsu thresholding 
+* K-means clustering for image segmentation
+* Mean-Shift clustering (planned)
+* EM/Bayesian pixel classification (planned)
+
+---
+
+## Project Roadmap
+
+| Stage  | Goal                                                    |
+| ------ | ------------------------------------------------------- |
+| Part 1 | Basic conversions, contour extraction, histogram tools  |
+| Part 2 | Convolution, enhancement techniques, gradient operators |
+| Part 3 | Automatic segmentation & clustering                     |
+| Part 4 | Advanced edge detection and EM classification           |
+
+---
+
+## Installation (when it’s live)
+
+```bash
+pip install pixrr
+```
+
+*(Currently under development. Not on PyPI yet.)*
+
+---
+
+## Usage Example
+
+```python
+import pixrr as pix
+
+# Example 
+img = pix.handle_image("peda_img/test_images/test2.png")
+grey = pix.convert_to_gray(img)
+# Applying gaussian
+pix.show_image(pix.gaussian_smoothing(grey, kernel_size=3))
+```
+
+---
+
+## Contribution
+
+This library is early-stage but open to improvements, bug reports, and algorithm implementations.
+Ideal for students learning image processing or developers wanting simple utilities without heavy dependencies.
+
+---
+

pixrr-0.1.0/README.md

@@ -0,0 +1,83 @@
+# **pixrr : A lightweight image processing toolkit for python**
+
+`pixrr` is a lightweight, beginner-friendly image processing library built for fast experimentation and teaching.
+It focuses on simplicity, clean function names, and easy-to-understand code, making it useful both for quick image tasks and for pedagogical environments such as introductory image processing courses.
+
+---
+
+##  Features (Planned & Implemented)
+
+### **Core Utilities**
+
+* Convert color images to grayscale and binary
+* Basic I/O helpers (read, write, display)
+* Plot and analyze histograms
+* Image thresholding
+* Image Cropping and Rotation (planned)
+
+### **Filtering & Enhancement**
+
+* Convolution using masks
+* Convolution using FFT (planned)
+* Contrast enhancement
+* Histogram equalization
+* Smoothing filters (Gaussian, median, weighted median)
+* Sharpening and Laplacian operators
+
+### **Edge and Gradient Detection**
+
+* Prewitt and Sobel (horizontal & vertical)
+* Second-order derivatives
+* Canny edge detector (planned)
+
+### **Segmentation & Classification**
+
+* Otsu thresholding 
+* K-means clustering for image segmentation
+* Mean-Shift clustering (planned)
+* EM/Bayesian pixel classification (planned)
+
+---
+
+## Project Roadmap
+
+| Stage  | Goal                                                    |
+| ------ | ------------------------------------------------------- |
+| Part 1 | Basic conversions, contour extraction, histogram tools  |
+| Part 2 | Convolution, enhancement techniques, gradient operators |
+| Part 3 | Automatic segmentation & clustering                     |
+| Part 4 | Advanced edge detection and EM classification           |
+
+---
+
+## Installation (when it’s live)
+
+```bash
+pip install pixrr
+```
+
+*(Currently under development. Not on PyPI yet.)*
+
+---
+
+## Usage Example
+
+```python
+import pixrr as pix
+
+# Example 
+img = pix.handle_image("peda_img/test_images/test2.png")
+grey = pix.convert_to_gray(img)
+# Applying gaussian
+pix.show_image(pix.gaussian_smoothing(grey, kernel_size=3))
+```
+
+---
+
+## Contribution
+
+This library is early-stage but open to improvements, bug reports, and algorithm implementations.
+Ideal for students learning image processing or developers wanting simple utilities without heavy dependencies.
+
+---
+

pixrr-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "pixrr"
+version = "0.1.0"
+description = "A lightweight image processing toolkit for Python"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [
+    { name = "Hrishikesh Tiwari", email = "tiwarihrishikesh686@gmail.com" }
+]
+
+requires-python = ">=3.9"
+
+dependencies = [
+    "numpy>=2.3.5",
+    "scipy>=1.16.3",
+    "matplotlib>=3.10.7",
+    "pillow>=12.0.0",
+    "numba>=0.63.1"
+]
+
+keywords = ["image-processing", "computer-vision", "education", "filters", "numpy"]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Intended Audience :: Education",
+]
+
+
+[project.urls]
+"Homepage" = "https://github.com/Hrishi11572/pixrr"
+"Documentation" = "https://github.com/Hrishi11572/pixrr/tree/main/docs"
+

pixrr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pixrr-0.1.0/src/pixrr/__init__.py

@@ -0,0 +1,40 @@
+# pixrr/__init__.py
+
+from .edges import gradient_prewitt, gradient_sobel, contour_extractor
+from .enhance import linear_contrast_enhancement, histogram_equalization
+from .filters import padd_image, conv2D, laplacian, sharpen_image, gaussian_filter, gaussian_smoothing
+from .io import handle_image, convert_to_gray, show_image, save_image, plot_img_hist
+from .threshold import threshold_image, otsu_thresholding
+from .segmentation import kmeans_segmentation
+from .utils import crop_image
+
+# 2. DEFINING EXPORTS
+# This list controls what happens if someone types "from peda_img import *"
+# It also cleans up the namespace so IDEs know what is public.
+
+__all__ = [
+    'gradient_prewitt',
+    'gradient_sobel',
+    'contour_extractor',
+    'linear_contrast_enhancement',
+    'histogram_equalization',
+    'padd_image',
+    'conv2D',
+    'laplacian',
+    'sharpen_image',
+    'gaussian_filter',
+    'gaussian_smoothing',
+    'handle_image',
+    'convert_to_gray',
+    'show_image',
+    'save_image',
+    'plot_img_hist',
+    'threshold_image',
+    'kmeans_segmentation',
+    'otsu_thresholding',
+    'crop_image'
+]
+
+# Optional: Library Metadata
+__version__ = "0.1.0"
+__author__ = "Hrishikesh Tiwari"

pixrr-0.1.0/src/pixrr/edges.py

@@ -0,0 +1,205 @@
+import numpy as np 
+import matplotlib.pyplot as plt 
+from .io import convert_to_gray
+from .filters import conv2D
+import os 
+
+def gradient_prewitt(img: np.ndarray,
+                     kernel_size : int = 3,
+                     direction: str = "both",
+                     hstep: int = 1,
+                     vstep :int = 1) -> np.ndarray : 
+    '''
+    Docstring for gradient_prewitt 
+    
+    :param img : input the image as a numpy array 
+    :type img : np.ndarray 
+    :param kernel_size : the size of the kernel, should be always odd
+    :type kernel_size : int (default = 3)
+    :param direction : in which direction you want to use the kernel : "both", "h", "v"
+    :type direction : str (Default = "both") 
+    :param hstep : horizontal stride 
+    :type hstep : int (Default = 1)
+    :param vstep : vertical stride 
+    :type vstep : int (Default = 1)
+    :return: the convolved image, as numpy array 
+    :rtype: ndarray[_AnyShape, dtype[Any]]
+    '''
+    
+    if img.ndim == 3: 
+        img = convert_to_gray(img)
+    
+    if kernel_size % 2 == 0: 
+        raise ValueError("Mask should be of the following form (odd, odd)")
+    
+    # create the prewitt kernel of the given size 
+    prewitt_horizontal = np.zeros((kernel_size, kernel_size-2))
+    prewitt_horizontal = np.hstack((prewitt_horizontal, np.full((kernel_size,1), -1)))
+    prewitt_horizontal = np.hstack((prewitt_horizontal[:,::-1], np.full((kernel_size,1), fill_value=1))) 
+
+    prewitt_vertical = prewitt_horizontal.T[::-1,:] 
+    
+    if direction == "h": 
+        horizontal_gradient = conv2D(img, prewitt_horizontal, hstep , vstep)
+        return horizontal_gradient
+    
+    elif direction == "v": 
+        vertical_gradient = conv2D(img, prewitt_vertical, hstep, vstep)
+        return vertical_gradient
+    
+    elif direction == "both": 
+        horizontal_gradient = conv2D(img, prewitt_horizontal, hstep, vstep)
+        vertical_gradient = conv2D(img, prewitt_vertical, hstep, vstep)
+        grad= np.sqrt(horizontal_gradient **2 + vertical_gradient **2)
+        grad = (grad / grad.max() * 255)
+        return grad.astype(np.uint8)
+    
+
+
+def gradient_sobel(img: np.ndarray,
+                   kernel_size : int = 3,
+                   direction: str = "both",
+                   hstep: int = 1,
+                   vstep :int = 1) -> np.ndarray : 
+    '''
+    Docstring for gradient_sobel  
+    
+    :param img : input the image as a numpy array 
+    :type img : np.ndarray 
+    :param kernel_size : the size of the kernel, should be always odd
+    :type kernel_size : int (default = 3)
+    :param direction : the direction where you want to use the kernel : "both", "h" , "v"
+    :type direction : str (Default = "both")
+    :param hstep : horizontal stride 
+    :type hstep : int (Default = 1)
+    :param vstep : vertical stride 
+    :type vstep : int (Default = 1)
+    :return: the convolved image, as numpy array 
+    :rtype: ndarray[_AnyShape, dtype[Any]]
+    '''
+    if img.ndim == 3: 
+        img = convert_to_gray(img)
+    
+    if kernel_size % 2 == 0: 
+        raise ValueError("Mask should be of the following form (odd, odd)")
+    
+    # create the prewitt kernel of the given size 
+    def get_sobel_kernels(size: int):
+        if size % 2 == 0 or size < 3:
+            raise ValueError("Size must be odd and at least 3")
+
+        # 1. Generate Pascal's Triangle row for smoothing
+        def get_pascal_row(n):
+            row = [1]
+            for k in range(n):
+                row.append(row[k] * (n - k) // (k + 1))
+            return np.array(row, dtype=np.float32)
+
+        # Smoothing vector (s)
+        s = get_pascal_row(size - 1)
+        
+        # Derivative vector (d) 
+        # Logic: difference of the Pascal row one degree smaller
+        d_prev = get_pascal_row(size - 2)
+        d = np.zeros(size)
+        d[:-1] += d_prev
+        d[1:] -= d_prev
+
+        # 2. Create Kernels using Outer Product
+        # Gx (Horizontal) detects vertical edges
+        sobel_x = np.outer(s, d)
+        
+        # Gy (Vertical) detects horizontal edges
+        sobel_y = np.outer(d, s)
+        
+        return sobel_x, sobel_y
+    
+    sobel_horizontal, sobel_vertical = get_sobel_kernels(kernel_size)
+    
+    if direction == "h": 
+        horizontal_gradient = conv2D(img, sobel_horizontal, hstep , vstep)
+        return horizontal_gradient
+    
+    elif direction == "v": 
+        vertical_gradient = conv2D(img, sobel_vertical, hstep, vstep)
+        return vertical_gradient
+    
+    elif direction == "both": 
+        horizontal_gradient = conv2D(img, sobel_horizontal, hstep, vstep)
+        vertical_gradient = conv2D(img, sobel_vertical, hstep, vstep)
+        grad= np.sqrt(horizontal_gradient **2 + vertical_gradient **2)
+        grad = (grad / grad.max() * 255)
+        return grad.astype(np.uint8)
+       
+       
+def contour_extractor(img : np.ndarray = None,
+                      save : bool = False,
+                      directory : str = None, 
+                      filename : str | None = "default.png")->np.ndarray:
+    '''
+    Docstring for contour_extractor : 
+    
+    extract the contour of the thresholded image, where interior is white and background is black 
+        
+    :param img: image as np.ndarray 
+    :type img: np.ndarray
+    :param save : boolean variable, asking whether you want to save the output image 
+    :type save : bool 
+    :param directory : the path where you want to save the image 
+    :type directory : str (Default = None)
+    :return: contour image 
+    :rtype: ndarray[_AnyShape, dtype[Any]]
+    '''
+    
+    if img.ndim == 3: 
+        raise ValueError("Please enter a binary image only")
+    
+    dx = [-1,-1,0,1,1,1,0,-1]
+    dy = [0,-1,-1,-1,0,1,1,1]
+    
+    height, width = img.shape
+    padded_arr = np.pad(img, pad_width=1, mode='constant', constant_values=255)
+    has_zero_neighbor = np.zeros((height, width), dtype=bool)
+    
+    for k in range(8):
+        r_start = 1 + dx[k]
+        r_end   = 1 + dx[k] + height
+        c_start = 1 + dy[k]
+        c_end   = 1 + dy[k] + width
+        
+        neighbor_view = padded_arr[r_start:r_end, c_start:c_end]
+        has_zero_neighbor |= (neighbor_view == 0)
+    
+    contour_mask = (img == 255) & has_zero_neighbor
+    contour = np.argwhere(contour_mask)
+    contour_list = [tuple(x) for x in contour]
+    
+    '''Display the contour and save it, if asked'''
+    
+    fig, ax = plt.subplots()
+    ax.imshow(img, cmap="gray")
+    row, col = zip(*contour_list)
+    ax.scatter(col, row, s=2, c="red")
+    ax.axis("off")
+    plt.show()
+    
+    
+    contour_img = np.zeros((img.shape[0], img.shape[1]),dtype=np.uint8); 
+    for (i, j) in contour_list: 
+        contour_img[i, j] = 255
+
+    if save:
+        # creating new gray scale figure for saving 
+        fig2, ax2 = plt.subplots()
+        ax2.imshow(contour_img, cmap="gray")
+        ax2.axis("off")
+        
+        if directory is None or not os.path.exists(directory) : 
+            directory = os.getcwd()
+        
+        file_path = os.path.join(directory, filename)
+        
+        fig2.savefig(file_path, dpi=600, bbox_inches="tight", pad_inches=0)
+        plt.close(fig2)
+
+    return contour_img

pixrr-0.1.0/src/pixrr/enhance.py

@@ -0,0 +1,178 @@
+import numpy as np 
+import matplotlib.pyplot as plt 
+from .io import convert_to_gray
+import os 
+
+def linear_contrast_enhancement(img : np.ndarray,
+                                low: int = 0,
+                                high : int = 255 ,
+                                directory: str | None = None, 
+                                save : bool = False,
+                                filename : str | None = None)->np.ndarray:
+    
+    '''
+    Docstring for linear_contrast_enhancement 
+    
+    :param img : the input image as a numpy array 
+    :type img : np.ndarray 
+    :param low : the lowest intensity value 
+    :type low : int 
+    :param high : the highest intensity value 
+    :type high : int 
+    :param save : whether to save the resulting image or not 
+    :type save : bool
+    :param directory : the path where you want to save the image 
+    :type directory : str | None  
+    :param filename : the name with which the image would be saved 
+    :type filename : str 
+    '''
+    
+    if img.ndim == 3: 
+         # convert colored to gray scale 
+         img = convert_to_gray(img)
+    
+    if max(low, high) > 255 or min(low, high) < 0: 
+        raise ValueError("{low} and {high} should be between 0 and 255")
+    
+    new_img = np.asarray(img)
+    
+    min_intensity = img.min()
+    max_intensity = img.max()
+    
+    print(f"Min intensity in original image : {min_intensity}")
+    print(f"Max intensity in original image : {max_intensity}")
+    
+    # Edge case (Zero denominator)
+    if max_intensity == min_intensity:
+        return np.full_like(img, low, dtype=np.uint8)
+
+    new_img = ((high - low)/(max_intensity - min_intensity)) * (img - min_intensity) + low
+    new_img = new_img.astype(np.uint8)
+    
+    fig, ax = plt.subplot_mosaic([
+        ['original', 'enhanced']
+    ], figsize=(7, 3.5))
+
+    ax["original"].imshow(img, cmap="gray")
+    ax["original"].axis("off")
+    ax["original"].set_title("Original Image")
+    
+    ax["enhanced"].imshow(new_img, cmap="gray")
+    ax["enhanced"].axis("off")
+    ax["enhanced"].set_title("Enhanced Image")
+    plt.show()
+    
+    if save: 
+        # 1. Create a new figure and axes for saving
+        fig2, ax2 = plt.subplots()
+        
+        # 2. Draw the new image onto the *saving* axes
+        ax2.imshow(new_img, cmap="gray")
+        
+        # 3. Configure the axes
+        ax2.axis("off")
+        
+        HIGH_RES_DPI = 600
+        
+        if directory is None or not os.path.exists(directory) : 
+            directory = os.getcwd()
+        
+        file_path = os.path.join(directory, filename)
+        
+        # **The key line for high resolution is here:**
+        fig2.savefig(
+            file_path, 
+            dpi=HIGH_RES_DPI,              # Sets the resolution
+            bbox_inches="tight",           # Crops unnecessary white space
+            pad_inches=0                   # Removes padding
+        )            
+        plt.close(fig2)
+    
+    return new_img
+
+
+
+def histogram_equalization(img : np.ndarray,
+                           low: int = 0,
+                           high : int  = 255,
+                           save : bool = False,
+                           directory : str | None = None, 
+                           filename : str | None = None)->np.ndarray: 
+     
+    '''
+    Docstring for histogram_equalization 
+    
+    :param img : the input image as a numpy array 
+    :type img : np.ndarray 
+    :param low : the lowest intensity value 
+    :type low : int 
+    :param high : the highest intensity value 
+    :type high : int 
+    :param save : whether to save the resulting image or not 
+    :type save : bool
+    :param directory : the path where you want to save the image 
+    :type directory : str | None  
+    :param filename : the name with which the image would be saved 
+    :type filename : str 
+    
+    '''
+    
+    # convert to gray scale if necessary 
+    if img.ndim == 3: 
+        img = convert_to_gray(img)
+    
+    if not (0 <= low < high <= 255):
+        raise ValueError(f"{low} and {high} must satisfy 0 <= low < high <= 255")
+
+    hist , _ = np.histogram(img, bins=256, range=(0,256))
+    hist = hist/hist.sum()
+    
+    cdf_original = np.cumsum(hist)
+    
+    new_img = np.round(cdf_original[img] * (high - low) + low).astype(np.uint8)
+
+    # display the enhanced image 
+    fig, ax = plt.subplot_mosaic([
+        ['original', 'enhanced']
+    ], figsize=(7, 3.5))
+
+    ax["original"].imshow(img, cmap="gray")
+    ax["original"].axis("off")
+    ax["original"].set_title("Original Image")
+    
+    
+    ax["enhanced"].imshow(new_img, cmap="gray")
+    ax["enhanced"].axis("off")
+    ax["enhanced"].set_title("Enhanced Image")
+    plt.show()
+    plt.close(fig)
+
+    # save the new image if asked to do so 
+    if save: 
+        
+        # 1. Create a new figure and axes for saving
+        fig2, ax2 = plt.subplots()
+        
+        # 2. Draw the new image onto the *saving* axes
+        ax2.imshow(new_img, cmap="gray")
+        
+        # 3. Configure the axes
+        ax2.axis("off")
+        
+        HIGH_RES_DPI = 600
+
+        if directory is None or not os.path.exists(directory) : 
+            directory = os.getcwd()
+        
+        file_path = os.path.join(directory, filename)
+
+        # **The key line for high resolution is here:**
+        fig2.savefig(
+            file_path, 
+            dpi=HIGH_RES_DPI,              # Sets the resolution
+            bbox_inches="tight",           # Crops unnecessary white space
+            pad_inches=0                   # Removes padding
+        )            
+        plt.close(fig2)
+    
+    return new_img