sebse/bildverarbeitungss18-hausaufgaben
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added solution for ex1 and 2

Browse Source
This commit is contained in:
Jakob Krause
2018-05-02 18:30:02 +02:00
parent e238780636
commit 1fc8c4bf0f
2 changed files with 832 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

410
assignments/02_assignment_sample_solution.ipynb Normal file
View File

@@ -0,0 +1,410 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"# Image Processing SS 16 - Assignment - 02\n",
"\n",
"### Deadline is 4.5.2016 at 16:00 o'clock\n",
"\n",
"Please solve the assignments together with a partner.\n",
"I will run every notebook. Make sure the code runs through. Select `Kernel` -> `Restart & Run All` to test it.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Exercise 1 - 10 Points\n",
"\n",
"Implement affine transformation with [bicubic interpolation](https://en.wikipedia.org/wiki/Bicubic_interpolation)."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# display the plots inside the notebook\n",
"%matplotlib inline"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import pylab\n",
"pylab.rcParams['figure.figsize'] = (12, 12) # This makes the plot bigger"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The [skimage](http://scikit-image.org/) library comes with multiple useful test images. Let's start with an image of an astronaut. "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"from skimage.data import astronaut\n",
"from skimage.color import rgb2gray"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# We use a gray image. All the algorithms should work with color images too.\n",
"img = rgb2gray(astronaut() / 255.)\n",
"plt.imshow(img, cmap='gray')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def derive_y(image):\n",
" \"\"\"Computes the derivative of the image w.r.t the y coordinate\"\"\"\n",
" derived_image = np.zeros_like(image)\n",
" for x in range(image.shape[0]):\n",
" for y in range(image.shape[1]):\n",
" if y + 1 < image.shape[1] and y - 1 > 0:\n",
" derived_image[x,y] = image[x, y - 1] - image[x, y + 1]\n",
" return derived_image\n",
"\n",
"def derive_x(image):\n",
" \"\"\"Computes the derivative of the image w.r.t the x coordinate\"\"\"\n",
" derived_image = np.zeros_like(image)\n",
" for x in range(image.shape[0]):\n",
" for y in range(image.shape[1]):\n",
" if x + 1 < image.shape[1] and x - 1 > 0:\n",
" derived_image[x,y] = image[x - 1, y] - image[x + 1, y]\n",
" return derived_image"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"dx_img = derive_x(img)\n",
"dy_img = derive_y(img)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"plt.figure(figsize=(18, 12))\n",
"plt.subplot(131)\n",
"plt.imshow(img, cmap='gray')\n",
"plt.subplot(132)\n",
"plt.imshow(dx_img, cmap='gray')\n",
"plt.subplot(133)\n",
"plt.imshow(dy_img, cmap='gray')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# The derivatives are no longer in the range [0,1].\n",
"print(\"min: {}, max: {}\".format(dx_img.min(), dx_img.max()))"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"indicies = np.indices(img.shape).reshape(2, -1)\n",
"indicies.shape"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# pick some random index"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"indicies[:, 123456]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"indicies_hg = np.concatenate([\n",
" indicies, np.ones((1, indicies.shape[1]))], axis=0)\n",
"indicies_hg.shape"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"indicies_hg[:, 123456]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"T_scale = np.array([\n",
" [0.75, 0, 0],\n",
" [0, 0.75, 0],\n",
" [0, 0, 1],\n",
"])\n",
"# np.dot(T_affine, indicies_hg).shape, for python < 3.5\n",
"(T_scale @ indicies_hg).shape"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"T_affine = np.array([\n",
" [0.75, 0.2, 100],\n",
" [-0.2, 0.75, 100],\n",
" [0, 0.001, 1],\n",
"])"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# you can use this function to invert the matricies\n",
"np.linalg.inv(T_scale)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def affine_transformation(img, matrix):\n",
" indicies = np.indices(img.shape).reshape(2, -1)\n",
" indicies_hg = matrix @ np.concatenate([indicies, np.ones((1, indicies.shape[1]))], axis=0)\n",
" \n",
" res_img = np.zeros((int(np.ceil(np.max(indicies_hg[0,:]))), int(np.ceil(np.max(indicies_hg[1,:])))))\n",
" indicies_res = np.indices(res_img.shape).reshape(2, -1)\n",
" indicies_res_hg = np.concatenate([indicies_res, np.ones((1, indicies_res.shape[1]))], axis=0)\n",
" indicies_interpolation = np.linalg.inv(matrix) @ indicies_res_hg\n",
" \n",
" return bicubic_interpolation(img, indicies_interpolation, matrix, res_img)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"def bicubic_interpolation(img, indicies, matrix, result):\n",
" dx_img = derive_x(img)\n",
" dy_img = derive_y(img)\n",
" dxy_img = derive_x(dy_img)\n",
" inv_matrix = np.array([\n",
" [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [-3, 3, 0, 0, -2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 2, -2, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0, -3, 3, 0, 0, -2, -1, 0, 0],\n",
" [ 0, 0, 0, 0, 0, 0, 0, 0, 2, -2, 0, 0, 1, 1, 0, 0],\n",
" [-3, 0, 3, 0, 0, 0, 0, 0, -2, 0, -1, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, -3, 0, 3, 0, 0, 0, 0, 0, -2, 0, -1, 0],\n",
" [ 9, -9, -9, 9, 6, 3, -6, -3, 6, -6, 3, -3, 4, 2, 2, 1],\n",
" [-6, 6, 6, -6, -3, -3, 3, 3, -4, 4, -2, 2, -2, -2, -1, -1],\n",
" [ 2, 0, -2, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],\n",
" [ 0, 0, 0, 0, 2, 0, -2, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n",
" [-6, 6, 6, -6, -4, -2, 4, 2, -3, 3, -3, 3, -2, -1, -2, -1],\n",
" [ 4, -4, -4, 4, 2, 2, -2, -2, 2, -2, 2, -2, 1, 1, 1, 1]\n",
" ])\n",
"\n",
" x_size = img.shape[0]\n",
" y_size = img.shape[1]\n",
" \n",
" for i in range(indicies.shape[-1]):\n",
" point = indicies[:, i]\n",
" x_val_floor = int(np.floor(point[0]))\n",
" x_val_ceil = int(np.ceil(point[0]))\n",
" y_val_floor = int(np.floor(point[1]))\n",
" y_val_ceil = int(np.ceil(point[1]))\n",
"\n",
" if 0 < x_val_floor < x_size and 0 < x_val_ceil < x_size and 0 < y_val_floor < y_size and 0 < y_val_ceil < y_size:\n",
" func_values = np.array([\n",
" img[x_val_floor][y_val_floor], img[x_val_ceil][y_val_floor], img[x_val_floor][y_val_ceil], img[x_val_ceil][y_val_ceil],\n",
" dx_img[x_val_floor][y_val_floor], dx_img[x_val_ceil][y_val_floor], dx_img[x_val_floor][y_val_ceil], dx_img[x_val_ceil][y_val_ceil],\n",
" dy_img[x_val_floor][y_val_floor], dy_img[x_val_ceil][y_val_floor], dy_img[x_val_floor][y_val_ceil], dy_img[x_val_ceil][y_val_ceil],\n",
" dxy_img[x_val_floor][y_val_floor], dxy_img[x_val_ceil][y_val_floor], dxy_img[x_val_floor][y_val_ceil], dxy_img[x_val_ceil][y_val_ceil]\n",
" ])\n",
" alpha = inv_matrix @ func_values\n",
" res_point = matrix @ point\n",
" result[int(np.rint(res_point[0]))][int(np.rint(res_point[1]))] = calc_value(point[0] - x_val_floor, point[1] - y_val_floor, alpha)\n",
"\n",
" return result\n",
"\n",
"def calc_value(x, y, alpha):\n",
" x_pow2 = x ** 2\n",
" x_pow3 = x ** 3\n",
" y_pow2 = y ** 2\n",
" y_pow3 = y ** 3\n",
" \n",
" return alpha[0] + alpha[4] * y + alpha[8] * y_pow2 + alpha[12] * y_pow3\\\n",
" + (alpha[1] + alpha[5] * y + alpha[9] * y_pow2 + alpha[13] * y_pow3) * x\\\n",
" + (alpha[2] + alpha[6] * y + alpha[10] * y_pow2 + alpha[14] * y_pow3) * x_pow2\\\n",
" + (alpha[3] + alpha[7] * y + alpha[11] * y_pow2 + alpha[15] * y_pow3) * x_pow3\\"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"img_scale = affine_transformation(img, T_scale)\n",
"img_affine = affine_transformation(img, T_affine)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"plt.imshow(img_scale, cmap='gray')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false,
"scrolled": false
},
"outputs": [],
"source": [
"plt.imshow(img_affine, cmap='gray')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"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.5.1+"
}
},
"nbformat": 4,
"nbformat_minor": 0
}