lab1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yajuna/tmath308/blob/master/lab1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6lqpRF-1tXi-"
      },
      "source": [
        "# Lab 1: RREF form, finding fit functions given data, and matrix arithmetics-application in image processing\n",
        "## Complete the lab, by running the code, some times adding your own code or writing documentations to explain the code"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzZASwwBtXjD"
      },
      "outputs": [],
      "source": [
        "# import libraries\n",
        "import numpy as np\n",
        "import scipy as sp\n",
        "import sympy\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2hfEfZZQtXjF"
      },
      "source": [
        "The Python library sympy computes REF and RREF. We will try a couple of matrices here. In general though, the operation is not very accurate."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aE6x2Gl3tXjF"
      },
      "outputs": [],
      "source": [
        "# generate a random matrix of size 4 by 4\n",
        "A = np.random.random((4,4))\n",
        "\n",
        "# find the rref form of A\n",
        "\n",
        "rA = sympy.Matrix(A).rref()\n",
        "\n",
        "# uncomment below to se the RREF of matrix\n",
        "# print(rA)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VqkBLW11tXjG"
      },
      "source": [
        "## We solved the system in class from the electrical networks. Now we are solving the system with Python. Notice this system is not square, so we will be using a different command (we did this in lab0).\n",
        "\n",
        "We know:\n",
        "\n",
        "for node A: $-i_1+i_2-i_3=0$\n",
        "\n",
        "node B: $i_1-i_2+i_4=0$\n",
        "\n",
        "node C: $i_3-i_5+i_6=0$\n",
        "\n",
        "node D: $-i_4+i_5-i_6=0$\n",
        "\n",
        "top loop: $4i_1+2i_2=8$\n",
        "\n",
        "middle loop: $2i_2+4i_5=0$\n",
        "\n",
        "bottom loop: $4i_5+5i_6=10$\n",
        "\n",
        "And our goal is to find the currents.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3MsDfG_ktXjG"
      },
      "outputs": [],
      "source": [
        "# Define coefficient matrix and right hand side vector\n",
        "\n",
        "B = np.array([[-1,1,-1,0,0,0],[1,-1,0,1,0,0],[0,0,1,0,-1,1],[0,0,0,-1,1,-1],[4,2,0,0,0,0],[0,2,0,0,4,0],[0,0,0,0,4,5]])\n",
        "\n",
        "b = np.array([0,0,0,0,8,0,10])\n",
        "\n",
        "# solve the system by uncommenting the following line\n",
        "# x = np.linalg.lstsq(B,b)\n",
        "\n",
        "# type in x = np.linalg.solve(B,b) and run. Paste the last line of your error message here."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nR62-npLtXjH"
      },
      "source": [
        "Notice the solution you get is not nice clean integer solutions like what we got in class. Why is that?\n",
        "\n",
        "Ans:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fzOEfgDdtXjH"
      },
      "source": [
        "## Data fitting eventually comes down to solving a linear system. You are given $N$ pairs of data points $(x_i,y_i)$, and your goal is to find a curve (or function) $y=f(x)$. We normally try some reasonable ones and choose one that works the best."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsOlckj_tXjI"
      },
      "source": [
        "### Consider a set of data points y = [0.892, 1.44, 1.31, 1.66, 1.10, 1.19], and x = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0]. We try a polynomial fit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-K-wrbbUtXjI"
      },
      "outputs": [],
      "source": [
        "# We guess that the function is of the form y = f(x)=c0+c1*x+c2*x^2+...+c5*x^5. Our goal is to\n",
        "# find the coefficients c0,...,c5\n",
        "\n",
        "# you will see some array handle with numpy here\n",
        "\n",
        "C = np.zeros((6,6))\n",
        "\n",
        "# type print(C) below and run to see what the command np.zeros((m,n)) does\n",
        "\n",
        "# define the data points\n",
        "\n",
        "x = np.transpose(np.array([0.0, 0.2, 0.4, 0.6, 0.8, 1.0]))\n",
        "\n",
        "y = np.transpose(np.array([0.892, 1.44, 1.31, 1.66, 1.10, 1.19]))\n",
        "\n",
        "C[:,0] = np.ones((6,))\n",
        "\n",
        "C[:,1] = x\n",
        "\n",
        "# type print(C) to see the output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UwfaRHugtXjJ"
      },
      "outputs": [],
      "source": [
        "# build coefficient matrix: each row means f(xi) = yi, or c0+c1*xi+c2*xi^2+...+c5*xi^5 = yi\n",
        "\n",
        "for i in range(2,6):\n",
        "    C[:,i] = np.power(C[:,1],i)\n",
        "\n",
        "# type print(C) to see the form of coefficient matrix\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xGrjbEa9tXjJ"
      },
      "outputs": [],
      "source": [
        "# solve the system with np.linalg.solve\n",
        "\n",
        "coef = np.linalg.solve(C,y)\n",
        "\n",
        "# print coef and run to see the coefficients."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhyAGxvBtXjJ"
      },
      "source": [
        "Now you have found the polynomial fit for the data. We will plot the data points and the fitting curve."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "s0UVS1HwtXjK"
      },
      "outputs": [],
      "source": [
        "# plot data points x and y\n",
        "\n",
        "plt.plot(x, y, 'ro')\n",
        "plt.axis([0, 1, 0, 2])\n",
        "plt.xlabel('x values')\n",
        "plt.ylabel('y values')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6lACr3Z5tXjK"
      },
      "outputs": [],
      "source": [
        "# plot fitting curve, call coef from above linear system\n",
        "\n",
        "xx = np.arange(0,1,0.02)\n",
        "\n",
        "# google a little bit to see how to define polynomials with coefficients. Paste the url of your result below after a #\n",
        "# answer:\n",
        "# A polynomial is defined as an expression which is composed of variables, constants and exponents, that are combined using mathematical operations such as addition, subtraction, multiplication and division (No division operation by a variable).\n",
        "\n",
        "# need to flip coef, as poly1d builds polynomial in the descending order of power of x\n",
        "coefficient = np.flip(coef)\n",
        "\n",
        "f = p = np.poly1d(coefficient)\n",
        "\n",
        "plt.plot(xx, f(xx), 'k')\n",
        "plt.axis([0, 1, 0, 2])\n",
        "plt.xlabel('x values')\n",
        "plt.ylabel('fitting curve')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vILGxQBXtXjK"
      },
      "outputs": [],
      "source": [
        "# uncomment below code to show the data points and fitting curve in the same figure\n",
        "\n",
        "# plt.plot(x, y, 'ro')\n",
        "# plt.plot(xx, f(xx), 'k')\n",
        "# plt.axis([0, 1, 0, 2])\n",
        "# plt.ylabel('fitting curve')\n",
        "# plt.xlabel('x values')\n",
        "# plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "txHK09K8tXjK"
      },
      "source": [
        "## In this part, we make our own knock off of photoshop.\n",
        "Digital photos are represented by arrays of numbers. We handle them as arrays (therefore matrices) and play with the matrix operations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHXObQ79tXjL"
      },
      "source": [
        "We will pre process the images from the raw import format to arrays.\n",
        "\n",
        "_Only run one of the two cells from below and skip the other_"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TfPFgbzqtXjL"
      },
      "outputs": [],
      "source": [
        "############ If using Google Colab, run this cell to use images from url\n",
        "import requests\n",
        "from io import BytesIO\n",
        "\n",
        "url_moon = 'https://raw.githubusercontent.com/yajuna/tmath308/master/pexels_moon.jpeg'\n",
        "page_moon = requests.get(url_moon)\n",
        "moon = Image.open(BytesIO(page_moon.content))\n",
        "\n",
        "url_person = 'https://raw.githubusercontent.com/yajuna/tmath308/master/pexels_person.jpeg'\n",
        "page_person = requests.get(url_person)\n",
        "person = Image.open(BytesIO(page_person.content))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tadmgX6LtXjM"
      },
      "outputs": [],
      "source": [
        "### DO NOT RUN THIS CELL\n",
        "############# If using Binder, run this cell to use images from github repository\n",
        "\n",
        "# import images Pillow\n",
        "# person = Image.open(\"pexels_person.jpeg\")\n",
        "# moon = Image.open(\"pexels_moon.jpeg\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RFgvcT9utXjM"
      },
      "outputs": [],
      "source": [
        "# color to grayscale\n",
        "personGray = person.convert('L')\n",
        "moonGray = moon.convert('L')\n",
        "######\n",
        "# uncomment and run to show images\n",
        "\n",
        "plt.figure()\n",
        "# subplot(r,c) #provide the no. of rows and columns\n",
        "f, axarr = plt.subplots(1,4,figsize=(16, 12))\n",
        "\n",
        "# use the created array to output your multiple images. In this case we have four images horizontally\n",
        "axarr[0].imshow(moon)\n",
        "axarr[1].imshow(person)\n",
        "axarr[2].imshow(moonGray)\n",
        "axarr[3].imshow(personGray)\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xk828RUStXjM"
      },
      "outputs": [],
      "source": [
        "# check the data type\n",
        "type(person)\n",
        "type(moon)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IcaBMfxLtXjM"
      },
      "outputs": [],
      "source": [
        "# run this cell\n",
        "# convert image file to array\n",
        "\n",
        "personArray = np.asarray(personGray)\n",
        "moonArray = np.asarray(moonGray)\n",
        "\n",
        "# check data size\n",
        "\n",
        "dim_person = np.shape(personArray)\n",
        "dim_moon = np.shape(moonArray)\n",
        "\n",
        "print(dim_person,dim_moon) # check size of images for matrix computation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GVR1y7WJtXjM"
      },
      "outputs": [],
      "source": [
        "# cut moon image so that two images are of the same size, run the code to see new shape\n",
        "\n",
        "moonArray1 = moonArray[:694,]\n",
        "print(np.shape(moonArray1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6uC6ZUSTtXjN"
      },
      "outputs": [],
      "source": [
        "# print a small portion of the data, paste what you see in the end after 'dtype = '\n",
        "# ans: dtype = Array\n",
        "\n",
        "personArray[0:5,34:54]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hsRhWwq9tXjN"
      },
      "source": [
        "### In this part, we deal with data types"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iPpRCf0JtXjN"
      },
      "outputs": [],
      "source": [
        "# run the code, and print a small portion similar to above to see what values you get\n",
        "\n",
        "addImage = (personArray + moonArray1)/2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Rlo1P3uJtXjN"
      },
      "outputs": [],
      "source": [
        "# print addImage to see what happens\n",
        "\n",
        "im_add1 = Image.fromarray(addImage, 'L')\n",
        "\n",
        "imgplot = plt.imshow(im_add1)\n",
        "\n",
        "# is it what you expected? why or why not?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pH8h9H_jtXjN"
      },
      "outputs": [],
      "source": [
        "# run the code, and print a small portion similar to above to see what values you get\n",
        "\n",
        "personF = personArray.astype('float')\n",
        "moonF = moonArray1.astype('float')\n",
        "additionF = (personF + moonF)/2\n",
        "addition = additionF.astype('uint8')\n",
        "\n",
        "# print(personF[0:5,34:54])\n",
        "# print(addition[0:5,34:54])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Cqq_9u-GtXjN"
      },
      "outputs": [],
      "source": [
        "# print addition to see what happens\n",
        "\n",
        "im_add2 = Image.fromarray(addition, 'L')\n",
        "implot = plt.imshow(im_add2)\n",
        "\n",
        "# is it what you expected? why or why not?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7njOKJuDtXjO"
      },
      "source": [
        "Find the mirror reflection of the photo with respect to the diagonal, by computing the tranpose of the array."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gnr6c1vltXjO"
      },
      "outputs": [],
      "source": [
        "# compute transpose of our image to make it flat. run the code and see the image\n",
        "\n",
        "im_addtranspose = np.transpose(addition)\n",
        "\n",
        "im_addt = Image.fromarray(im_addtranspose, 'L')\n",
        "imgplot = plt.imshow(im_addt)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SrJytz7btXjO"
      },
      "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.7.4"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}