attack_cases-2DEMBEdd.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c187ff35",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import numpy as np\n",
    "import threading\n",
    "import pywt\n",
    "import scipy.fftpack\n",
    "import queue\n",
    "from queue import Queue\n",
    "channel = 0 #0:blue/y,1:green/cg,2:red/co\n",
    "\n",
    "\n",
    "images_DIR=\"embedded\\\\\"\n",
    "def get_image_names(folder_path):\n",
    "    image_names = []\n",
    "    for filename in os.listdir(folder_path):\n",
    "        image_names.append(filename)\n",
    "    return image_names\n",
    "image_names = get_image_names(images_DIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d247a32b-f589-4bb8-9881-4b3f280ff43c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_middle_portion(A, m, n, x, y):\n",
    " \n",
    "\n",
    "  if x > m or y > n:\n",
    "    raise ValueError(\"x and y must be less than or equal to the corresponding dimensions of the matrix.\")\n",
    "\n",
    "  # Calculate the starting indices for the middle portion.\n",
    "  start_row = (m - x) // 2\n",
    "  start_col = (n - y) // 2\n",
    "\n",
    "  # Extract the middle portion.\n",
    "  return A[start_row:start_row+x, start_col:start_col+y]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c26592db",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def deconcatenate_2d_to_color_image(matrix, dims):\n",
    "\n",
    "  # Reshape the matrix back into a 3D matrix.\n",
    "  image = np.reshape(matrix, dims)\n",
    "\n",
    "  # Return the deconcatenated image.\n",
    "  return image\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b5344ed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rgb_to_ycbcr_lossless(img_bgr):\n",
    "  matrix = np.array([[0.299, 0.587, 0.114],[-0.168736, -0.331264, 0.5],[0.5, -0.418688, -0.081312]], dtype=np.float64)\n",
    "  img_ycrcb = np.dot(img_bgr, matrix.T)\n",
    "  if (channel == 0):\n",
    "      return img_ycrcb\n",
    " \n",
    "  return img_bgr\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c62a930a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def row_even_odd_split(array):\n",
    "    \n",
    "  even_array = array[::2, :]\n",
    "  odd_array = array[1::2, :]\n",
    "  return even_array, odd_array\n",
    "\n",
    "def column_even_odd_split(array):\n",
    "\n",
    "  even_array = array[:, ::2]\n",
    "  odd_array = array[:, 1::2]\n",
    "  return even_array, odd_array\n",
    "\n",
    "\n",
    "\n",
    "def even_odd_split(matrix):\n",
    "    flag = False\n",
    "    last_elements = None\n",
    "    if matrix.shape[0]>=matrix.shape[1]:#if row length > column length a or square matrix\n",
    "        flag = True\n",
    "        if matrix.shape[0]%2 != 0:\n",
    "            last_elements = matrix[-1, :]\n",
    "            matrix = matrix[:-1, :]\n",
    "        even, odd = row_even_odd_split(matrix)              \n",
    "    else:\n",
    "        print(matrix.shape) #if row length < column length a\n",
    "        if matrix.shape[1]%2 != 0:\n",
    "            last_elements = matrix[:, -1]\n",
    "            matrix = matrix[:, :-1]\n",
    "        even, odd = column_even_odd_split(matrix)\n",
    "        print(matrix.shape)\n",
    "\n",
    "    return even, odd, flag, last_elements\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6d345a1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def recover_watermark(A,shape,alpha=0.1):#recover_watermark(A, rowW, colW, alpha=0.1):\n",
    "    alpha = np.float64(alpha)\n",
    "    two = np.float64(2.)\n",
    "    \n",
    "    Wrow = shape[0]\n",
    "    Wcol = shape[1] * shape[2]\n",
    "    \n",
    "    evenw, oddw, flag, last= even_odd_split(A)\n",
    "    \n",
    " \n",
    "\n",
    "    roweven, coleven = evenw.shape\n",
    "    \n",
    "    \n",
    "    ZZeven = extract_middle_portion(evenw.copy(), roweven, coleven, Wrow, Wcol)\n",
    "    ZZodd = extract_middle_portion(oddw.copy(), roweven, coleven,Wrow, Wcol)\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    # Initialize matrix W with zeros\n",
    "    flattenW = np.zeros((Wrow,Wcol), dtype=np.float64)\n",
    "\n",
    "    # Iterate through even indices of A and recover B using the specified equation\n",
    "\n",
    "    flattenW = ((ZZeven - ZZodd)/two)\n",
    "    flattenW= flattenW/alpha\n",
    "    \n",
    "    \n",
    "    return flattenW\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fafe3d3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process4extract_image(image_name, MDIR, XDIR, shape=(32,32,3)):\n",
    "  wimage_path = MDIR+image_name\n",
    "  image1 = cv2.imread(wimage_path)\n",
    "  image = rgb_to_ycbcr_lossless(image1)\n",
    "  bwm =image[:, :, channel]\n",
    "\n",
    "  if bwm.shape[0] % 4 != 0:\n",
    "        rowLen=bwm.shape[0] % 4\n",
    "        last_row = bwm[-rowLen:,:]\n",
    "        bwm= bwm[:-rowLen,:]\n",
    "  \n",
    "  if bwm.shape[1] % 4 != 0:\n",
    "        colLen=bwm.shape[1] % 4\n",
    "        last_column = bwm[:,-colLen:]\n",
    "        bwm= bwm[:,:-colLen]\n",
    "\n",
    "  #bwm_LL, (bwm_LH, bwm_HL, bwm_HH) = pywt.dwt2(bwm, 'db1')\n",
    "  values = pywt.wavedec2(bwm, 'coif3', mode='periodization', level=2)\n",
    "  (b_LH, b_HL, b_HH) = values[1]\n",
    "\n",
    "\n",
    "    \n",
    "  water = recover_watermark(b_HH, shape)\n",
    "  watermark_ext = deconcatenate_2d_to_color_image(water,shape)\n",
    "\n",
    "  if not image_name.endswith(\".png\"):\n",
    "    image_name = image_name.split(\".\")[0] + \".png\"\n",
    "  extracted_water_path = XDIR+\"extracted_from_\"+image_name\n",
    "  cv2.imwrite(extracted_water_path, watermark_ext)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "350b2a5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Xtract(MDIR,XDIR):\n",
    "    embedd_image_names = get_image_names(MDIR)\n",
    "    threads = []\n",
    "    for imgname in embedd_image_names:\n",
    "        thread = threading.Thread(target=process4extract_image, args=(imgname,MDIR,XDIR))\n",
    "        threads.append(thread)\n",
    "\n",
    "\n",
    "    for thread in threads:\n",
    "        thread.start()\n",
    "\n",
    "\n",
    "    for thread in threads:\n",
    "        thread.join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0240c2e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multithread(cell):\n",
    "    threads = [] \n",
    "    for imgname in image_names:\n",
    "        thread = threading.Thread(target=cell, args=(imgname,))\n",
    "        threads.append(thread) # add the thread to the list\n",
    "        thread.start() # start the thread\n",
    "\n",
    "    for thread in threads:\n",
    "        thread.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82573c66",
   "metadata": {},
   "source": [
    "# attackcase codes from here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1743e061",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 45s\n",
      "Wall time: 8.47 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def downscale(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        scale_factor = 0.75  # Adjust the scaling factor as needed\n",
    "        h, w, _ = image.shape\n",
    "        attacked_image = cv2.resize(image, (int(w * scale_factor), int(h * scale_factor)))\n",
    "        restored_image = cv2.resize(attacked_image, (w, h))\n",
    "        cv2.imwrite(convertedDIR+image_name, restored_image)\n",
    "\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\downscale\\\\\"\n",
    "downscale(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\downscale\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\downscale\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "583693c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 47s\n",
      "Wall time: 8.52 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def upscale(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        scale_factor = 1.5  # Adjust the scaling factor as needed\n",
    "        h, w, _ = image.shape\n",
    "        attacked_image = cv2.resize(image, (int(w * scale_factor), int(h * scale_factor)))\n",
    "        restored_image = cv2.resize(attacked_image, (w, h))\n",
    "        cv2.imwrite(convertedDIR+image_name, restored_image)\n",
    "\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\upscale\\\\\"\n",
    "upscale(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\upscale\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\upscale\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0bef6a22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 46s\n",
      "Wall time: 9.25 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def gaussBlurr(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        kernel_size = (3, 3)  # Adjust the kernel size as needed\n",
    "        blurred_image = cv2.GaussianBlur(image, kernel_size, 0)\n",
    "        cv2.imwrite(convertedDIR+image_name, blurred_image)\n",
    "\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\gaussBlurr\\\\\"\n",
    "gaussBlurr(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\gaussBlurr\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\gaussBlurr\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8c476fd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 51s\n",
      "Wall time: 10.1 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def rotation(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        rotation_angle = 0.3  # Adjust the rotation angle as needed\n",
    "        rows, cols, _ = image.shape\n",
    "        rotation_matrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), rotation_angle, 1)\n",
    "        rotated_image = cv2.warpAffine(image, rotation_matrix, (cols, rows))\n",
    "\n",
    "        cv2.imwrite(convertedDIR+image_name, rotated_image)\n",
    "\n",
    "    multithread(convertion)\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\rotation\\\\\"\n",
    "rotation(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\rotation\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\rotation\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "86218bb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 53s\n",
      "Wall time: 11.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def saltpepper(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        noise_density = 0.001  # Adjust the noise density as needed\n",
    "\n",
    "        # Create a copy of the watermarked image\n",
    "        noisy_image = image.copy()\n",
    "\n",
    "        # Generate random noise\n",
    "        salt_and_pepper = np.random.rand(noisy_image.shape[0], noisy_image.shape[1])\n",
    "\n",
    "        # Add salt noise\n",
    "        noisy_image[salt_and_pepper < noise_density] = 255\n",
    "\n",
    "        # Add pepper noise\n",
    "        noisy_image[salt_and_pepper > 1 - noise_density] = 0\n",
    "\n",
    "        cv2.imwrite(convertedDIR+image_name, noisy_image)\n",
    "\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\saltpepper\\\\\"\n",
    "saltpepper(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\saltpepper\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\saltpepper\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8ceffbf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 40s\n",
      "Wall time: 8.96 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def jpegcompression(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        \n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image)\n",
    "\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg\\\\\"\n",
    "jpegcompression(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c9288456-c4ec-4d7b-b5ed-bd27d2666bf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 1min 34s\n",
      "Wall time: 7.53 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "def jpegcompression50(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 50\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg50\\\\\"\n",
    "jpegcompression50(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg50\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg50\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e79bc3f-fe7d-42ec-a84c-a44623a6f15d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "def jpegcompression30(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 30\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg30\\\\\"\n",
    "jpegcompression30(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg30\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg30\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a076b91e-06a2-4924-bb25-21169a2c68f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "def jpegcompression40(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 40\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg40\\\\\"\n",
    "jpegcompression40(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg40\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg40\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9f9ed76-5aef-4b52-b044-5150ab175b7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "def jpegcompression60(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 60\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg60\\\\\"\n",
    "jpegcompression60(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg60\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg60\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cea6a933-3ed4-4b62-9ff8-0b344563a07f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "def jpegcompression70(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 70\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg70\\\\\"\n",
    "jpegcompression70(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg70\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg70\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c218e05c-8103-4225-a8ef-57b413cc630c",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "def jpegcompression80(convertedDIR):\n",
    "    def convertion(image_name):\n",
    "        compression_quality = 80\n",
    "        image_path = images_DIR+image_name\n",
    "        image = cv2.imread(image_path)\n",
    "        \n",
    "        cv2.imwrite(convertedDIR + image_name[:-4] + '.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, compression_quality])\n",
    "\n",
    "    multithread(convertion)\n",
    "convertedDIR=\"attack\\\\images\\\\jpeg80\\\\\"\n",
    "jpegcompression80(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\jpeg80\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\jpeg80\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "85f39e37-5d7c-4cb9-b72d-ebaaa1ca29fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#bright>1.0 dark 0<x<1.0 \n",
    "def Bright15(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 1.5\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright15\\\\\"\n",
    "Bright15(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright15\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright15\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "928a12b7-19ba-4db2-b3d8-9747bf5c788a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright14(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 1.4\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright14\\\\\"\n",
    "Bright14(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright14\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright14\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2f67dbc2-221d-4084-86f6-629c83d1880e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright13(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 1.3\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright13\\\\\"\n",
    "Bright13(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright13\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright13\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "17ea8df7-6588-4453-b362-2661bd4207a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright12(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 1.2\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright12\\\\\"\n",
    "Bright12(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright12\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright12\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "251a552e-b878-457a-aa80-24f2f95f49a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright11(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 1.1\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright11\\\\\"\n",
    "Bright11(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright11\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright11\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8f1d0170-06d5-401a-975e-492abf3aaebd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright09(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 0.9\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright09\\\\\"\n",
    "Bright09(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright09\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright09\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "17e4f84f-2534-4a05-b3e4-ae40eedbfa64",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright08(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 0.8\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright08\\\\\"\n",
    "Bright08(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright08\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright08\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "36b0a39c-e089-490d-bb39-04b2265a1a53",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright07(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 0.7\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright07\\\\\"\n",
    "Bright07(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright07\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright07\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "517047f2-7071-4642-9f7a-79f1c8384d89",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Bright06(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 0.6\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright06\\\\\"\n",
    "Bright06(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright06\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright06\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c91beb70-12e9-411e-bf59-2171aa15063b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#bright>1.0 dark 0<x<1.0 \n",
    "def Bright05(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    factor = 0.5\n",
    "    image_path = images_DIR + image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Adjust brightness using element-wise multiplication\n",
    "    brighter_image = image * factor\n",
    "\n",
    "    # Clip pixel values to prevent overflow/underflow (optional)\n",
    "    #brighter_image = np.clip(brighter_image, 0, 255, out=brighter_image, casting=\"uint8\")\n",
    "\n",
    "    cv2.imwrite(convertedDIR + image_name, brighter_image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\bright05\\\\\"\n",
    "Bright05(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\bright05\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\bright05\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f5777608-cade-424d-b4f2-63ad97b1d612",
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop25UL(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    image_path = images_DIR+image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Get the height and width of the image\n",
    "    height, width, _ = image.shape\n",
    "\n",
    "    # Calculate the area to be replaced (25% of the image)\n",
    "    area_height = int(height * 0.50)\n",
    "    area_width = int(width * 0.50)\n",
    "\n",
    "    # Replace the upper left corner with black pixels\n",
    "    image[0:area_height, 0:area_width] = (0, 0, 0)\n",
    "\n",
    "    cv2.imwrite(convertedDIR+image_name, image)\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\crop25UL\\\\\"\n",
    "crop25UL(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\crop25UL\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\crop25UL\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9eab18da-10dc-4da5-be38-9442ecb3d62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def crop25W(convertedDIR):\n",
    "  def conversion(image_name):\n",
    "    image_path = images_DIR+image_name\n",
    "    image = cv2.imread(image_path)\n",
    "\n",
    "    # Get the height and width of the image\n",
    "    height, width, _ = image.shape\n",
    "\n",
    "    # Replace the boundary (1 pixel wide) with black pixels\n",
    "    boundary=50 #25%\n",
    "    image[0:boundary, 0:width] = (0, 0, 0)  # top boundary\n",
    "    image[height-boundary:height, 0:width] = (0, 0, 0)  # bottom boundary\n",
    "    image[0:height, 0:boundary] = (0, 0, 0)  # left boundary\n",
    "    image[0:height, width-boundary:width] = (0, 0, 0)  # right boundary\n",
    "\n",
    "    cv2.imwrite(convertedDIR+image_name, image)\n",
    "\n",
    "\n",
    "  multithread(conversion)\n",
    "\n",
    "\n",
    "convertedDIR=\"attack\\\\images\\\\crop25W\\\\\"\n",
    "crop25W(convertedDIR)\n",
    "\n",
    "MDIR = \"attack\\\\images\\\\crop25W\\\\\"\n",
    "XDIR =\"attack\\\\extracted\\\\crop25W\\\\\"\n",
    "Xtract(MDIR,XDIR)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}