watermark_removal/light_watermark_remover.ipynb

{
 "metadata": {
  "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.9.2"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python392jvsc74a57bd0eafa71b4a5f824d3055ca9707dde86e6ce800dc54c56e20c6da9d851446cd008",
   "display_name": "Python 3.9.2 64-bit ('venv')"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "## Load image"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2 as cv\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# image = \"./images/test1.jpg\"\n",
    "image = \"./images/test3-nored.jpg\"\n",
    "highlighted_image = \"./images/test3.jpg\"\n",
    "output = \"./images/removed3.png\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "watermarked = cv.imread(image)\n",
    "# display\n",
    "def display(name, img):\n",
    "    cv.startWindowThread()\n",
    "    cv.imshow(name, img/255)\n",
    "    cv.waitKey(0)\n",
    "    cv.destroyWindow(name)\n",
    "    cv.waitKey(1)\n",
    "\n",
    "display(\"Watermarked\", watermarked)\n"
   ]
  },
  {
   "source": [
    "## Detect watermark \n",
    "\n",
    "*Note*: This is only for white semitransparent watermark. \n",
    "\n",
    "Find the pixels that are in a range of white after converting the image to greyscale. To decrease noise, the user enters the ROI of the watermark. Then, compute an alpha mask of the watermark. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# obtain the alpha mask\n",
    "\n",
    "# rectangle to identify watermark\n",
    "# test1  \n",
    "# x, y, w, h = 600, 1400, 250, 35 \n",
    "# test2 \n",
    "x, y, w, h = 50, 1480, 470, 70 \n",
    "# test3 \n",
    "# x, y, w, h = 600, 1400, 250, 35 \n",
    "\n",
    "selected = np.zeros_like(watermarked)\n",
    "cv.rectangle(selected, (x,y), (x+w, y+h), (255,255,255), -1)\n",
    "\n",
    "# for lighter images (test2 and test3)\n",
    "highlighted = cv.imread(highlighted_image) # highlighted with red strokes \n",
    "watermark = cv.bitwise_and(highlighted, selected) \n",
    "watermark = watermark.astype(float)\n",
    "# display(\"Selected\", watermark)\n",
    "watermark[np.where((watermark != [0,0,255]).all(axis = 2))] = [0,0,0] # and all other pixels to black \n",
    "# watermark[np.where((watermark == [0,0,255]).all(axis = 2))] = watermarked[np.where((watermark == [0,0,255]).all(axis = 2))] # convert red to white \n",
    "\n",
    "\n",
    "grey = watermark.max(axis=-1)\n",
    "grey[grey>0] = 255\n",
    "display(\"Mask\", grey)\n",
    "\n",
    "# HSV (alternative)\n",
    "# hsv = cv.cvtColor(watermark, cv.COLOR_BGR2HSV)\n",
    "# sensitivity = 50\n",
    "# lower_white = np.array([0, 0, 255-sensitivity])\n",
    "# upper_white = np.array([255, sensitivity, 255])\n",
    "# hsv_mask = cv.inRange(hsv, lower_white, upper_white)\n",
    "# display(\"Mask\", hsv_mask)\n"
   ]
  },
  {
   "source": [
    "## Calculate alpha and W \n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for light images \n",
    "W = grey \n",
    "alpha = np.zeros_like(W)\n",
    "alpha[W>0] = 1 # alpha is 1 \n",
    "\n",
    "alpha = np.repeat(alpha, 3, axis=-1).reshape(*(alpha.shape),3)\n",
    "W = np.repeat(W, 3, axis=-1).reshape(*(W.shape),3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOT USED \n",
    "def blur_mask(watermarked, alpha, W):\n",
    "    I = (watermarked.astype(float) - alpha * W)/(1-alpha)\n",
    "    I[I<0] = 0 \n",
    "    I[I>255] = 255 \n",
    "    I = I.astype(uint8)\n",
    "\n",
    "    fI = I.copy()\n",
    "    fI[y:y+h, x:x+w, :] = cv.medianBlur(fI[y:y+h, x:x+w, :], 5) \n",
    "\n",
    " "
   ]
  },
  {
   "source": [
    "## Main logic \n",
    "J = alpha * W + (1-alpha) * I \n",
    "\n",
    "I = \\frac{J - alpha * W}{1 - alpha}"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process(watermarked, alpha, W, bg, output_name=\"removed.png\"):\n",
    "    aW = (alpha * W)\n",
    "    # a1 = (1 / (1-alpha))\n",
    "    med = bg \n",
    "    watermarked = watermarked.astype(float)\n",
    "    J = watermarked\n",
    "\n",
    "    # display(\"Watermarked\", J)\n",
    "    I = (J - aW) # * a1, but for test1, alpha is around 1\n",
    "    I[I<0] = 0\n",
    "    I[I>255] = 255 \n",
    "    I = I.astype(np.uint8)\n",
    "\n",
    "    display(\"Output\", I) \n",
    "\n",
    "\n",
    "    # blur \n",
    "    fI = I.copy() \n",
    "    fI[y:y+h, x:x+w, :] = cv.medianBlur(fI[y:y+h, x:x+w, :], 7) \n",
    "    fI[fI<0] = 0\n",
    "    fI[fI>255] = 255 \n",
    "\n",
    "    display(\"Output2\", fI)\n",
    "\n",
    "    # predict the color from the left and top neighbor \n",
    "    for row in range(y, y+h):\n",
    "        for col in range(x, x+w):\n",
    "            if fI[row, col][0] == 0 and fI[row, col][1] == 0 and fI[row, col][2] == 0:\n",
    "                crop = fI[row-1:row, col-1:col]\n",
    "                average = np.average(crop, axis=(0,1))\n",
    "                fI[row, col] = average # + I[row, col-1] \n",
    "\n",
    "    display(\"Output test\", fI)\n",
    "\n",
    "    # blur again \n",
    "    fI[y:y+h, x:x+w, :] = cv.medianBlur(fI[y:y+h, x:x+w, :], 7) \n",
    "    fI[fI<0] = 0\n",
    "    fI[fI>255] = 255\n",
    "\n",
    "    display(\"Test\", fI)\n",
    "\n",
    "    cv.imwrite(output_name, fI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "process(watermarked, alpha, W, W, output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}