gradientloss.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.8.3"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python383jvsc74a57bd0c9065c558bee4c4db638e2f8f7496f90f39fc7fab4c41fb820e5cc84613df2a7",
   "display_name": "Python 3.8.3 64-bit (conda)"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import numpy as np\n",
    "from torchvision import transforms\n",
    "from torch.autograd import Variable\n",
    "import torch.nn.functional as F\n",
    "\n",
    "img = Image.open('FH3_1_cvsr.png')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "h = img.size[1]\n",
    "w = img.size[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "T=transforms.Compose([transforms.ToTensor()])\n",
    "P=transforms.Compose([transforms.ToPILImage()])\n",
    "\n",
    "ten=torch.unbind(T(img))\n",
    "x=ten[0].unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "a=np.array([[1, 0, -1],[2,0,-2],[1,0,-1]])\n",
    "conv1=nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1, bias=False)\n",
    "conv1.weight=nn.Parameter(torch.from_numpy(a).float().unsqueeze(0).unsqueeze(0))\n",
    "\n",
    "G_x=conv1(Variable(x)).data.view(1,h,w)\n",
    "\n",
    "b=np.array([[1, 2, 1],[0,0,0],[-1,-2,-1]])\n",
    "conv2=nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1, bias=False)\n",
    "conv2.weight=nn.Parameter(torch.from_numpy(b).float().unsqueeze(0).unsqueeze(0))\n",
    "G_y=conv2(Variable(x)).data.view(1,h,w)\n",
    "\n",
    "G=torch.sqrt(torch.pow(G_x,2)+ torch.pow(G_y,2))\n",
    "X=P(G)\n",
    "X.save('grad.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "torch.Size([1, 1, 1080, 1920])"
      ]
     },
     "metadata": {},
     "execution_count": 12
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Get_gradient(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Get_gradient, self).__init__()\n",
    "        kernel_v = [[0, -1, 0], \n",
    "                    [0, 0, 0], \n",
    "                    [0, 1, 0]]\n",
    "        kernel_h = [[0, 0, 0], \n",
    "                    [-1, 0, 1], \n",
    "                    [0, 0, 0]]\n",
    "        kernel_h = torch.FloatTensor(kernel_h).unsqueeze(0).unsqueeze(0)\n",
    "        kernel_v = torch.FloatTensor(kernel_v).unsqueeze(0).unsqueeze(0)\n",
    "        self.weight_h = nn.Parameter(data = kernel_h, requires_grad = False)\n",
    "        self.weight_v = nn.Parameter(data = kernel_v, requires_grad = False)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x0 = x[:, 0, :]\n",
    "        x1 = x[:, 1, :]\n",
    "        x2 = x[:, 2, :]\n",
    "        x0_v = F.conv2d(x0.unsqueeze(1), self.weight_v, padding=1)\n",
    "        x0_h = F.conv2d(x0.unsqueeze(1), self.weight_h, padding=1)\n",
    "\n",
    "        x1_v = F.conv2d(x1.unsqueeze(1), self.weight_v, padding=1)\n",
    "        x1_h = F.conv2d(x1.unsqueeze(1), self.weight_h, padding=1)\n",
    "\n",
    "        x2_v = F.conv2d(x2.unsqueeze(1), self.weight_v, padding=1)\n",
    "        x2_h = F.conv2d(x2.unsqueeze(1), self.weight_h, padding=1)\n",
    "\n",
    "        x0 = torch.sqrt(torch.pow(x0_v, 2) + torch.pow(x0_h, 2) + 1e-6)\n",
    "        x1 = torch.sqrt(torch.pow(x1_v, 2) + torch.pow(x1_h, 2) + 1e-6)\n",
    "        x2 = torch.sqrt(torch.pow(x2_v, 2) + torch.pow(x2_h, 2) + 1e-6)\n",
    "\n",
    "        x = torch.cat([x0, x1, x2], dim=1)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "gradfunc = Get_gradient()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 1080, 1920])"
      ]
     },
     "metadata": {},
     "execution_count": 35
    }
   ],
   "source": [
    "data = T(img)\n",
    "data = data.unsqueeze(0)\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "gx = gradfunc(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "torch.Size([1, 3, 1080, 1920])"
      ]
     },
     "metadata": {},
     "execution_count": 37
    }
   ],
   "source": [
    "gx.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "out_img = P(gx.squeeze(0))\n",
    "out_img.save('gx.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_aug = data + gx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_aug = P(data_aug.squeeze(0))\n",
    "img_aug.save('aug.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(1080, 1920)"
      ]
     },
     "metadata": {},
     "execution_count": 50
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import math\n",
    "\n",
    "moon = cv2.imread(\"FH3_1_cvsr.png\", 0)\n",
    "\n",
    "moon.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "metadata": {},
     "execution_count": 51
    }
   ],
   "source": [
    "row, column = moon.shape\n",
    "moon_f = np.copy(moon)\n",
    "moon_f = moon_f.astype(\"float\")\n",
    "\n",
    "gradient = np.zeros((row, column))\n",
    "\n",
    "# for x in range(row - 1):\n",
    "#     for y in range(column - 1):\n",
    "#         gx = abs(moon_f[x + 1, y] - moon_f[x, y])\n",
    "#         gy = abs(moon_f[x, y + 1] - moon_f[x, y])\n",
    "#         gradient[x, y] = gx + gy\n",
    "for x in range(1, row - 1):\n",
    "    for y in range(1, column - 1):\n",
    "        gx = abs(moon_f[x + 1, y] - moon_f[x - 1, y])\n",
    "        gy = abs(moon_f[x, y + 1] - moon_f[x, y - 1])\n",
    "        gradient[x, y] = math.sqrt(gx**2 + gy**2)\n",
    "\n",
    "sharp = moon_f + gradient\n",
    "sharp = np.where(sharp < 0, 0, np.where(sharp > 255, 255, sharp))\n",
    "\n",
    "gradient = gradient.astype(\"uint8\")\n",
    "sharp = sharp.astype(\"uint8\")\n",
    "cv2.imshow(\"moon\", moon)\n",
    "cv2.imshow(\"gradient\", gradient)\n",
    "cv2.imshow(\"sharp\", sharp)\n",
    "cv2.waitKey()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}