test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[40 21 11]\n",
      " [43 10 33]\n",
      " [43 37  0]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Dimensions of the image\n",
    "image_height = 3\n",
    "image_width = 3\n",
    "\n",
    "# Generate a random grayscale image\n",
    "random_image = np.random.randint(0, 50, size=(image_height, image_width), dtype=np.uint8)\n",
    "print(random_image)\n",
    "\n",
    "# Display the random image using matplotlib\n",
    "plt.imshow(random_image, cmap='gray', vmin=0, vmax=255)\n",
    "plt.title('Random Grayscale Image')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num of pixels: 9\n"
     ]
    }
   ],
   "source": [
    "numOfPixels = random_image.size\n",
    "print(f\"num of pixels: {numOfPixels}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "noise amount: 4\n"
     ]
    }
   ],
   "source": [
    "noiseAmount = int(numOfPixels * 0.5)\n",
    "print(f\"noise amount: {noiseAmount}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salt: 1\n"
     ]
    }
   ],
   "source": [
    "numOfSaltPixel = int(numOfPixels * 0.20)\n",
    "print(f\"salt: {numOfSaltPixel}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "salt: 2\n"
     ]
    }
   ],
   "source": [
    "numOfPepperPixel = int(numOfPixels * 0.30)\n",
    "print(f\"salt: {numOfPepperPixel}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cordinate: (2, 0)\n"
     ]
    }
   ],
   "source": [
    "xCor, yCor = np.random.randint(0, (random_image.shape[0], random_image.shape[1]))\n",
    "print(f\"Cordinate: {xCor, yCor}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "print(random_image.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apply_average_filter(image, kernel_size):\n",
    "    \"\"\"Applies an average filter to an image.\"\"\"\n",
    "\n",
    "    pad_size = kernel_size // 2\n",
    "    print(f\"pad: {pad_size}\")\n",
    "    padded_image = np.pad(image, (pad_size, pad_size), mode='constant')\n",
    "    print(f\"padded imagae: {padded_image}\")\n",
    "    filtered_image = np.zeros_like(image)\n",
    "\n",
    "    for i in range(image.shape[0]):\n",
    "        for j in range(image.shape[1]):\n",
    "            kernel_region = padded_image[i:i+kernel_size, j:j+kernel_size]\n",
    "            print(f\"karnel region: {kernel_region}\")\n",
    "            average = np.mean(kernel_region)\n",
    "            print(f\"average: {average}\")\n",
    "            filtered_image[i, j] = average\n",
    "\n",
    "    return filtered_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pad: 1\n",
      "padded imagae: [[ 0  0  0  0  0]\n",
      " [ 0 40 21 11  0]\n",
      " [ 0 43 10 33  0]\n",
      " [ 0 43 37  0  0]\n",
      " [ 0  0  0  0  0]]\n",
      "karnel region: [[ 0  0]\n",
      " [ 0 40]]\n",
      "average: 10.0\n",
      "karnel region: [[ 0  0]\n",
      " [40 21]]\n",
      "average: 15.25\n",
      "karnel region: [[ 0  0]\n",
      " [21 11]]\n",
      "average: 8.0\n",
      "karnel region: [[ 0 40]\n",
      " [ 0 43]]\n",
      "average: 20.75\n",
      "karnel region: [[40 21]\n",
      " [43 10]]\n",
      "average: 28.5\n",
      "karnel region: [[21 11]\n",
      " [10 33]]\n",
      "average: 18.75\n",
      "karnel region: [[ 0 43]\n",
      " [ 0 43]]\n",
      "average: 21.5\n",
      "karnel region: [[43 10]\n",
      " [43 37]]\n",
      "average: 33.25\n",
      "karnel region: [[10 33]\n",
      " [37  0]]\n",
      "average: 20.0\n",
      "filtered_image: [[10 15  8]\n",
      " [20 28 18]\n",
      " [21 33 20]]\n",
      "original image: [[40 21 11]\n",
      " [43 10 33]\n",
      " [43 37  0]]\n"
     ]
    }
   ],
   "source": [
    "filtered_image = apply_average_filter(random_image, 2)\n",
    "print(f\"filtered_image: {filtered_image}\")\n",
    "print(f\"original image: {random_image}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = np.array([\n",
    "    [1, 2, 3],\n",
    "    [4, 5, 6],\n",
    "    [7, 8, 9]\n",
    "], dtype=np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "padded image [[0 0 0 0 0]\n",
      " [0 1 2 3 0]\n",
      " [0 4 5 6 0]\n",
      " [0 7 8 9 0]\n",
      " [0 0 0 0 0]]\n",
      "window: [[0 0 0]\n",
      " [0 1 2]\n",
      " [0 4 5]]\n",
      "window: [[0 0 0]\n",
      " [1 2 3]\n",
      " [4 5 6]]\n",
      "window: [[0 0 0]\n",
      " [2 3 0]\n",
      " [5 6 0]]\n",
      "window: [[0 1 2]\n",
      " [0 4 5]\n",
      " [0 7 8]]\n",
      "window: [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "window: [[2 3 0]\n",
      " [5 6 0]\n",
      " [8 9 0]]\n",
      "window: [[0 4 5]\n",
      " [0 7 8]\n",
      " [0 0 0]]\n",
      "window: [[4 5 6]\n",
      " [7 8 9]\n",
      " [0 0 0]]\n",
      "window: [[5 6 0]\n",
      " [8 9 0]\n",
      " [0 0 0]]\n",
      "hermonicMean: [[2 1 3]\n",
      " [1 1 2]\n",
      " [5 4 6]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Fahim Ahammed Firoz\\AppData\\Local\\Temp\\ipykernel_6708\\1882059399.py:17: RuntimeWarning: divide by zero encountered in divide\n",
      "  pixel += 0 if np.isinf(1/window[r, k]) else 1/window[r, k]\n"
     ]
    }
   ],
   "source": [
    "def hermonicMean(image, kernelSize = 2):\n",
    "    filteredImage  = np.zeros_like(image)\n",
    "    padSize = kernelSize // 2\n",
    "    paddedImage = np.pad(image, (padSize, padSize), mode='constant')\n",
    "    print(f\"padded image {paddedImage}\")\n",
    "\n",
    "    for i in range (padSize, image.shape[0] + padSize):\n",
    "        for j in range(padSize, image.shape[1] + padSize):\n",
    "            window = paddedImage[i - padSize: i+padSize+1, j - padSize: j+padSize+1]\n",
    "\n",
    "            print(f\"window: {window}\")\n",
    "\n",
    "            pixel = 0\n",
    "\n",
    "            for r in range(window.shape[0]):\n",
    "                for k in range(window.shape[1]):\n",
    "                    pixel += 0 if np.isinf(1/window[r, k]) else 1/window[r, k]\n",
    "\n",
    "            pixel = 0 if pixel == 0 else (kernelSize ** 2 / pixel)\n",
    "\n",
    "            if pixel > 255:\n",
    "                pixel = 255\n",
    "\n",
    "            filteredImage[i-padSize, j-padSize]= pixel\n",
    "    return filteredImage\n",
    "print(f\"hermonicMean: {hermonicMean(image)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hermonicMean: [[172 108 216]\n",
      " [100  70 123]\n",
      " [117  96 187]]\n"
     ]
    }
   ],
   "source": [
    "def apply_harmonic_mean_filter2(image, mask_size):\n",
    "    filtered_image = image.copy()\n",
    "    height, width = filtered_image.shape \n",
    "    offset, number_of_pixel = mask_size // 2, mask_size * mask_size\n",
    "\n",
    "    for r in range(height):\n",
    "        for c in range(width):\n",
    "            pixel = 0\n",
    "            for x in range(-offset, offset + 1):\n",
    "                for y in range(-offset, offset + 1):\n",
    "                    if (r + x >= 0 and r + x < height and c + y >= 0 and c + y < width):\n",
    "                        pixel += float(1 / (image[r + x, c + y] + 1e-4))\n",
    "            pixel = number_of_pixel / pixel\n",
    "            filtered_image[r, c] = 255 if pixel > 255 else pixel\n",
    "\n",
    "    return np.uint8(filtered_image)\n",
    "\n",
    "harmonic_filtered = apply_harmonic_mean_filter2(image, 3)  # Adjust filter_size as needed\n",
    "print(f\"hermonicMean: {harmonic_filtered}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hermonicMean: [[ 2  5  3]\n",
      " [ 6 24 10]\n",
      " [ 5 15  6]]\n"
     ]
    }
   ],
   "source": [
    "def geoMetricMean(image, kernelSize = 2):\n",
    "    filteredImage  = np.zeros_like(image)\n",
    "    padSize = kernelSize // 2\n",
    "    paddedImage = np.pad(image, (padSize, padSize), mode='constant')\n",
    "\n",
    "    for i in range (padSize, image.shape[0] + padSize):\n",
    "        for j in range(padSize, image.shape[1] + padSize):\n",
    "            window = paddedImage[i - padSize: i+padSize+1, j - padSize: j+padSize+1]\n",
    "\n",
    "            pixel = 1\n",
    "            # Calculate the product of pixel values in the window\n",
    "            for r in range(window.shape[0]):\n",
    "                for k in range(window.shape[1]):\n",
    "                    pixel = pixel * int(window[r, k])\n",
    "\n",
    "            pixel = pixel ** (1/(kernelSize ** 2)) # Take the geometric mean by raising the product to the power of (1 / (kernelSize^2))\n",
    "\n",
    "            if pixel > 255:\n",
    "                pixel = 255\n",
    "\n",
    "            filteredImage[i-padSize, j-padSize]= pixel\n",
    "    return filteredImage\n",
    "print(f\"hermonicMean: {geoMetricMean(image)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "module 'cv2' has no attribute 'hstack'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[2], line 24\u001b[0m\n\u001b[0;32m     22\u001b[0m original_half \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mresize(image, (image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m, image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m))\n\u001b[0;32m     23\u001b[0m modified_half \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mresize(binary_image \u001b[38;5;28;01mif\u001b[39;00m new_bpp \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m image, (image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m, image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m))\n\u001b[1;32m---> 24\u001b[0m combined_image \u001b[38;5;241m=\u001b[39m \u001b[43mcv2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhstack\u001b[49m([original_half, modified_half])\n\u001b[0;32m     26\u001b[0m \u001b[38;5;66;03m# Show the combined image\u001b[39;00m\n\u001b[0;32m     27\u001b[0m cv2\u001b[38;5;241m.\u001b[39mimshow(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOriginal vs. Modified\u001b[39m\u001b[38;5;124m\"\u001b[39m, combined_image)\n",
      "\u001b[1;31mAttributeError\u001b[0m: module 'cv2' has no attribute 'hstack'"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "\n",
    "# Load the image\n",
    "image = cv2.imread(\"./photos/Rose-1024x1024.tif\")\n",
    "\n",
    "# Get the current number of bits per pixel\n",
    "bpp = image.dtype.itemsize * 8\n",
    "\n",
    "# Calculate the new number of bits per pixel\n",
    "new_bpp = bpp - 1\n",
    "\n",
    "# Check if the new bpp is binary (1 bit)\n",
    "if new_bpp == 1:\n",
    "    # Convert the image to binary using thresholding\n",
    "    threshold, binary_image = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)\n",
    "else:\n",
    "    # Reduce the intensity levels by one bit\n",
    "    mask = 2 ** (bpp - new_bpp) - 1\n",
    "    image = cv2.bitwise_and(image, mask)\n",
    "\n",
    "# Display the original and modified images side-by-side\n",
    "original_half = cv2.resize(image, (image.shape[1] // 2, image.shape[0] // 2))\n",
    "modified_half = cv2.resize(binary_image if new_bpp == 1 else image, (image.shape[1] // 2, image.shape[0] // 2))\n",
    "combined_image = cv2.hstack([original_half, modified_half])\n",
    "\n",
    "# Show the combined image\n",
    "cv2.imshow(\"Original vs. Modified\", combined_image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}