airfoil_pressure_field.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "87040e44-fc5d-403c-9b79-d76b4b77adb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install opencv-python\n",
    "#!pip install numpy==1.23\n",
    "import torch\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "from pyqtree import Index\n",
    "from scipy import stats\n",
    "from rtree import index\n",
    "from matplotlib.patches import PathPatch\n",
    "from matplotlib.path import Path\n",
    "from template_mesh import Template_Mesh\n",
    "from geometry import Edge_Set\n",
    "from scipy.spatial import distance\n",
    "from PIL import Image\n",
    "from skimage.metrics import structural_similarity as ssim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb07c4c0-21cb-4c87-9cd2-c9b107671e1f",
   "metadata": {},
   "outputs": [],
   "source": [
    "point_number = 5233\n",
    "face_number = 10216\n",
    "\n",
    "face_start_line = 2\n",
    "face_end_line = 10218\n",
    "point_start_line = 10219\n",
    "point_end_line = 15452\n",
    "contour_start_line = 15455\n",
    "contour_end_line = 15655\n",
    "boundary_start_line = 15657\n",
    "boundary_end_line = 15707"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4334350d-267f-4115-85f0-39a89e5ad3d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# x,y-coordinates for each point\n",
    "def read_points(filename):\n",
    "    lines = open(filename, 'r').readlines()\n",
    "    points = np.zeros([point_number, 2], dtype=float)\n",
    "    for i, line in enumerate(lines[point_start_line : point_end_line]):\n",
    "        line = line.strip().split('\\t')\n",
    "        points[i,0] = float(line[0])\n",
    "        points[i,1] = float(line[1])\n",
    "    return points\n",
    "\n",
    "def read_faces(filename):\n",
    "    lines = open(filename, 'r').readlines()\n",
    "    faces = np.zeros([face_number, 3], dtype=int)\n",
    "    for i, line in enumerate(lines[face_start_line : face_end_line]):\n",
    "        line = line.strip().split('\\t')\n",
    "        faces[i,0] = int(line[1])\n",
    "        faces[i,1] = int(line[2])\n",
    "        faces[i,2] = int(line[3])\n",
    "    return faces\n",
    "\n",
    "# on airfoil surface\n",
    "def read_contour_id_list(filename):\n",
    "    lines = open(filename, 'r').readlines()\n",
    "    contour_id_list = []\n",
    "    for line in lines[contour_start_line : contour_end_line]:\n",
    "        line = line.strip().split('\\t')\n",
    "        contour_id_list.append([int(line[1]), int(line[2])])\n",
    "    return np.array(contour_id_list, dtype=int)\n",
    "\n",
    "def read_boundary_id_list(filename):\n",
    "    lines = open(filename, 'r').readlines()\n",
    "    boundary_id_list = []\n",
    "    for line in lines[boundary_start_line : boundary_end_line]:\n",
    "        line = line.strip().split('\\t')\n",
    "        boundary_id_list.append([int(line[1]), int(line[2])])\n",
    "    return np.array(boundary_id_list, dtype=int)\n",
    "\n",
    "def read_pressure_coefficient(filename):\n",
    "    df = pd.read_csv(filename)\n",
    "    pressure_coefficient_list = np.array(df['Pressure_Coefficient'])\n",
    "    return pressure_coefficient_list    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "12537ecc-d81c-4553-b236-7df7cd5e238c",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'mesh/'\n",
    "FOLDER2 = 'restart_csv/'\n",
    "\n",
    "def read_all_data(FILENAME1, FILENAME2):\n",
    "    \n",
    "    FILE1 = FOLDER1 + FILENAME1\n",
    "    FILE2 = FOLDER2 + FILENAME2\n",
    "    \n",
    "    points = read_points(FILE1)\n",
    "    triangles = read_faces(FILE1)\n",
    "    contour = read_contour_id_list(FILE1) # 200\n",
    "    boundary = read_boundary_id_list(FILE1) # 50\n",
    "    pressure_coefs = read_pressure_coefficient(FILE2)\n",
    "    \n",
    "    return points, triangles, contour, boundary, pressure_coefs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a1993fac-dfee-4ed0-82d8-3e2356412cea",
   "metadata": {},
   "outputs": [],
   "source": [
    "points_0013, triangles_0013, contour_0013, boundary_0013, pressure_coefs_0013 = read_all_data('0013.su2', '0013.csv')\n",
    "points_0719, triangles_0719, contour_0719, boundary_0719, pressure_coefs_0719 = read_all_data('0719.su2', '0719.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "a4316072-b197-477a-8102-b0de8df89202",
   "metadata": {},
   "outputs": [],
   "source": [
    "# READING IN MANY FILES\n",
    "def get_identifier(filename):\n",
    "    \"\"\"Extract identifier fron the filename.\"\"\"\n",
    "    return filename.split('.')[0]\n",
    "\n",
    "def read_in_many_files(FOLDER1, FOLDER2):\n",
    "    files_in_folder_1 = os.listdir(FOLDER1)\n",
    "    data = {}\n",
    "    for file1 in files_in_folder_1:\n",
    "        identifier = get_identifier(file1)\n",
    "        file2 = str(identifier) + '.csv'\n",
    "        if file2 in os.listdir(FOLDER2):\n",
    "            points, triangles, contour, boundary, pressure_coefs = read_all_data(file1, file2)\n",
    "        # store in dictionary\n",
    "        data[identifier] = {  \n",
    "                'points': points,\n",
    "                'triangles': triangles,\n",
    "                'contour': contour,\n",
    "                'boundary': boundary,\n",
    "                'pressure_coefs': pressure_coefs}\n",
    "\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "id": "adb843fe-05aa-4cd6-b7f4-674d0ce25307",
   "metadata": {},
   "outputs": [],
   "source": [
    "# SIZE\n",
    "FOLDER1 = 'mesh/size_a/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/size_a/'  # TO CHANGE\n",
    "data_size_a = read_in_many_files(FOLDER1, FOLDER2)\n",
    "\n",
    "FOLDER1 = 'mesh/size_b/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/size_b/'  # TO CHANGE\n",
    "data_size_b = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0378348d-d743-4bb7-ba05-0d397b4cdd21",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Help Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f4bce828-867d-47ca-9180-53f182fcd94d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def precompute_triangle_values(triangles, points):  # triangle indices\n",
    "    \"\"\"\n",
    "    Calculate and store some values for all triangles.\n",
    "    \n",
    "    Returns: Array of intermediate values for each triangle\n",
    "    \"\"\"\n",
    "    num_triangles = len(triangles)\n",
    "    triangle_values = np.zeros((num_triangles, 8))\n",
    "    \n",
    "    for t, triangle in enumerate(triangles):\n",
    "        A = points[triangle[0]]  # 坐标\n",
    "        B = points[triangle[1]]\n",
    "        C = points[triangle[2]]\n",
    "        \n",
    "        \n",
    "        v0 = C - A # vector\n",
    "        v1 = B - A\n",
    "\n",
    "        dot00 = np.dot(v0,v0)\n",
    "        dot01 = np.dot(v0,v1)\n",
    "        dot11 = np.dot(v1,v1)\n",
    "        \n",
    "        invDenom = 1 / (dot00 * dot11 - dot01 * dot01)\n",
    "        \n",
    "        triangle_values[t] = [v0[0], v0[1], v1[0], v1[1], invDenom, dot00, dot01, dot11]\n",
    "    \n",
    "    return triangle_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "95ab5396-390d-4315-bba6-6cabcad7e04d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# used in find_triangles_for_points\n",
    "def create_spatial_index(triangles, points):\n",
    "    # Find bounds of all triangles\n",
    "    bbox = (min(points[:,0]), min(points[:,1]), max(points[:,0]), max(points[:,1]))\n",
    "    \n",
    "    # Create a spatial index using Quadtree\n",
    "    spatial_index = Index(bbox)\n",
    "    \n",
    "    # Insert each triangle into the index\n",
    "    for i, triangle in enumerate(triangles):\n",
    "        t_points = points[triangle]\n",
    "        t_bbox = (min(t_points[:,0]), min(t_points[:,1]), max(t_points[:,0]), max(t_points[:,1]))\n",
    "        spatial_index.insert(i, t_bbox)\n",
    "        \n",
    "    return spatial_index                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b750d4db-36c6-4686-9991-823ac86ff273",
   "metadata": {},
   "outputs": [],
   "source": [
    "# used in find_triangles_for_points\n",
    "def is_point_inside_triangle(point, A, B, C): # A, B, C are coordinates\n",
    "    \n",
    "    # Compute vectors    \n",
    "    v0 = np.array(C) - np.array(A)\n",
    "    v1 = np.array(B) - np.array(A)\n",
    "    v2 = np.array(point) - np.array(A)\n",
    "\n",
    "    # Compute dot products\n",
    "    dot00 = np.dot(v0, v0)\n",
    "    dot01 = np.dot(v0, v1)\n",
    "    dot02 = np.dot(v0, v2)\n",
    "    dot11 = np.dot(v1, v1)\n",
    "    dot12 = np.dot(v1, v2)\n",
    "\n",
    "    # Compute barycentric coordinates\n",
    "    invDenom = 1.0 / (dot00 * dot11 - dot01 * dot01)\n",
    "    u = (dot11 * dot02 - dot01 * dot12) * invDenom\n",
    "    v = (dot00 * dot12 - dot01 * dot02) * invDenom\n",
    "\n",
    "    # Check if point is in triangle\n",
    "    return (u >= 0) and (v >= 0) and (u + v <= 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c3bbd1c0-e522-4de9-9c6c-7fc9274255c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_triangles_for_points(new_points, triangles, points):\n",
    "    \"\"\"\n",
    "    Find the containing triangle for each point.\n",
    "    \n",
    "    Returns:\n",
    "    - Dictionary mapping each new point to its containing triangle's indices.\n",
    "    \"\"\"\n",
    "    spatial_index = create_spatial_index(triangles, points)\n",
    "    point_to_triangle = {}\n",
    "    \n",
    "    for point in new_points:\n",
    "        possible_triangles = list(spatial_index.intersect((point[0], point[1], point[0], point[1])))\n",
    "        \n",
    "        for tri_idx in possible_triangles:\n",
    "            if is_point_inside_triangle(point, points[triangles[tri_idx][0]], points[triangles[tri_idx][1]], points[triangles[tri_idx][2]]):\n",
    "                point_to_triangle[tuple(point)] = triangles[tri_idx]  # TUPLE\n",
    "                break\n",
    "    \n",
    "    return point_to_triangle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "67a918b0-6391-483d-985b-9b8f86765878",
   "metadata": {},
   "outputs": [],
   "source": [
    "def barycentric_coords(p, v1, v2, v3):\n",
    "    \"\"\"\n",
    "    Compute the barycentric coordinates of point p with respect to triangle v1v2v3.\n",
    "    \n",
    "    Args:\n",
    "    - A, B, C are coordinates of the vertices of the tirangle.\n",
    "    \n",
    "    Returns:\n",
    "    - Array of barycentric coordinates (w1, w2, w3)\n",
    "    \"\"\"\n",
    "    denominator = (v2[1] - v3[1])*(v1[0] - v3[0]) + (v3[0] - v2[0])*(v1[1] - v3[1])\n",
    "    w1 = (v2[1] - v3[1])*(p[0] - v3[0]) + (v3[0] - v2[0])*(p[1] - v3[1])\n",
    "    w2 = (v3[1] - v1[1])*(p[0] - v3[0]) + (v1[0] - v3[0])*(p[1] - v3[1])\n",
    "    \n",
    "    w1 = w1 / denominator\n",
    "    w2 = w2 / denominator\n",
    "    w3 = 1 - w1 - w2\n",
    "    \n",
    "    return np.array([w1, w2, w3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "35aa984b-3b76-4a9b-be65-61e8f18153b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_barycentric_for_new_points(new_points, triangles, points):\n",
    "    \"\"\"\n",
    "    Compute barycentric coordinates for a set of new points with respect to a set of triangles.\n",
    "    \n",
    "    Returns: \n",
    "    - an array containing barycentric data. Each row is [a, b, c, d, e, f], where\n",
    "        - a, b, c are the indices of the triangle the new point belongs to\n",
    "        - d, e, f are the barycentric coordinates of the new point w.r.t the triangle\n",
    "    \"\"\"\n",
    "    point_to_triangle = find_triangles_for_points(new_points, triangles, points) # dictionary\n",
    "    \n",
    "    results = []\n",
    "    \n",
    "    for p in new_points:\n",
    "        \n",
    "        tri_indices = point_to_triangle[tuple(p)]\n",
    "        A, B, C = points[tri_indices]\n",
    "        b_coords = barycentric_coords(p, A, B, C)\n",
    "        results.append(np.hstack((tri_indices, b_coords)))\n",
    "    \n",
    "    return np.array(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "45282bc8-5284-4f39-9a1e-cf65aeff6a70",
   "metadata": {},
   "outputs": [],
   "source": [
    "def interpolate_pressure_coef(new_points, triangles, points, pressure_coefs):\n",
    "    \"\"\"\n",
    "    Interpolate pressure coefficients for the new points.\n",
    "    \"\"\"\n",
    "    new_barycentric = compute_barycentric_for_new_points(new_points, triangles, points)  # 6D array\n",
    "    \n",
    "    interpolated_pressure_coefs = []\n",
    "    \n",
    "    for b in new_barycentric:\n",
    "        tri_indices = b[:3].astype(int)\n",
    "        bary_coords = b[3:]\n",
    "        \n",
    "        # get the pressure coefficients for the vertices\n",
    "        vertex_pressure_coef = [pressure_coefs[idx] for idx in tri_indices]\n",
    "        \n",
    "        # new pressure coefs\n",
    "        interpolated_value = sum(v * b for v,b in zip(vertex_pressure_coef, bary_coords))\n",
    "        \n",
    "        interpolated_pressure_coefs.append(interpolated_value)\n",
    "        \n",
    "    return np.array(interpolated_pressure_coefs)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4005ffaf-a977-4764-95e9-16117dda6fa4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def computing_bounding_box(contour, points):\n",
    "    \"\"\"\n",
    "    Compute the bounding box of the airfoil.\n",
    "    \n",
    "    Returns:\n",
    "    - an array [min_x, max_x, min_y, max_y] representing the bounding box.\n",
    "    \"\"\"\n",
    "    unique_indices = np.unique(contour)\n",
    "    airfoil_points_coords = points[unique_indices]\n",
    "    \n",
    "    min_x, min_y = np.min(airfoil_points_coords, axis=0)\n",
    "    max_x, max_y = np.max(airfoil_points_coords, axis=0)\n",
    "    \n",
    "    return np.array([min_x, max_x, min_y, max_y])  # 坐标值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "922545f2-439a-47e6-8ccf-0405e1b97f31",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_points_within_bbox(grid_points, contour, points):\n",
    "    \"\"\"\n",
    "    Return only grid points that lie within the bounding box, also their indices w.r.t grid_points.\n",
    "    \"\"\"\n",
    "    min_x, max_x, min_y, max_y = computing_bounding_box(contour, points)\n",
    "    \n",
    "    filtered_indices = np.where((grid_points[:,0] >= min_x) &\n",
    "                                (grid_points[:,0] <= max_x) &\n",
    "                                (grid_points[:,1] >= min_y) &\n",
    "                                (grid_points[:,1] <= max_y))\n",
    "\n",
    "    return grid_points[filtered_indices], list(filtered_indices[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "29d58dab-6331-4810-a1d2-280c3c477573",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_point_inside_airfoil(p, contour, points):\n",
    "    \"\"\"\n",
    "    Check if a point is inside the airfoil contour using ray casting method.\n",
    "    \"\"\"\n",
    "    x, y = p\n",
    "    intersections = 0\n",
    "    for i in range(len(contour)):\n",
    "        a = points[contour[i][0]] # 坐标\n",
    "        b = points[contour[i][1]]\n",
    "        \n",
    "        # Check if ray intersects with edge of the contour\n",
    "        if ((a[1] > y) != (b[1] > y)) and (x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0]):\n",
    "            intersections += 1\n",
    "            \n",
    "    # Return True if intersections count is odd\n",
    "    return intersections % 2 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fc4ef986-2037-4cfa-9110-8c33287692e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_points_outside_airfoil(contour, grid_points, points): \n",
    "    \"\"\"\n",
    "    Returns:\n",
    "    - Array of coordinates of grid points that are inside the airfoil\n",
    "    \"\"\"\n",
    "    # all points and their indices within the bounding box of the airfoil (w.r.t grid_points)\n",
    "    bbox_points, bbox_indices = filter_points_within_bbox(grid_points, contour, points)\n",
    "    \n",
    "    # get the points that are inside the airfoil\n",
    "    inside_airfoil_points = [p for p in bbox_points if is_point_inside_airfoil(p, contour, points)]\n",
    "    inside_airfoil_tuples = {tuple(p) for p in inside_airfoil_points}\n",
    "    inside_airfoil_indices = [bbox_indices[i] for i,p in enumerate(bbox_points) if tuple(p) in inside_airfoil_tuples]\n",
    "    \n",
    "    # get the points indices that are outside airfoil but inside bbox\n",
    "    outside_airfoil_inside_bbox_indices = list(set(bbox_indices) - set(inside_airfoil_indices))\n",
    "    \n",
    "    # get the indices outside bbox\n",
    "    outside_bbox_indices = list(set(range(grid_points.shape[0])) - set(bbox_indices))\n",
    "    \n",
    "    # combine the above two groups\n",
    "    outside_airfoil_indices = outside_bbox_indices + outside_airfoil_inside_bbox_indices\n",
    "\n",
    "    return grid_points[outside_airfoil_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fe8f49a1-5ea8-4b7f-9720-21ae3385bae7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_points_inside_airfoil(contour, grid_points, points):\n",
    "    \n",
    "    points_outside_airfoil = filter_points_outside_airfoil(contour, grid_points, points)\n",
    "    set_of_all_points = set(map(tuple, grid_points))\n",
    "    set_of_points_outside = set(map(tuple, points_outside_airfoil))\n",
    "    points_inside_airfoil = list(set_of_all_points - set_of_points_outside)\n",
    "    \n",
    "    mask = np.zeros(grid_points.shape[0], dtype=bool)\n",
    "    \n",
    "    for i,p in enumerate(grid_points):\n",
    "        if tuple(p) in points_inside_airfoil:\n",
    "            mask[i] = True\n",
    "    \n",
    "    return mask\n",
    "    #return np.array(points_inside_airfoil)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1091a5a3-8234-4128-92cc-5fdf20730d2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_points_inside_boundary(grid_points, points, boundary):\n",
    "    \n",
    "    boundary_coords = np.array([points[idx] for segment in boundary for idx in segment])\n",
    "    path = Path(boundary_coords)\n",
    "    mask = path.contains_points(grid_points)\n",
    "    \n",
    "    return grid_points[mask]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "176757fd-ab34-4c92-832b-878799ef251a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_points_inside_boundary_outside_airfoil(grid_points, points, contour, boundary):\n",
    "    \n",
    "    points_inside_boundary = get_points_inside_boundary(grid_points, points, boundary)\n",
    "    return filter_points_outside_airfoil(contour, points_inside_boundary, points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5bd15334-76af-462a-9048-b11eee2eecfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_pressure_coef_on_grid(points, triangles, pressure_coefs, contour, boundary, grid_points):\n",
    "    \"\"\"\n",
    "    Compute pressure coefficient values for grid points that are outside of the airfoil and inside the boundary.\n",
    "    \"\"\"\n",
    "    final_points = filter_points_inside_boundary_outside_airfoil(grid_points, points, contour, boundary)\n",
    "    \n",
    "    interpolated_pressure_coefs = interpolate_pressure_coef(final_points, triangles, points, pressure_coefs)\n",
    "    \n",
    "    return final_points, interpolated_pressure_coefs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a5a1543d-76e6-4a3d-baba-f9a7c07c00e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Color RGB values\n",
    "WHITE = np.array([255,255,255])\n",
    "BLACK = np.array([0,0,0])\n",
    "BLUE = np.array([0,0,255]) \n",
    "GREEN = np.array([0,255,0])\n",
    "RED = np.array([255,0,0])\n",
    "PURPLE = np.array([127,0,255])\n",
    "CYAN = np.array([0,255,255])\n",
    "YELLOW = np.array([255,255,0])\n",
    "PINK = np.array([255,0,255])\n",
    "ORANGE = np.array([255,128,0])\n",
    "\n",
    "PIYG_START = np.array([77, 146, 33])\n",
    "PIYG_END = np.array([197, 27, 125])\n",
    "\n",
    "PRGN_START = np.array([118, 42, 131])\n",
    "PRGN_END = np.array([27, 120, 55])\n",
    "\n",
    "SOFT_RED = np.array([255,51,51])\n",
    "SOFT_BLUE = np.array([51,51,255])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "id": "b153dc8a-2dde-4064-b881-de9e6a3d89ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_pressure_on_grid(points, triangles, pressure_coefs, contour, boundary,  res, start_color, end_color, airfoil_color, x_min, x_max, y_min, y_max):\n",
    "    \n",
    "    xx, yy = np.meshgrid(           \n",
    "        np.linspace(x_min, x_max, res),           \n",
    "        np.linspace(y_min, y_max, res)    \n",
    "    )\n",
    "    grid_points = np.vstack([xx.ravel(), yy.ravel()]).T    \n",
    "    \n",
    "    final_points, interpolated_pressure_coefs = compute_pressure_coef_on_grid(points, triangles, pressure_coefs, contour, boundary, grid_points)\n",
    "    \n",
    "    pressure_grid = np.full(xx.shape, 0).astype(float)\n",
    "    \n",
    "    # create a look up map for the grid points\n",
    "    grid_point_to_idx = {tuple(point): idx for idx,point in enumerate(grid_points)}\n",
    "    \n",
    "    # inside airfoil mask: check which points are inside the airfoil  \n",
    "    contour_coords = points[np.unique(contour)] \n",
    "    airfoil_path = Path(contour_coords)\n",
    "    inside_airfoil_mask = airfoil_path.contains_points(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
    "    \n",
    "    # normalized to [0,1]\n",
    "    interpolated_pressure_coefs = interpolated_pressure_coefs - interpolated_pressure_coefs.min()\n",
    "    interpolated_pressure_coefs /= interpolated_pressure_coefs.max() + 1e-12                                                                     \n",
    "    \n",
    "    # fill pressure_grid\n",
    "    for pt, pressure in zip(final_points, interpolated_pressure_coefs):\n",
    "        idx = grid_point_to_idx[tuple(pt)]\n",
    "        ix, iy = np.unravel_index(idx, xx.shape)\n",
    "        pressure_grid[ix, iy] = pressure\n",
    "    \n",
    "    # create an empty RGB image\n",
    "    colored_image = np.zeros((*pressure_grid.shape, 3), dtype=np.uint8)  # np.uint8 ensures that the values are integers ranging from 0 to 255, which is standard for RGB images.\n",
    "    \n",
    "    for i in range(pressure_grid.shape[0]):\n",
    "        for j in range(pressure_grid.shape[1]):\n",
    "            if inside_airfoil_mask[i,j]:\n",
    "                colored_image[i,j] = airfoil_color    \n",
    "            else:\n",
    "                value = pressure_grid[i,j]\n",
    "                color = (1 - value) * start_color + value * end_color  # 压力小 start color, 压力大 end color\n",
    "                colored_image[i,j] = color.astype(np.uint8) \n",
    "    \n",
    "    cv2.imwrite('1.png', cv2.cvtColor(colored_image, cv2.COLOR_RGB2BGR))\n",
    "       \n",
    "def plot_pressure_on_grid_2(points, triangles, pressure_coefs, contour, boundary,  res, start_color, end_color, airfoil_color, x_min, x_max, y_min, y_max, identifier, FOLDER):\n",
    "    xx, yy = np.meshgrid(           \n",
    "        np.linspace(x_min, x_max, res),           \n",
    "        np.linspace(y_min, y_max, res)    \n",
    "    )\n",
    "    grid_points = np.vstack([xx.ravel(), yy.ravel()]).T    \n",
    "    final_points, interpolated_pressure_coefs = compute_pressure_coef_on_grid(points, triangles, pressure_coefs, contour, boundary, grid_points)\n",
    "    pressure_grid = np.full(xx.shape, 0).astype(float)\n",
    "    grid_point_to_idx = {tuple(point): idx for idx,point in enumerate(grid_points)} \n",
    "    contour_coords = points[np.unique(contour)] \n",
    "    airfoil_path = Path(contour_coords)\n",
    "    inside_airfoil_mask = airfoil_path.contains_points(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
    "    interpolated_pressure_coefs = interpolated_pressure_coefs - interpolated_pressure_coefs.min()\n",
    "    interpolated_pressure_coefs /= interpolated_pressure_coefs.max() + 1e-12                                                                     \n",
    "    for pt, pressure in zip(final_points, interpolated_pressure_coefs):\n",
    "        idx = grid_point_to_idx[tuple(pt)]\n",
    "        ix, iy = np.unravel_index(idx, xx.shape)\n",
    "        pressure_grid[ix, iy] = pressure\n",
    "    colored_image = np.zeros((*pressure_grid.shape, 3), dtype=np.uint8)  \n",
    "    for i in range(pressure_grid.shape[0]):\n",
    "        for j in range(pressure_grid.shape[1]):\n",
    "            if inside_airfoil_mask[i,j]:\n",
    "                colored_image[i,j] = airfoil_color    \n",
    "            else:\n",
    "                value = pressure_grid[i,j]\n",
    "                color = (1 - value) * start_color + value * end_color\n",
    "                colored_image[i,j] = color.astype(np.uint8) \n",
    "    if not os.path.exists(FOLDER):\n",
    "        os.makedirs(FOLDER)\n",
    "    filename = os.path.join(FOLDER, f'{identifier}.png')\n",
    "    cv2.imwrite(filename, cv2.cvtColor(colored_image, cv2.COLOR_RGB2BGR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "61b72132-9bdd-43a8-b45e-00e0b2edfbc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_black_and_white(points, triangles, pressure_coefs, contour, boundary, res, inside_color, outside_color, x_min, x_max, y_min, y_max):\n",
    "    \n",
    "    xx, yy = np.meshgrid(           \n",
    "        np.linspace(x_min, x_max, res),            \n",
    "        np.linspace(y_min, y_max, res)    \n",
    "    )\n",
    "    \n",
    "    pressure_grid = np.full(xx.shape, 0).astype(float)\n",
    "    \n",
    "    # inside airfoil mask: check which points are inside the airfoil  \n",
    "    contour_coords = points[np.unique(contour)] \n",
    "    airfoil_path = Path(contour_coords)\n",
    "    inside_airfoil_mask = airfoil_path.contains_points(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
    "    \n",
    "    # create an empty RGB image\n",
    "    bw_image = np.zeros((*pressure_grid.shape, 3), dtype=np.uint8) \n",
    "    \n",
    "    for i in range(pressure_grid.shape[0]):\n",
    "        for j in range(pressure_grid.shape[1]):\n",
    "            if inside_airfoil_mask[i,j]:\n",
    "                bw_image[i,j] = inside_color      \n",
    "            else:\n",
    "                bw_image[i,j] = outside_color\n",
    "    \n",
    "    cv2.imwrite('bw.png', cv2.cvtColor(bw_image, cv2.COLOR_RGB2BGR))\n",
    "\n",
    "def plot_black_and_white_2(points, triangles, pressure_coefs, contour, boundary, res, inside_color, outside_color, x_min, x_max, y_min, y_max, identifier, FOLDER):\n",
    "    xx, yy = np.meshgrid(           \n",
    "        np.linspace(x_min, x_max, res),            \n",
    "        np.linspace(y_min, y_max, res)    \n",
    "    )\n",
    "    pressure_grid = np.full(xx.shape, 0).astype(float)\n",
    "    contour_coords = points[np.unique(contour)] \n",
    "    airfoil_path = Path(contour_coords)\n",
    "    inside_airfoil_mask = airfoil_path.contains_points(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)\n",
    "    bw_image = np.zeros((*pressure_grid.shape, 3), dtype=np.uint8) \n",
    "    for i in range(pressure_grid.shape[0]):\n",
    "        for j in range(pressure_grid.shape[1]):\n",
    "            if inside_airfoil_mask[i,j]:\n",
    "                bw_image[i,j] = inside_color      \n",
    "            else:\n",
    "                bw_image[i,j] = outside_color\n",
    "    if not os.path.exists(FOLDER):\n",
    "        os.makedirs(FOLDER)\n",
    "    filename = os.path.join(FOLDER, f'{identifier}_bw.png')\n",
    "    cv2.imwrite(filename, cv2.cvtColor(bw_image, cv2.COLOR_RGB2BGR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "39e3842a-c9cf-4cd0-a08d-30f987c26bd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_contour_black(points, contour, res, x_min, x_max, y_min, y_max):\n",
    "    \n",
    "    xx, yy = np.meshgrid(           \n",
    "        np.linspace(x_min, x_max, res),            \n",
    "        np.linspace(y_min, y_max, res)    \n",
    "    )\n",
    "    \n",
    "    contour_coords = points[np.unique(contour)] \n",
    "    \n",
    "    bw_image = np.full((*xx.shape, 3), 255, dtype=np.uint8) \n",
    "    \n",
    "    for i in range(xx.shape[0]):\n",
    "        for j in range(xx.shape[1]):\n",
    "            point = [xx[i, j], yy[i, j]]\n",
    "            \n",
    "            min_distance = np.min(distance.cdist([point], contour_coords))\n",
    "\n",
    "            if min_distance < 0.01:\n",
    "                bw_image[i, j] = [0, 0, 0] \n",
    "\n",
    "    cv2.imwrite('contour.png', bw_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cdb1357-6018-4f9f-9969-b234cbd406be",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Comparing the predicted image and the actual image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f3d1a75-decf-41e1-8bcc-5a39b7a7d0ea",
   "metadata": {},
   "source": [
    "## Comparing how much the airfoil regions overlap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "737b6802-78da-4557-ae9d-8231fed66265",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_last_image(img_name, start_row=112, start_col=112):\n",
    "    \"\"\"Extract the last image from a 2x2 grid image.\"\"\"\n",
    "    img = cv2.imread(img_name)\n",
    "    last_image = img[start_row:, start_col:]\n",
    "    \n",
    "    return last_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "fcedc3d0-67d7-4a85-af17-9ba8a5bd4f94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = extract_last_image(\"grid_1.png\")\n",
    "cv2.imwrite(\"extracted_image.png\", img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e50d8c3c-6ba2-4939-87df-a468b2663c95",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_binay_mask(image, threshold=50):\n",
    "    \"\"\"Create a binary mask to isolate the airfoil shape.\"\"\"\n",
    "    \n",
    "    # Convert the image to grayscale if it's not already.\n",
    "    if len(image.shape) == 3:\n",
    "        grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    else: \n",
    "        grayscale = image\n",
    "    \n",
    "    # Threshold the image to create a binary mask\n",
    "    _,binary_mask = cv2.threshold(grayscale, threshold, 255, cv2.THRESH_BINARY_INV)\n",
    "    \n",
    "    return binary_mask\n",
    "    # returns a binary image where the airfoil is white (255) and everything else is black (0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "2a03f89e-0317-402d-bc96-a83bfce92284",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_binay_mask_2(image, threshold=50):\n",
    "   \n",
    "    image = cv2.imread(image)  # difference compared to create_binary_mask\n",
    "    \n",
    "    if len(image.shape) == 3:\n",
    "        grayscale = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "    else: \n",
    "        grayscale = image\n",
    "    \n",
    "    _,binary_mask = cv2.threshold(grayscale, threshold, 255, cv2.THRESH_BINARY_INV)\n",
    "    \n",
    "    return binary_mask\n",
    "    # returns a binary image where the airfoil is white (255) and everything else is black (0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "id": "0f91a0b2-f56f-466d-9beb-7aa3fd42f3a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compare_airfoil_overlap(predicted_img, actual_img):\n",
    "    \n",
    "    # read image in grayscale\n",
    "    actual_img = cv2.imread(actual_img, cv2.IMREAD_GRAYSCALE)\n",
    "    predicted_img = cv2.imread(predicted_img, cv2.IMREAD_GRAYSCALE)\n",
    "    \n",
    "    # create binary masks for both images\n",
    "    predicted_mask = create_binay_mask(predicted_img)\n",
    "    actual_mask = create_binay_mask(actual_img)\n",
    "    \n",
    "    # convert the masks to boolean arrays\n",
    "    predicted_bool = (predicted_mask > 0)\n",
    "    actual_bool = (actual_mask > 0)\n",
    "    \n",
    "    # compute overlap \n",
    "    overlap = np.logical_and(predicted_bool, actual_bool)\n",
    "    # compute union\n",
    "    union = np.logical_or(predicted_bool, actual_bool)\n",
    "    \n",
    "    # calculate iou\n",
    "    iou = np.sum(overlap) / np.sum(union)\n",
    "    \n",
    "    # calculate the overlap percentage\n",
    "    total_pixels = np.prod(actual_bool.shape)\n",
    "    overlap_pixels = np.sum(overlap)\n",
    "    overlap_percentage = (overlap_pixels / total_pixels) * 100\n",
    "    \n",
    "    actual_airfoil_percentage = actual_bool.sum() / total_pixels * 100    \n",
    "    \n",
    "    return iou"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b58e668-ae6e-4530-85d7-7f3abb6634c7",
   "metadata": {},
   "source": [
    "## Comparing the generated image with the actual image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fba50eb-b315-463a-925b-e8cd2f1408ab",
   "metadata": {},
   "source": [
    "### Visual inspection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "732ac509-a209-4879-9cef-9dae1b556dfc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def overlay_difference(image_path1, image_path2, output_path='difference.png'):\n",
    "    image1 = cv2.imread(image_path1)\n",
    "    image2 = cv2.imread(image_path2)\n",
    "    \n",
    "    difference = cv2.absdiff(image1, image2)\n",
    "    \n",
    "    cv2.imwrite(output_path, difference)\n",
    "    # areas will be black if difference is 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "18726f7e-9613-40ee-9334-b67fb1a26191",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('extracted_image.png','actual_image.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87320a4f-6265-40d1-a0a3-165b3042d029",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Using MSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "9a0b55da-dc06-426d-8e32-0a7c5c15c175",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_mse(image_path1, image_path2):\n",
    "    image1 = cv2.imread(image_path1, cv2.IMREAD_GRAYSCALE)\n",
    "    image2 = cv2.imread(image_path2, cv2.IMREAD_GRAYSCALE)\n",
    "    \n",
    "    diff = cv2.subtract(image1, image2)\n",
    "    squared_diff = np.square(diff)\n",
    "    mse = squared_diff.mean()\n",
    "    \n",
    "    return mse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "99ce6847-84b1-4470-8d9f-4ef2955c7fd1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99.99832589285714"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('extracted_image.png','actual_image.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9063273-c09a-4ce4-9529-4b4f734d4120",
   "metadata": {},
   "source": [
    "### Using SSIM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "8a8aac4b-2dff-480e-bf52-ff5550877ff4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_ssim(image1_path, image2_path):\n",
    "    image1 = cv2.imread(image1_path, cv2.IMREAD_GRAYSCALE)\n",
    "    image2 = cv2.imread(image2_path, cv2.IMREAD_GRAYSCALE)\n",
    "    \n",
    "    score, _ = ssim(image1, image2, full=True)\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "53549012-d102-408c-81b5-bd9b148a9ec5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7756733528065535"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('extracted_image.png','actual_image.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64bc97df-2a5d-4845-92b2-1b9d92d81707",
   "metadata": {},
   "source": [
    "A value close to 1 means the two images are very similar. A value approacing 0 means significant differences between the images. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78fa9b14-48bd-4d9d-8d3d-7850c2b4d45a",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Using R^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "id": "5a2692fe-f114-4378-95b5-1b74d97880b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_r_squared(predicted_image_path, actual_image_path):\n",
    "    actual_img = cv2.imread(actual_image_path, cv2.IMREAD_GRAYSCALE)\n",
    "    predicted_img = cv2.imread(predicted_image_path, cv2.IMREAD_GRAYSCALE)\n",
    "    \n",
    "    residuals = actual_img - predicted_img\n",
    "    ss_res = np.sum(residuals**2) # sum of squares of the residuals\n",
    "    ss_tot = np.sum((actual_img - np.mean(actual_img))**2)  # total sum of squares\n",
    "    r_squared = 1 - (ss_res / ss_tot)\n",
    "    \n",
    "    return r_squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "af2f1abf-0bac-4487-b3b8-dda9909fda6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9621'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('actual_image.png', 'extracted_image.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53325e4e-e5f5-42cc-82e7-7a934acd0140",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Functions Loop Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "id": "76a1c923-d1fd-4179-bf6f-ffb3129dc52b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_presure_on_grid_LOOP(data, res, start_color, end_color, airfoil_color, x_min, x_max, y_min, y_max, FOLDER):\n",
    "    \n",
    "    for identifier, dataset in data.items():\n",
    "        points = dataset['points']\n",
    "        triangles = dataset['triangles']\n",
    "        pressure_coefs = dataset['pressure_coefs']\n",
    "        contour = dataset['contour']\n",
    "        boundary = dataset['boundary']\n",
    "        plot_pressure_on_grid_2(points, triangles, pressure_coefs, contour, boundary, res, start_color, end_color, airfoil_color, x_min, x_max, y_min, y_max, identifier, FOLDER)\n",
    "\n",
    "def plot_black_and_white_LOOP(data, res, inside_color, outside_color, x_min, x_max, y_min, y_max, FOLDER):\n",
    "    for identifier, dataset in data.items():\n",
    "        points = dataset['points']\n",
    "        triangles = dataset['triangles']\n",
    "        pressure_coefs = dataset['pressure_coefs']\n",
    "        contour = dataset['contour']\n",
    "        boundary = dataset['boundary']\n",
    "        plot_black_and_white_2(points, triangles, pressure_coefs, contour, boundary, res, inside_color, outside_color, x_min, x_max, y_min, y_max, identifier, FOLDER)\n",
    "        \n",
    "def extract_last_image_LOOP(folder_path, output_folder, start_row=112, start_col=112):\n",
    "    if not os.path.exists(output_folder):\n",
    "        os.makedirs(output_folder)\n",
    "    for filename in os.listdir(folder_path):\n",
    "        img_path = os.path.join(folder_path, filename)\n",
    "        img = cv2.imread(img_path)\n",
    "        last_image = img[start_row:, start_col:]\n",
    "        output_path = os.path.join(output_folder, f'{filename}')\n",
    "        cv2.imwrite(output_path, last_image)\n",
    "\n",
    "def compare_airfoil_overlap_LOOP(predicted_folder, actual_folder):\n",
    "    predicted_files = sorted([f for f in os.listdir(predicted_folder) if f.lower().endswith('.png')])  # IMPORTANT 这里是按顺序的\n",
    "    actual_files = sorted([f for f in os.listdir(actual_folder) if f.lower().endswith('.png')])\n",
    "    if len(predicted_files) != len(actual_files):\n",
    "        print(\"The number doesn't match.\")\n",
    "    results = []\n",
    "    for predicted_file, actual_file in zip(predicted_files, actual_files):\n",
    "        predicted_path = os.path.join(predicted_folder, predicted_file)\n",
    "        actual_path = os.path.join(actual_folder, actual_file)\n",
    "        iou = compare_airfoil_overlap(predicted_path, actual_path)\n",
    "        results.append(iou)\n",
    "    return np.array(results)\n",
    "\n",
    "def compute_mse_LOOP(predicted_folder, actual_folder):\n",
    "    predicted_files = sorted([f for f in os.listdir(predicted_folder) if f.lower().endswith('.png')]) \n",
    "    actual_files = sorted([f for f in os.listdir(actual_folder) if f.lower().endswith('.png')])\n",
    "    if len(predicted_files) != len(actual_files):\n",
    "        print(\"The number doesn't match.\")\n",
    "    results = []\n",
    "    for predicted_file, actual_file in zip(predicted_files, actual_files):\n",
    "        predicted_path = os.path.join(predicted_folder, predicted_file)\n",
    "        actual_path = os.path.join(actual_folder, actual_file)\n",
    "        mse = compute_mse(predicted_path, actual_path)\n",
    "        results.append(mse)\n",
    "    return np.array(results)\n",
    "\n",
    "def compute_ssim_LOOP(predicted_folder, actual_folder):\n",
    "    predicted_files = sorted([f for f in os.listdir(predicted_folder) if f.lower().endswith('.png')]) \n",
    "    actual_files = sorted([f for f in os.listdir(actual_folder) if f.lower().endswith('.png')])\n",
    "    if len(predicted_files) != len(actual_files):\n",
    "        print(\"The number doesn't match.\")\n",
    "    results = []\n",
    "    for predicted_file, actual_file in zip(predicted_files, actual_files):\n",
    "        predicted_path = os.path.join(predicted_folder, predicted_file)\n",
    "        actual_path = os.path.join(actual_folder, actual_file)\n",
    "        ssim = compute_ssim(predicted_path, actual_path)\n",
    "        results.append(ssim)\n",
    "    return np.array(results)\n",
    "\n",
    "def compute_r_squared_LOOP(predicted_folder, actual_folder):\n",
    "    predicted_files = sorted([f for f in os.listdir(predicted_folder) if f.lower().endswith('.png')]) \n",
    "    actual_files = sorted([f for f in os.listdir(actual_folder) if f.lower().endswith('.png')])\n",
    "    if len(predicted_files) != len(actual_files):\n",
    "        print(\"The number doesn't match.\")\n",
    "    results = []\n",
    "    for predicted_file, actual_file in zip(predicted_files, actual_files):\n",
    "        predicted_path = os.path.join(predicted_folder, predicted_file)\n",
    "        actual_path = os.path.join(actual_folder, actual_file)\n",
    "        r_squared = compute_r_squared(predicted_path, actual_path)\n",
    "        results.append(r_squared)\n",
    "    return np.array(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc39b50f-359d-4fed-9023-07abe9453555",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Airfoil Zoom-in Level"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b746ae3-4787-4171-ab7c-44316c4e9c8e",
   "metadata": {},
   "source": [
    "## Loop Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb523028-ac51-46d4-9966-df0c7b6393a9",
   "metadata": {},
   "source": [
    "Use`a` to predict `b`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "id": "dcb932bb-f96d-4f1c-87e1-656d30bf196c",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'mesh/size_a/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/size_a/'  # TO CHANGE\n",
    "data_size_a = read_in_many_files(FOLDER1, FOLDER2)\n",
    "\n",
    "FOLDER1 = 'mesh/size_b/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/size_b/'  # TO CHANGE\n",
    "data_size_b = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dcfb9ef-7857-468f-a544-5322b9d42a96",
   "metadata": {},
   "source": [
    "**SMALL**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "id": "22692c83-8759-46f0-acb3-629480f90806",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_size_a, 500, WHITE, BLACK, BLACK, -1, 2, -0.5, 0.5, 'size/a_small_500')\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_size_a, 500, BLACK, WHITE, -1, 2, -0.5, 0.5, 'size/a_small_500_bw')\n",
    "# 左下\n",
    "plot_black_and_white_LOOP(data_size_b, 500, BLACK, WHITE, -1, 2, -0.5, 0.5, 'size/b_small_500_bw')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f87e231-3fd0-429a-afd9-da226a6fd894",
   "metadata": {},
   "source": [
    "Use model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "id": "25f9d786-74e3-48d9-aa7c-02b5eb2b7e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = 'size/generated_grid/small'\n",
    "output_folder = 'size/extracted/small'\n",
    "extract_last_image_LOOP(input_folder, output_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "id": "c5cbd5fd-b4bd-42d7-9af5-3245251d1f39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_size_b, 112, WHITE, BLACK, BLACK, -1, 2, -0.5, 0.5, 'size/LR_112/small')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "483ce8e5-1cdc-46bf-91e5-f5a63dde97f6",
   "metadata": {},
   "source": [
    "**MEDIUM**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "id": "39cfde3a-400b-4818-92ee-208cfe896edc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_size_a, 500, WHITE, BLACK, BLACK, -0.6, 1.6, -0.3, 0.3, 'size/a_medium_500')\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_size_a, 500, BLACK, WHITE, -0.6, 1.6, -0.3, 0.3, 'size/a_medium_500_bw')\n",
    "# 左下\n",
    "plot_black_and_white_LOOP(data_size_b, 500, BLACK, WHITE, -0.6, 1.6, -0.3, 0.3, 'size/b_medium_500_bw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "id": "312150db-690d-4745-9ea5-b49bb6611500",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = 'size/generated_grid/middle'\n",
    "output_folder = 'size/extracted/middle'\n",
    "extract_last_image_LOOP(input_folder, output_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "id": "07da5208-2424-445d-879e-f6a74a41f409",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_size_b, 112, WHITE, BLACK, BLACK, -0.6, 1.6, -0.3, 0.3, 'size/LR_112/middle')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7793bf6-c201-4e0e-8e4c-07bbf14ea1b8",
   "metadata": {},
   "source": [
    "**LARGE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "id": "8df36612-2350-4707-adbd-118c8d6ad317",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_size_a, 500, WHITE, BLACK, BLACK, -0.2, 1.2, -0.15, 0.15, 'size/a_large_500')\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_size_a, 500, BLACK, WHITE, -0.2, 1.2, -0.15, 0.15, 'size/a_large_500_bw')\n",
    "# 左下\n",
    "plot_black_and_white_LOOP(data_size_b, 500, BLACK, WHITE, -0.2, 1.2, -0.15, 0.15, 'size/b_large_500_bw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "id": "fb28b1a9-63d7-4e11-a0a4-8a4e74be0739",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = 'size/generated_grid/large'\n",
    "output_folder = 'size/extracted/large'\n",
    "extract_last_image_LOOP(input_folder, output_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "id": "1b0469c5-f102-46e6-8dfa-f441a96410be",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_size_b, 112, WHITE, BLACK, BLACK, -0.2, 1.2, -0.15, 0.15, 'size/LR_112/large')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f53b46de-7b58-4076-98dd-a73ccb75ca5d",
   "metadata": {},
   "source": [
    "### Compare metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bd8e3a6-26b2-4a83-a2d3-f406b5c36f1e",
   "metadata": {},
   "source": [
    "**Airfoil Overlap**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "id": "69a4fa3e-4a12-4938-bd0d-d16288cb6193",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from small to medium: 85.00%\n",
      "Proportion of positive increase from medium to large: 85.00%\n",
      "\n",
      "t-statistic for small and medium: -4.4768\n",
      "p-value for small and medium: 0.0003\n",
      "SIGNIFICANT!\n",
      "\n",
      "t-statistic for medium and large: -3.4258\n",
      "p-value for medium and large: 0.0028\n",
      "SIGNIFICANT!\n"
     ]
    }
   ],
   "source": [
    "predicted_folder = 'size/extracted/small'\n",
    "actual_folder = 'size/LR_112/small'\n",
    "iou_small = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/medium'\n",
    "actual_folder = 'size/LR_112/medium'\n",
    "iou_medium = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/large'\n",
    "actual_folder = 'size/LR_112/large'\n",
    "iou_large = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff_1_2 = iou_medium - iou_small\n",
    "diff_2_3 = iou_large - iou_medium\n",
    "increase_1_2 = np.sum(diff_1_2 > 0) / len(diff_1_2) * 100\n",
    "increase_2_3 = np.sum(diff_2_3 > 0) / len(diff_2_3) * 100\n",
    "print(\"Proportion of positive increase from small to medium: {:.2f}%\".format(increase_1_2))\n",
    "print(\"Proportion of positive increase from medium to large: {:.2f}%\\n\".format(increase_2_3))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_small, iou_medium)\n",
    "print(\"t-statistic for small and medium: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for small and medium: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_medium, iou_large)\n",
    "print(\"t-statistic for medium and large: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for medium and large: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c496447-9cd6-4f32-a247-077b0fe097bc",
   "metadata": {},
   "source": [
    "**MSE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "id": "055c8656-8855-4c94-9476-44175e4ece0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive decrease from small to medium: 50.00%\n",
      "Proportion of positive decrease from medium to large: 90.00%\n",
      "\n",
      "t-statistic for small and medium: 1.0572\n",
      "p-value for small and medium: 0.3037\n",
      "NOT SIGNIFICANT.\n",
      "\n",
      "t-statistic for medium and large: 6.9695\n",
      "p-value for medium and large: 0.0000\n",
      "SIGNIFICANT!\n"
     ]
    }
   ],
   "source": [
    "predicted_folder = 'size/extracted/small'\n",
    "actual_folder = 'size/LR_112/small'\n",
    "mse_small = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/medium'\n",
    "actual_folder = 'size/LR_112/medium'\n",
    "mse_medium = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/large'\n",
    "actual_folder = 'size/LR_112/large'\n",
    "mse_large = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff_1_2 = mse_medium - mse_small\n",
    "diff_2_3 = mse_large - mse_medium\n",
    "decrease_1_2 = np.sum(diff_1_2 < 0) / len(diff_1_2) * 100\n",
    "decrease_2_3 = np.sum(diff_2_3 < 0) / len(diff_2_3) * 100\n",
    "print(\"Proportion of positive decrease from small to medium: {:.2f}%\".format(decrease_1_2))\n",
    "print(\"Proportion of positive decrease from medium to large: {:.2f}%\\n\".format(decrease_2_3))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_small, mse_medium)\n",
    "print(\"t-statistic for small and medium: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for small and medium: {:.4f}\".format(p_value))\n",
    "print(\"NOT SIGNIFICANT.\\n\")\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_medium, mse_large)\n",
    "print(\"t-statistic for medium and large: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for medium and large: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26fba131-b7da-45ec-8e49-d81df6bec1f1",
   "metadata": {},
   "source": [
    "**R_squared**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 426,
   "id": "d1318f1e-a60c-4fb3-80b7-b6f628560592",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from small to medium: 100.00%\n",
      "Proportion of positive increase from medium to large: 100.00%\n",
      "\n",
      "t-statistic for small and medium: -4.4655\n",
      "p-value for small and medium: 0.0003\n",
      "SIGNIFICANT!\n",
      "\n",
      "t-statistic for medium and large: -4.7435\n",
      "p-value for medium and large: 0.0001\n",
      "SIGNIFICANT!\n"
     ]
    }
   ],
   "source": [
    "predicted_folder = 'size/extracted/small'\n",
    "actual_folder = 'size/LR_112/small'\n",
    "r_small = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/medium'\n",
    "actual_folder = 'size/LR_112/medium'\n",
    "r_medium = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'size/extracted/large'\n",
    "actual_folder = 'size/LR_112/large'\n",
    "r_large = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff_1_2 = r_medium - r_small\n",
    "diff_2_3 = r_large - r_medium\n",
    "increase_1_2 = np.sum(diff_1_2 > 0) / len(diff_1_2) * 100\n",
    "increase_2_3 = np.sum(diff_2_3 > 0) / len(diff_2_3) * 100\n",
    "print(\"Proportion of positive increase from small to medium: {:.2f}%\".format(increase_1_2))\n",
    "print(\"Proportion of positive increase from medium to large: {:.2f}%\\n\".format(increase_2_3))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_small, r_medium)\n",
    "print(\"t-statistic for small and medium: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for small and medium: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_medium, r_large)\n",
    "print(\"t-statistic for medium and large: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for medium and large: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1357be6e-e800-40cf-9aae-f981dadddef5",
   "metadata": {},
   "source": [
    "## Single Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6eb6f2d-39ee-4178-9bed-7db616091823",
   "metadata": {},
   "source": [
    "Use 0013 to predict 0124. Change size only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "b06b8674-82d3-4587-8b64-31276705c43d",
   "metadata": {},
   "outputs": [],
   "source": [
    "points_0124, triangles_0124, contour_0124, boundary_0124, pressure_coefs_0124 = read_all_data('0124.su2', '0124.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "id": "78d03e90-cde1-4f84-9da6-c784aa5b1bf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "## SMALL\n",
    "# 右上\n",
    "plot_pressure_on_grid(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-1, x_max=2, y_min=-0.5, y_max=0.5)\n",
    "# 左上\n",
    "plot_black_and_white(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, inside_color=BLACK, outside_color=WHITE,  x_min=-1, x_max=2, y_min=-0.5, y_max=0.5)\n",
    "# 右下\n",
    "plot_black_and_white(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-1, x_max=2, y_min=-0.5, y_max=0.5)\n",
    "# 右下\n",
    "plot_black_and_white(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=112, inside_color=BLACK, outside_color=WHITE, x_min=-1, x_max=2, y_min=-0.5, y_max=0.5)\n",
    "\n",
    "img = extract_last_image(\"size/grid_small_0124.png\")\n",
    "cv2.imwrite(\"size/extracted_small.png\", img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "e414bdbd-d14b-4828-a377-32fe3ffeb4b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "## MEDIUM\n",
    "plot_black_and_white(points_0423, triangles_0423, pressure_coefs_0423, contour_0423, boundary_0423, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "plot_black_and_white(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "plot_pressure_on_grid(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3) # actual\n",
    "img = extract_last_image(\"size/grid_middle_0124.png\")\n",
    "cv2.imwrite(\"size/extracted_middle.png\", img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "d1cae777-cd0d-48d8-a5e4-72d6f927407c",
   "metadata": {},
   "outputs": [],
   "source": [
    "## LARGE\n",
    "plot_pressure_on_grid(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.2, x_max=1.2, y_min=-0.15, y_max=0.15)\n",
    "plot_black_and_white(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.2, x_max=1.2, y_min=-0.15, y_max=0.15)\n",
    "plot_black_and_white(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.2, x_max=1.2, y_min=-0.15, y_max=0.15)\n",
    "plot_black_and_white(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.2, x_max=1.2, y_min=-0.5, y_max=0.5) # MORE FLAT\n",
    "plot_pressure_on_grid(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.2, x_max=1.2, y_min=-0.15, y_max=0.15) # actual\n",
    "plot_pressure_on_grid(points_0124, triangles_0124, pressure_coefs_0124, contour_0124, boundary_0124, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.2, x_max=1.2, y_min=-0.5, y_max=0.5) # actual\n",
    "\n",
    "img = extract_last_image(\"size/grid_large_0124.png\")\n",
    "cv2.imwrite(\"size/extracted_large.png\", img)\n",
    "\n",
    "img = extract_last_image(\"size/grid_large_flat_0124.png\")\n",
    "cv2.imwrite(\"size/extracted_large_flat.png\", img)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5319c87-6a75-40ac-b0df-b936006cc1e2",
   "metadata": {},
   "source": [
    "### Compare Metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d423abf-68dc-4c13-a556-7b7659186e5c",
   "metadata": {},
   "source": [
    "**Airfoil IoU**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "9e0e9cbb-e7cb-424e-8965-fb3483ea723a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(463, 1000, '46.30%')"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('size/extracted_small.png','size/0124_actual_small.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "b4d5c834-54b7-4aca-b177-3e2f59a0efc1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1445, 2000, '72.25%')"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('size/extracted_middle.png','size/0124_actual_middle.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "0b3d111c-9a3a-4653-9eef-6fa9a7b01c0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4767, 5762, '82.73%')"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('size/extracted_large.png','size/0124_actual_large.png')  # significant improvement compared to small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "d00909ba-284e-4237-bd5e-fef0783dad80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1408, 1870, '75.29%')"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('size/extracted_large_flat.png','size/0124_actual_large_flat.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed75b09a-847a-4969-8614-06b4267fdaf3",
   "metadata": {},
   "source": [
    "**Visual Inspection**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "789ca2ac-63fd-4800-a469-12d0d036efa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('size/extracted_small.png','size/0124_actual_small.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "c8465532-9d91-4597-9363-bbb59b467fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('size/extracted_middle.png','size/0124_actual_middle.png') # quite good"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "c1022367-5ce5-4a9d-93fc-322963ed8887",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('size/extracted_large.png','size/0124_actual_large.png') # pretty good. airfoil area overlaps a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "1f596b6c-f936-41ae-8fb8-3d7f022f3832",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('size/extracted_large_flat.png','size/0124_actual_large_flat.png') # airfoil overlaps well"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f10bd49a-88b0-4ec4-90d1-a688165fbe97",
   "metadata": {},
   "source": [
    "**MSE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "39a25b5b-0d18-40b7-8c1e-3ca8e368e5e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101.3125"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('size/extracted_small.png','size/0124_actual_small.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "ddfe6edf-a909-4cc5-a9e4-cec391f40972",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "83.44427614795919"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('size/extracted_middle.png','size/0124_actual_middle.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "053c448e-982f-4469-a040-d9f4ce2c8ca3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52.15521364795919"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('size/extracted_large.png','size/0124_actual_large.png') # decreasing trend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "1ba21ff1-703c-4e40-b03f-10fb5cc1c666",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72.42458545918367"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('size/extracted_large_flat.png','size/0124_actual_large_flat.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "376a0e19-8ce4-4ffd-98ab-d5d4e501ff62",
   "metadata": {},
   "source": [
    "**SSIM**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "64684a59-3c56-464c-a057-849415005a23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6390489084700608"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('size/extracted_small.png','size/0124_actual_small.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "ce091070-f83e-4725-b0d5-e20019f1417e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6694754059821213"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('size/extracted_middle.png','size/0124_actual_middle.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "202b84a2-7cb7-4a65-acd2-8e4baf49e762",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7068277907471062"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('size/extracted_large.png','size/0124_actual_large.png')  # increasing trend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "04c11f18-5024-4d0b-acc6-2fbc7d41b9f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6418031312788608"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('size/extracted_large_flat.png','size/0124_actual_large_flat.png') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09e739f9-3cb8-430e-b0b2-70a212ba442c",
   "metadata": {},
   "source": [
    "**R-squared**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "3c80fad8-5c08-4aad-9b50-fb4e0f988501",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9661'"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('size/0124_actual_small.png','size/extracted_small.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "043e43c8-7b81-462e-af95-6951c162ff0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9814'"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('size/0124_actual_middle.png','size/extracted_middle.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "a3c5cee6-6cc0-492e-a61d-3abbbdc62f9d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9924'"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('size/0124_actual_large.png','size/extracted_large.png')  # increasing trend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "8afc7237-7005-4fed-85fa-da0edb608f9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9854'"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('size/0124_actual_large_flat.png','size/extracted_large_flat.png') "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd2ad3e-2c34-457a-afa3-76028e0e5402",
   "metadata": {},
   "source": [
    "# Does color help?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a15e5d2-e09d-4cee-87a5-d98a221e8653",
   "metadata": {},
   "source": [
    "## Single Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29af3b88-4afa-4244-b014-2e29e469f0bc",
   "metadata": {},
   "source": [
    "Using 0013 to predict 0027. The only variation is colored or bw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "c60bac56-2781-4d86-ad3f-5aee2354af10",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_pressure_on_grid(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, start_color=WHITE, end_color=BLUE, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "\n",
    "plot_black_and_white(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "\n",
    "plot_black_and_white(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "\n",
    "plot_pressure_on_grid(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "\n",
    "plot_pressure_on_grid(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)\n",
    "\n",
    "plot_pressure_on_grid(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=112, start_color=WHITE, end_color=BLUE, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "9f3e16a9-236c-442a-a34e-15c8676cb4bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "img = extract_last_image(\"color/grid_bw.png\")\n",
    "cv2.imwrite(\"color/extracted_bw.png\", img)\n",
    "\n",
    "img = extract_last_image(\"color/grid_color.png\")\n",
    "cv2.imwrite(\"color/extracted_color.png\", img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "id": "1704e8ad-715e-4cdd-9ef3-d25b4dec34a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7110923660902573"
      ]
     },
     "execution_count": 581,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('color/extracted_bw.png','color/0027_actual_112_bw.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "id": "615f5b61-b092-414c-b7a4-56bfb0243fc7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8300198807157058"
      ]
     },
     "execution_count": 582,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('color/extracted_color.png','color/0027_actual_112_color.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "6be174a6-9e21-423e-89c2-a11c581dc96e",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('color/extracted_bw.png','color/0027_actual_112_bw.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "24b72ffa-83c1-476a-8b76-e7383331b4a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('color/extracted_color.png','color/0027_actual_112_color.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "1c1130a7-d1ff-44a6-87a5-dc84c21b60db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84.4126275510204"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('color/extracted_bw.png','color/0027_actual_112_bw.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "76f3dbd7-e051-43f1-a8be-a6c84ba79600",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81.6328125"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('color/extracted_color.png','color/0027_actual_112_color.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "8c8755e9-589b-4ba1-b663-cca359edd736",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6401795029776779"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('color/extracted_bw.png','color/0027_actual_112_bw.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "8f82a031-c848-4302-a347-384b488817ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7441673413137828"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('color/extracted_color.png','color/0027_actual_112_color.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "38d99d1f-28cb-4ed5-a5a1-f214e600385d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9828'"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('color/0027_actual_112_bw.png', 'color/extracted_bw.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "910f422a-09b2-4347-85e1-5f07099a88d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9820'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('color/0027_actual_112_color.png', 'color/extracted_color.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e34db6f-2d21-41d8-9662-0937f3942d5c",
   "metadata": {},
   "source": [
    "## Loop Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60dcaec6-145f-4dbc-a01e-8adb4faece4a",
   "metadata": {},
   "source": [
    "Use a to predict b. Change color only."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 514,
   "id": "fff06049-18fe-4146-920f-2f937c29b280",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'color/original/color_a/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data_color_a = read_in_many_files(FOLDER1, FOLDER2)\n",
    "\n",
    "FOLDER1 = 'color/original/color_b/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data_color_b = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb821605-d5db-4a2c-b1b1-1b4953a82015",
   "metadata": {},
   "source": [
    "### Black and White Version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 522,
   "id": "f6a78c66-399b-48a6-856e-4d68c1c9102b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_color_a, 500, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/ur/black_and_white')\n",
    "\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_color_a, 500, BLACK, WHITE, -0.4, 1.4, -0.3, 0.3, 'color/ul')\n",
    "\n",
    "# 左下\n",
    "plot_black_and_white_LOOP(data_color_b, 500, BLACK, WHITE, -0.4, 1.4, -0.3, 0.3, 'color/ll')\n",
    "\n",
    "input_folder = 'color/generated_grid/black_and_white'\n",
    "output_folder = 'color/extracted/black_and_white'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_color_b, 112, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/lr/black_and_white')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9af8ff6f-1f9e-4548-985d-cb50416f796f",
   "metadata": {},
   "source": [
    "### Color Version (Blue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 523,
   "id": "2ce912cf-fb85-4f31-9b49-ab1cd99b5793",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_color_a, 500, WHITE, BLUE, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/ur/color')\n",
    "\n",
    "input_folder = 'color/generated_grid/color'\n",
    "output_folder = 'color/extracted/color'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_color_b, 112, WHITE, BLUE, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/lr/color')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb0c56de-175a-4cae-832e-2fe337f978c1",
   "metadata": {},
   "source": [
    "### Color Version (Red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "id": "f9151e67-e7da-478f-912d-fe72c76779cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_color_a, 500, WHITE, RED, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/ur/red')\n",
    "\n",
    "input_folder = 'color/generated_grid/red'\n",
    "output_folder = 'color/extracted/red'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_color_b, 112, WHITE, RED, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/lr/red')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9925aee-9755-462b-9673-5e055cd89d2b",
   "metadata": {},
   "source": [
    "### Color Version (Yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 549,
   "id": "4df2940e-b4d1-4be7-a1fd-6fc5850175d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_color_a, 500, WHITE, YELLOW, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/ur/yellow')\n",
    "\n",
    "input_folder = 'color/generated_grid/yellow'\n",
    "output_folder = 'color/extracted/yellow'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_color_b, 112, WHITE, YELLOW, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/lr/yellow')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ad3684b-493f-4bee-897f-22bfe761a23b",
   "metadata": {},
   "source": [
    "### Color Version (Green)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 550,
   "id": "0fdf25f0-cf04-4582-90c5-56538d0289a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_color_a, 500, WHITE, GREEN, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/ur/green')\n",
    "\n",
    "input_folder = 'color/generated_grid/green'\n",
    "output_folder = 'color/extracted/green'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_presure_on_grid_LOOP(data_color_b, 112, WHITE, GREEN, BLACK, -0.4, 1.4, -0.3, 0.3, 'color/lr/green')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1612cbf2-9079-45d9-8efc-eb6f06e50a51",
   "metadata": {},
   "source": [
    "### Compare Metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b563ba5-d1af-483f-8a3c-d89d232126e2",
   "metadata": {},
   "source": [
    "#### Airfoil overlap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 531,
   "id": "583191d8-8f7e-43d7-9651-7958303c9caf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from bw to color: 84.00%\n",
      "t-statistic for bw and color: -3.8249\n",
      "p-value for bw and color: 0.0008\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_bw:\n",
      " [0.66443515 0.61127273 0.71179951 0.73471539 0.72584856 0.70691676\n",
      " 0.6202765  0.63435583 0.76476907 0.79495942 0.67222767 0.75107632\n",
      " 0.715      0.62236842 0.69430052 0.69724409 0.58797041 0.74668142\n",
      " 0.51238165 0.52078337 0.70872274 0.56637737 0.75848913 0.72397869\n",
      " 0.78151862]\n",
      "iou_color:\n",
      " [0.69881711 0.66342649 0.71706904 0.75494071 0.7436182  0.7591267\n",
      " 0.61171797 0.61766024 0.73103448 0.83514407 0.69048474 0.7726087\n",
      " 0.81442495 0.70567195 0.78153697 0.76740009 0.65962264 0.80735478\n",
      " 0.76616915 0.53912257 0.72064601 0.60899131 0.79143228 0.69575758\n",
      " 0.85720199]\n"
     ]
    }
   ],
   "source": [
    "# BLUE\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "iou_bw = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/color'\n",
    "actual_folder = 'color/lr/color'\n",
    "iou_color = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = iou_color - iou_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from bw to color: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_bw, iou_color)\n",
    "print(\"t-statistic for bw and color: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and color: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_bw:\\n\", iou_bw)\n",
    "print(\"iou_color:\\n\", iou_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 552,
   "id": "d86354b0-2bde-471e-9373-4b3b6ba55666",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from bw to red: 96.00%\n",
      "t-statistic for bw and red: -6.1465\n",
      "p-value for bw and red: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_bw:\n",
      " [0.66443515 0.61127273 0.71179951 0.73471539 0.72584856 0.70691676\n",
      " 0.6202765  0.63435583 0.76476907 0.79495942 0.67222767 0.75107632\n",
      " 0.715      0.62236842 0.69430052 0.69724409 0.58797041 0.74668142\n",
      " 0.51238165 0.52078337 0.70872274 0.56637737 0.75848913 0.72397869\n",
      " 0.78151862]\n",
      "iou_red:\n",
      " [0.78365385 0.67235637 0.75555556 0.77559549 0.78170144 0.77739726\n",
      " 0.64488017 0.64178381 0.77210884 0.83014354 0.7143951  0.76972184\n",
      " 0.80887097 0.80750894 0.80583942 0.76961909 0.68057722 0.80232058\n",
      " 0.74015411 0.57122093 0.73846843 0.63760751 0.79920036 0.71803415\n",
      " 0.8716303 ]\n"
     ]
    }
   ],
   "source": [
    "# RED\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "iou_bw = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/red'\n",
    "actual_folder = 'color/lr/red'\n",
    "iou_red = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = iou_red - iou_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from bw to red: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_bw, iou_red)\n",
    "print(\"t-statistic for bw and red: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and red: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_bw:\\n\", iou_bw)\n",
    "print(\"iou_red:\\n\", iou_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "id": "10764dea-e854-4e3b-bf7b-477ed20996c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from bw to yellow: 96.00%\n",
      "t-statistic for bw and yellow: -7.0184\n",
      "p-value for bw and yellow: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_bw:\n",
      " [0.66443515 0.61127273 0.71179951 0.73471539 0.72584856 0.70691676\n",
      " 0.6202765  0.63435583 0.76476907 0.79495942 0.67222767 0.75107632\n",
      " 0.715      0.62236842 0.69430052 0.69724409 0.58797041 0.74668142\n",
      " 0.51238165 0.52078337 0.70872274 0.56637737 0.75848913 0.72397869\n",
      " 0.78151862]\n",
      "iou_yellow:\n",
      " [0.75012494 0.72957111 0.75954023 0.80769231 0.78716356 0.80487805\n",
      " 0.67128603 0.62573964 0.83435961 0.87118469 0.76803279 0.75729572\n",
      " 0.82419899 0.80012771 0.85942492 0.75963827 0.68122638 0.83333333\n",
      " 0.78011644 0.58714703 0.74267101 0.62955466 0.80129991 0.72825617\n",
      " 0.87302305]\n"
     ]
    }
   ],
   "source": [
    "# YELLOW\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "iou_bw = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/yellow'\n",
    "actual_folder = 'color/lr/yellow'\n",
    "iou_yellow = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = iou_yellow - iou_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from bw to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_bw, iou_yellow)\n",
    "print(\"t-statistic for bw and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_bw:\\n\", iou_bw)\n",
    "print(\"iou_yellow:\\n\", iou_yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 554,
   "id": "6c53fcf2-6801-419e-bbd6-c49a35d4d274",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from bw to green: 100.00%\n",
      "t-statistic for bw and green: -9.6985\n",
      "p-value for bw and green: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_bw:\n",
      " [0.66443515 0.61127273 0.71179951 0.73471539 0.72584856 0.70691676\n",
      " 0.6202765  0.63435583 0.76476907 0.79495942 0.67222767 0.75107632\n",
      " 0.715      0.62236842 0.69430052 0.69724409 0.58797041 0.74668142\n",
      " 0.51238165 0.52078337 0.70872274 0.56637737 0.75848913 0.72397869\n",
      " 0.78151862]\n",
      "iou_green:\n",
      " [0.82959641 0.7325529  0.77134986 0.81241915 0.80795778 0.77933384\n",
      " 0.70005414 0.6781721  0.83716707 0.8974359  0.74633373 0.78362573\n",
      " 0.81132861 0.82569361 0.82637475 0.79942693 0.71696574 0.84009009\n",
      " 0.78565102 0.6269305  0.78877128 0.67169657 0.83908582 0.76015727\n",
      " 0.88379341]\n"
     ]
    }
   ],
   "source": [
    "# GREEN\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "iou_bw = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/green'\n",
    "actual_folder = 'color/lr/green'\n",
    "iou_green = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = iou_green - iou_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from bw to green: {:.2f}%\".format(increase))  # iou效果非常好\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_bw, iou_green)\n",
    "print(\"t-statistic for bw and green: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and green: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_bw:\\n\", iou_bw)\n",
    "print(\"iou_green:\\n\", iou_green)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 583,
   "id": "649bd7e8-e898-4fee-9564-0c37770171c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from blue to red: 80.00%\n",
      "t-statistic for blue and red: -4.1433\n",
      "p-value for blue and red: 0.0004\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_color:\n",
      " [0.69881711 0.66342649 0.71706904 0.75494071 0.7436182  0.7591267\n",
      " 0.61171797 0.61766024 0.73103448 0.83514407 0.69048474 0.7726087\n",
      " 0.81442495 0.70567195 0.78153697 0.76740009 0.65962264 0.80735478\n",
      " 0.76616915 0.53912257 0.72064601 0.60899131 0.79143228 0.69575758\n",
      " 0.85720199]\n",
      "iou_red:\n",
      " [0.78365385 0.67235637 0.75555556 0.77559549 0.78170144 0.77739726\n",
      " 0.64488017 0.64178381 0.77210884 0.83014354 0.7143951  0.76972184\n",
      " 0.80887097 0.80750894 0.80583942 0.76961909 0.68057722 0.80232058\n",
      " 0.74015411 0.57122093 0.73846843 0.63760751 0.79920036 0.71803415\n",
      " 0.8716303 ]\n"
     ]
    }
   ],
   "source": [
    "# BLUE AND RED: RED BETTER\n",
    "diff = iou_red - iou_color\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from blue to red: {:.2f}%\".format(increase))  # iou效果非常好\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_color, iou_red)\n",
    "print(\"t-statistic for blue and red: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for blue and red: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_color:\\n\", iou_color)\n",
    "print(\"iou_red:\\n\", iou_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 571,
   "id": "9c0d7538-2020-4988-bd10-faeee61ce32f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from red to yellow: 76.00%\n",
      "t-statistic for red and yellow: -3.0957\n",
      "p-value for red and yellow: 0.0049\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_red:\n",
      " [0.78365385 0.67235637 0.75555556 0.77559549 0.78170144 0.77739726\n",
      " 0.64488017 0.64178381 0.77210884 0.83014354 0.7143951  0.76972184\n",
      " 0.80887097 0.80750894 0.80583942 0.76961909 0.68057722 0.80232058\n",
      " 0.74015411 0.57122093 0.73846843 0.63760751 0.79920036 0.71803415\n",
      " 0.8716303 ]\n",
      "iou_yellow:\n",
      " [0.75012494 0.72957111 0.75954023 0.80769231 0.78716356 0.80487805\n",
      " 0.67128603 0.62573964 0.83435961 0.87118469 0.76803279 0.75729572\n",
      " 0.82419899 0.80012771 0.85942492 0.75963827 0.68122638 0.83333333\n",
      " 0.78011644 0.58714703 0.74267101 0.62955466 0.80129991 0.72825617\n",
      " 0.87302305]\n"
     ]
    }
   ],
   "source": [
    "# RED AND YELLOW：YELLOW BETTER\n",
    "diff = iou_yellow - iou_red\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from red to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_red, iou_yellow)\n",
    "print(\"t-statistic for red and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for red and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_red:\\n\", iou_red)\n",
    "print(\"iou_yellow:\\n\", iou_yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 573,
   "id": "a5f43440-fe3f-4597-bbf0-ddcfe060000d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of positive increase from green to yellow: 16.00%\n",
      "t-statistic for green and yellow: 3.7011\n",
      "p-value for green and yellow: 0.0011\n",
      "SIGNIFICANT!\n",
      "\n",
      "iou_green:\n",
      " [0.82959641 0.7325529  0.77134986 0.81241915 0.80795778 0.77933384\n",
      " 0.70005414 0.6781721  0.83716707 0.8974359  0.74633373 0.78362573\n",
      " 0.81132861 0.82569361 0.82637475 0.79942693 0.71696574 0.84009009\n",
      " 0.78565102 0.6269305  0.78877128 0.67169657 0.83908582 0.76015727\n",
      " 0.88379341]\n",
      "iou_yellow:\n",
      " [0.75012494 0.72957111 0.75954023 0.80769231 0.78716356 0.80487805\n",
      " 0.67128603 0.62573964 0.83435961 0.87118469 0.76803279 0.75729572\n",
      " 0.82419899 0.80012771 0.85942492 0.75963827 0.68122638 0.83333333\n",
      " 0.78011644 0.58714703 0.74267101 0.62955466 0.80129991 0.72825617\n",
      " 0.87302305]\n"
     ]
    }
   ],
   "source": [
    "# GREEN AND YELLOW: green larger (better)\n",
    "diff = iou_yellow - iou_green\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of positive increase from green to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_green, iou_yellow)\n",
    "print(\"t-statistic for green and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for green and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"iou_green:\\n\", iou_green)\n",
    "print(\"iou_yellow:\\n\", iou_yellow)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83cb6922-014d-407e-b5f6-a0e06a786d73",
   "metadata": {},
   "source": [
    "#### MSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "id": "85b7b10d-bd3b-4149-b874-d1b02170b108",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from bw to color: 88.00%\n",
      "t-statistic for bw and color: 5.0574\n",
      "p-value for bw and color: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_bw:\n",
      " [78.70296556 36.30245536 22.96109694 32.17370855 40.18821747 46.0444037\n",
      " 67.72951212 64.9190051  40.1661352  36.57581314 35.34789541 63.75255102\n",
      " 38.61128827 64.63942921 55.82940051 41.40425702 50.81648597 37.98134566\n",
      " 63.1558514  71.03188776 42.46420599 60.75813138 33.35586735 39.29567921\n",
      " 33.9740912 ]\n",
      "mse_color:\n",
      " [48.4634088  27.18423151 35.11981824 33.29121492 25.8330676  27.08673469\n",
      " 52.68662309 39.17195472 24.62404337 30.50143495 34.15617028 32.14827806\n",
      " 32.37619579 36.0020727  22.7635523  40.63990753 40.26929209 38.22441008\n",
      " 35.71029974 52.20304528 35.81831952 51.39564732 33.2574139  32.49944196\n",
      " 31.22472895]\n"
     ]
    }
   ],
   "source": [
    "# BLUE\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "mse_bw = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/color'\n",
    "actual_folder = 'color/lr/color'\n",
    "mse_color = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = mse_color - mse_bw\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from bw to color: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_bw, mse_color)\n",
    "print(\"t-statistic for bw and color: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and color: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_bw:\\n\", mse_bw)\n",
    "print(\"mse_color:\\n\", mse_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "id": "7cfa7dc5-60da-422e-87f4-8924cb5af433",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from bw to red: 24.00%\n",
      "t-statistic for bw and red: -2.2113\n",
      "p-value for bw and red: 0.0368\n",
      "SIGNIFICANT!\n",
      "BW VERSION IS BETTER\n",
      "\n",
      "mse_bw:\n",
      " [78.70296556 36.30245536 22.96109694 32.17370855 40.18821747 46.0444037\n",
      " 67.72951212 64.9190051  40.1661352  36.57581314 35.34789541 63.75255102\n",
      " 38.61128827 64.63942921 55.82940051 41.40425702 50.81648597 37.98134566\n",
      " 63.1558514  71.03188776 42.46420599 60.75813138 33.35586735 39.29567921\n",
      " 33.9740912 ]\n",
      "mse_red:\n",
      " [79.16573661 38.69754464 31.40058992 48.8125     47.97018495 50.74362245\n",
      " 79.95192921 71.44196429 45.13871173 31.62858737 45.14508929 67.94977679\n",
      " 52.91501913 44.71316964 43.30125957 45.64867666 56.47177934 43.20248724\n",
      " 71.23732462 69.96037946 40.45838648 59.49641263 35.7964764  43.00693559\n",
      " 40.15967793]\n"
     ]
    }
   ],
   "source": [
    "# RED\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "mse_bw = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/red'\n",
    "actual_folder = 'color/lr/red'\n",
    "mse_red = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = mse_red - mse_bw\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from bw to red: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_bw, mse_red)\n",
    "print(\"t-statistic for bw and red: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and red: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")\n",
    "print(\"BW VERSION IS BETTER\\n\")\n",
    "\n",
    "print(\"mse_bw:\\n\", mse_bw)\n",
    "print(\"mse_red:\\n\", mse_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "id": "275116e1-6f3d-4fa1-a4dd-e78d0063dc9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from bw to yellow: 100.00%\n",
      "t-statistic for bw and yellow: 12.1566\n",
      "p-value for bw and yellow: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_bw:\n",
      " [78.70296556 36.30245536 22.96109694 32.17370855 40.18821747 46.0444037\n",
      " 67.72951212 64.9190051  40.1661352  36.57581314 35.34789541 63.75255102\n",
      " 38.61128827 64.63942921 55.82940051 41.40425702 50.81648597 37.98134566\n",
      " 63.1558514  71.03188776 42.46420599 60.75813138 33.35586735 39.29567921\n",
      " 33.9740912 ]\n",
      "mse_yellow:\n",
      " [ 6.54360651 11.71795281 14.24736926 11.85068559 11.26713967 12.3881537\n",
      "  9.81927615 15.06752232 12.52032844  6.66557717 11.68231824 21.3934949\n",
      "  9.40888074 13.67235332 15.56871811 16.39827806 22.23413584  9.2290338\n",
      " 13.82557398 14.22496811  9.41334503 12.29280931  7.8934949  10.59773597\n",
      " 12.05731824]\n"
     ]
    }
   ],
   "source": [
    "# YELLOW\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "mse_bw = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/yellow'\n",
    "actual_folder = 'color/lr/yellow'\n",
    "mse_yellow = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = mse_yellow - mse_bw\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from bw to yellow: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_bw, mse_yellow)                    # 黄色效果非常好\n",
    "print(\"t-statistic for bw and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_bw:\\n\", mse_bw)\n",
    "print(\"mse_yellow:\\n\", mse_yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 562,
   "id": "bd942d2f-3170-400a-b98e-5d38adacf8ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from bw to green: 80.00%\n",
      "t-statistic for bw and green: 4.2700\n",
      "p-value for bw and green: 0.0003\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_bw:\n",
      " [78.70296556 36.30245536 22.96109694 32.17370855 40.18821747 46.0444037\n",
      " 67.72951212 64.9190051  40.1661352  36.57581314 35.34789541 63.75255102\n",
      " 38.61128827 64.63942921 55.82940051 41.40425702 50.81648597 37.98134566\n",
      " 63.1558514  71.03188776 42.46420599 60.75813138 33.35586735 39.29567921\n",
      " 33.9740912 ]\n",
      "mse_green:\n",
      " [35.09255421 33.82453763 28.37053571 29.17904974 36.86208546 35.15553253\n",
      " 37.52192283 15.32828444  7.07653061 37.6278699  29.19961735 25.83641582\n",
      " 38.99481824 19.16358418 44.09941008 39.05923151 31.11033163 29.02000957\n",
      " 46.8178412  37.51753827 37.61918048 43.03627232 40.36583227 34.3227838\n",
      " 38.38137755]\n"
     ]
    }
   ],
   "source": [
    "# GREEN\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "mse_bw = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/green'\n",
    "actual_folder = 'color/lr/green'\n",
    "mse_green = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = mse_green - mse_bw\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from bw to green: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_bw, mse_green)                    # 绿色效果也不错\n",
    "print(\"t-statistic for bw and green: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and green: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_bw:\\n\", mse_bw)\n",
    "print(\"mse_green:\\n\", mse_green)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 574,
   "id": "b1c24944-5ebf-4938-a78b-14fdd16acdf3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from red to blue: 96.00%\n",
      "t-statistic for red and blue: 7.0755\n",
      "p-value for red and blue: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_red:\n",
      " [79.16573661 38.69754464 31.40058992 48.8125     47.97018495 50.74362245\n",
      " 79.95192921 71.44196429 45.13871173 31.62858737 45.14508929 67.94977679\n",
      " 52.91501913 44.71316964 43.30125957 45.64867666 56.47177934 43.20248724\n",
      " 71.23732462 69.96037946 40.45838648 59.49641263 35.7964764  43.00693559\n",
      " 40.15967793]\n",
      "mse_blue:\n",
      " [48.4634088  27.18423151 35.11981824 33.29121492 25.8330676  27.08673469\n",
      " 52.68662309 39.17195472 24.62404337 30.50143495 34.15617028 32.14827806\n",
      " 32.37619579 36.0020727  22.7635523  40.63990753 40.26929209 38.22441008\n",
      " 35.71029974 52.20304528 35.81831952 51.39564732 33.2574139  32.49944196\n",
      " 31.22472895]\n"
     ]
    }
   ],
   "source": [
    "# BLUE AND RED: BLUE GOOD\n",
    "diff = mse_color - mse_red\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from red to blue: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_red, mse_color)\n",
    "print(\"t-statistic for red and blue: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for red and blue: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_red:\\n\", mse_red)\n",
    "print(\"mse_blue:\\n\", mse_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "id": "0e462ecc-8aea-4c1f-bb44-25b4e22d5d56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from blue to yellow: 100.00%\n",
      "t-statistic for yellow and blue: -12.5463\n",
      "p-value for yellow and blue: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_yellow:\n",
      " [ 6.54360651 11.71795281 14.24736926 11.85068559 11.26713967 12.3881537\n",
      "  9.81927615 15.06752232 12.52032844  6.66557717 11.68231824 21.3934949\n",
      "  9.40888074 13.67235332 15.56871811 16.39827806 22.23413584  9.2290338\n",
      " 13.82557398 14.22496811  9.41334503 12.29280931  7.8934949  10.59773597\n",
      " 12.05731824]\n",
      "mse_blue:\n",
      " [48.4634088  27.18423151 35.11981824 33.29121492 25.8330676  27.08673469\n",
      " 52.68662309 39.17195472 24.62404337 30.50143495 34.15617028 32.14827806\n",
      " 32.37619579 36.0020727  22.7635523  40.63990753 40.26929209 38.22441008\n",
      " 35.71029974 52.20304528 35.81831952 51.39564732 33.2574139  32.49944196\n",
      " 31.22472895]\n"
     ]
    }
   ],
   "source": [
    "# BLUE AND YELLOW: YELLOW BEST\n",
    "diff = mse_yellow - mse_color\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from blue to yellow: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_yellow, mse_color)\n",
    "print(\"t-statistic for yellow and blue: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for yellow and blue: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_yellow:\\n\", mse_yellow)\n",
    "print(\"mse_blue:\\n\", mse_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "id": "4fb15f58-4af9-4a28-9473-afb44d7d950b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of decrease from green to yellow: 96.00%\n",
      "t-statistic for yellow and green: -9.8027\n",
      "p-value for yellow and green: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "mse_yellow:\n",
      " [ 6.54360651 11.71795281 14.24736926 11.85068559 11.26713967 12.3881537\n",
      "  9.81927615 15.06752232 12.52032844  6.66557717 11.68231824 21.3934949\n",
      "  9.40888074 13.67235332 15.56871811 16.39827806 22.23413584  9.2290338\n",
      " 13.82557398 14.22496811  9.41334503 12.29280931  7.8934949  10.59773597\n",
      " 12.05731824]\n",
      "mse_green:\n",
      " [35.09255421 33.82453763 28.37053571 29.17904974 36.86208546 35.15553253\n",
      " 37.52192283 15.32828444  7.07653061 37.6278699  29.19961735 25.83641582\n",
      " 38.99481824 19.16358418 44.09941008 39.05923151 31.11033163 29.02000957\n",
      " 46.8178412  37.51753827 37.61918048 43.03627232 40.36583227 34.3227838\n",
      " 38.38137755]\n"
     ]
    }
   ],
   "source": [
    "# GREEN AND YELLOW: YELLOW BEST\n",
    "diff = mse_yellow - mse_green\n",
    "decrease = np.sum(diff < 0) / len(diff) * 100\n",
    "print(\"Proportion of decrease from green to yellow: {:.2f}%\".format(decrease))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_yellow, mse_green)\n",
    "print(\"t-statistic for yellow and green: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for yellow and green: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"mse_yellow:\\n\", mse_yellow)\n",
    "print(\"mse_green:\\n\", mse_green)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b38928a-1da1-4f65-a412-424847d7bc1b",
   "metadata": {},
   "source": [
    "#### R^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 536,
   "id": "3878481a-3126-4932-9f82-b209952437b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from bw to color: 28.00%\n",
      "t-statistic for bw and color: 1.7332\n",
      "p-value for bw and color: 0.0959\n",
      "NOT SIGNIFICANT!\n",
      "\n",
      "R^2_bw:\n",
      " [0.98414701 0.98791296 0.99170938 0.99031848 0.99164113 0.99104383\n",
      " 0.9875777  0.98855968 0.98678474 0.99035749 0.99278927 0.98857069\n",
      " 0.99135016 0.98624656 0.98911204 0.98891832 0.98917258 0.98782763\n",
      " 0.98859946 0.98784074 0.99196617 0.98803847 0.99171165 0.99161611\n",
      " 0.99152008]\n",
      "R^2_color:\n",
      " [0.98805718 0.98519133 0.98834876 0.98778155 0.98907172 0.99009536\n",
      " 0.98733004 0.99136982 0.98866372 0.98900366 0.98921039 0.99177598\n",
      " 0.98805428 0.98766987 0.98826332 0.98813848 0.98887193 0.98726067\n",
      " 0.98790955 0.98876577 0.9898538  0.98865528 0.98881642 0.98987431\n",
      " 0.9886846 ]\n"
     ]
    }
   ],
   "source": [
    "# BLUE\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "r_bw = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/color'\n",
    "actual_folder = 'color/lr/color'\n",
    "r_color = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = r_color - r_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from bw to color: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_bw, r_color)\n",
    "print(\"t-statistic for bw and color: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and color: {:.4f}\".format(p_value))\n",
    "print(\"NOT SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_bw:\\n\", r_bw)\n",
    "print(\"R^2_color:\\n\", r_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "id": "f36fdfda-5384-40ab-84bf-ad1ef4dab810",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from bw to red: 44.00%\n",
      "t-statistic for bw and red: 1.5043\n",
      "p-value for bw and red: 0.1456\n",
      "NOT SIGNIFICANT!\n",
      "\n",
      "R^2_bw:\n",
      " [0.98414701 0.98791296 0.99170938 0.99031848 0.99164113 0.99104383\n",
      " 0.9875777  0.98855968 0.98678474 0.99035749 0.99278927 0.98857069\n",
      " 0.99135016 0.98624656 0.98911204 0.98891832 0.98917258 0.98782763\n",
      " 0.98859946 0.98784074 0.99196617 0.98803847 0.99171165 0.99161611\n",
      " 0.99152008]\n",
      "R^2_red:\n",
      " [0.98168225 0.98830363 0.99212453 0.98892835 0.98996809 0.99019326\n",
      " 0.98410663 0.9866273  0.98700884 0.99116795 0.98989865 0.9866429\n",
      " 0.99028129 0.98767627 0.98878035 0.99025018 0.98996971 0.99068486\n",
      " 0.98675066 0.9865767  0.99118029 0.98931313 0.99223369 0.99198476\n",
      " 0.99144538]\n"
     ]
    }
   ],
   "source": [
    "# RED\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "r_bw = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/red'\n",
    "actual_folder = 'color/lr/red'\n",
    "r_red = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = r_red - r_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from bw to red: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_bw, r_red)\n",
    "print(\"t-statistic for bw and red: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and red: {:.4f}\".format(p_value))\n",
    "print(\"NOT SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_bw:\\n\", r_bw)\n",
    "print(\"R^2_red:\\n\", r_red)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 565,
   "id": "ba5a359a-944d-4de3-97bc-070c3e609c99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from bw to yellow: 100.00%\n",
      "t-statistic for bw and yellow: -19.7390\n",
      "p-value for bw and yellow: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "R^2_bw:\n",
      " [0.98414701 0.98791296 0.99170938 0.99031848 0.99164113 0.99104383\n",
      " 0.9875777  0.98855968 0.98678474 0.99035749 0.99278927 0.98857069\n",
      " 0.99135016 0.98624656 0.98911204 0.98891832 0.98917258 0.98782763\n",
      " 0.98859946 0.98784074 0.99196617 0.98803847 0.99171165 0.99161611\n",
      " 0.99152008]\n",
      "R^2_yellow:\n",
      " [0.99667734 0.99633123 0.99718902 0.99696921 0.99718209 0.99748532\n",
      " 0.99710512 0.9970804  0.99680503 0.99696114 0.99758815 0.9967562\n",
      " 0.99757375 0.99662054 0.99702464 0.9973615  0.99714903 0.99794246\n",
      " 0.99754321 0.9967666  0.99785248 0.99755771 0.99723026 0.99738905\n",
      " 0.99731607]\n"
     ]
    }
   ],
   "source": [
    "# YELLOW\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "r_bw = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/yellow'\n",
    "actual_folder = 'color/lr/yellow'\n",
    "r_yellow = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = r_yellow - r_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from bw to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_bw, r_yellow)                    # 黄色效果非常好\n",
    "print(\"t-statistic for bw and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_bw:\\n\", r_bw)\n",
    "print(\"R^2_yellow:\\n\", r_yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 566,
   "id": "e2509db6-0870-44be-8e77-bb0fa4231162",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from bw to green: 60.00%\n",
      "t-statistic for bw and green: -3.2752\n",
      "p-value for bw and green: 0.0032\n",
      "SIGNIFICANT!\n",
      "\n",
      "R^2_bw:\n",
      " [0.98414701 0.98791296 0.99170938 0.99031848 0.99164113 0.99104383\n",
      " 0.9875777  0.98855968 0.98678474 0.99035749 0.99278927 0.98857069\n",
      " 0.99135016 0.98624656 0.98911204 0.98891832 0.98917258 0.98782763\n",
      " 0.98859946 0.98784074 0.99196617 0.98803847 0.99171165 0.99161611\n",
      " 0.99152008]\n",
      "R^2_green:\n",
      " [0.98831065 0.98935549 0.99165092 0.99028574 0.9900718  0.99074628\n",
      " 0.98974143 0.99322682 0.98882632 0.98999305 0.99092364 0.99301322\n",
      " 0.99211092 0.99065462 0.98754147 0.9910368  0.99358684 0.991954\n",
      " 0.99004913 0.99088393 0.99127326 0.99203906 0.99131917 0.992581\n",
      " 0.99035851]\n"
     ]
    }
   ],
   "source": [
    "# GREEN\n",
    "predicted_folder = 'color/extracted/black_and_white'\n",
    "actual_folder = 'color/lr/black_and_white'\n",
    "r_bw = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'color/extracted/green'\n",
    "actual_folder = 'color/lr/green'\n",
    "r_green = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "diff = r_green - r_bw\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from bw to green: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_bw, r_green)                  # 绿色效果还可以 \n",
    "print(\"t-statistic for bw and green: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for bw and green: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_bw:\\n\", r_bw)\n",
    "print(\"R^2_green:\\n\", r_green)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 577,
   "id": "0669164d-3482-4830-a263-66a44dc32ecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from red to blue: 28.00%\n",
      "t-statistic for red and blue: 0.5066\n",
      "p-value for bw and blue: 0.6171\n",
      "NOT SIGNIFICANT!\n",
      "\n",
      "R^2_red:\n",
      " [0.98168225 0.98830363 0.99212453 0.98892835 0.98996809 0.99019326\n",
      " 0.98410663 0.9866273  0.98700884 0.99116795 0.98989865 0.9866429\n",
      " 0.99028129 0.98767627 0.98878035 0.99025018 0.98996971 0.99068486\n",
      " 0.98675066 0.9865767  0.99118029 0.98931313 0.99223369 0.99198476\n",
      " 0.99144538]\n",
      "R^2_blue:\n",
      " [0.98805718 0.98519133 0.98834876 0.98778155 0.98907172 0.99009536\n",
      " 0.98733004 0.99136982 0.98866372 0.98900366 0.98921039 0.99177598\n",
      " 0.98805428 0.98766987 0.98826332 0.98813848 0.98887193 0.98726067\n",
      " 0.98790955 0.98876577 0.9898538  0.98865528 0.98881642 0.98987431\n",
      " 0.9886846 ]\n"
     ]
    }
   ],
   "source": [
    "# BLUE AND RED: 差不多\n",
    "diff = r_color - r_red\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from red to blue: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_red, r_color)\n",
    "print(\"t-statistic for red and blue: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for red and blue: {:.4f}\".format(p_value))\n",
    "print(\"NOT SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_red:\\n\", r_red)\n",
    "print(\"R^2_blue:\\n\", r_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "id": "870d14ca-6f5a-41ac-91ba-60f73c7deda5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from blue to yellow: 100.00%\n",
      "t-statistic for blue and yellow: -32.6433\n",
      "p-value for blue and yellow: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "R^2_blue:\n",
      " [0.98805718 0.98519133 0.98834876 0.98778155 0.98907172 0.99009536\n",
      " 0.98733004 0.99136982 0.98866372 0.98900366 0.98921039 0.99177598\n",
      " 0.98805428 0.98766987 0.98826332 0.98813848 0.98887193 0.98726067\n",
      " 0.98790955 0.98876577 0.9898538  0.98865528 0.98881642 0.98987431\n",
      " 0.9886846 ]\n",
      "R^2_yellow:\n",
      " [0.99667734 0.99633123 0.99718902 0.99696921 0.99718209 0.99748532\n",
      " 0.99710512 0.9970804  0.99680503 0.99696114 0.99758815 0.9967562\n",
      " 0.99757375 0.99662054 0.99702464 0.9973615  0.99714903 0.99794246\n",
      " 0.99754321 0.9967666  0.99785248 0.99755771 0.99723026 0.99738905\n",
      " 0.99731607]\n"
     ]
    }
   ],
   "source": [
    "# BLUE AND YELLOW: YELLOW BEST\n",
    "diff = r_yellow - r_color\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from blue to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_color, r_yellow)\n",
    "print(\"t-statistic for blue and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for blue and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_blue:\\n\", r_color)\n",
    "print(\"R^2_yellow:\\n\", r_yellow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "id": "a9e1950c-751f-4a74-a6b4-baad42b41879",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proportion of increase from green to yellow: 100.00%\n",
      "t-statistic for green and yellow: -22.5735\n",
      "p-value for green and yellow: 0.0000\n",
      "SIGNIFICANT!\n",
      "\n",
      "R^2_green:\n",
      " [0.98831065 0.98935549 0.99165092 0.99028574 0.9900718  0.99074628\n",
      " 0.98974143 0.99322682 0.98882632 0.98999305 0.99092364 0.99301322\n",
      " 0.99211092 0.99065462 0.98754147 0.9910368  0.99358684 0.991954\n",
      " 0.99004913 0.99088393 0.99127326 0.99203906 0.99131917 0.992581\n",
      " 0.99035851]\n",
      "R^2_yellow:\n",
      " [0.99667734 0.99633123 0.99718902 0.99696921 0.99718209 0.99748532\n",
      " 0.99710512 0.9970804  0.99680503 0.99696114 0.99758815 0.9967562\n",
      " 0.99757375 0.99662054 0.99702464 0.9973615  0.99714903 0.99794246\n",
      " 0.99754321 0.9967666  0.99785248 0.99755771 0.99723026 0.99738905\n",
      " 0.99731607]\n"
     ]
    }
   ],
   "source": [
    "# GREEN AND YELLOW: YELLOW BEST\n",
    "diff = r_yellow - r_green\n",
    "increase = np.sum(diff > 0) / len(diff) * 100\n",
    "print(\"Proportion of increase from green to yellow: {:.2f}%\".format(increase))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_green, r_yellow)\n",
    "print(\"t-statistic for green and yellow: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for green and yellow: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\\n\")\n",
    "\n",
    "print(\"R^2_green:\\n\", r_green)\n",
    "print(\"R^2_yellow:\\n\", r_yellow)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74cb1a4c-fb28-44f8-8f27-0321d0725ceb",
   "metadata": {},
   "source": [
    "# Compare: 1. Using B's coordinates and A's pressure   2. Generated B from model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3424d51-50d5-4f96-b768-3bf43c2a5530",
   "metadata": {},
   "source": [
    "**Example: A: 0719; B:0013. Use 0719 to predict 0013**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "0ba4f796-8984-4a8a-b2f7-e1dd2519bf4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_pressure_on_grid(points_0013, triangles_0013, pressure_coefs_0013, contour_0013, boundary_0013, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.3, y_max=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "d0137462-c554-47e7-9583-8eb286947b3d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(835, 1236, '67.56%')"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('compare_a_b/extracted_0013.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "d60dea2b-1511-4045-bc31-7069246d44f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(863, 901, '95.78%')"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('compare_a_b/0013_with_0719_pressure.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "de10353b-43ef-452a-a9f1-355d02a0ebed",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('compare_a_b/extracted_0013.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "ec80ec1f-8697-4fc0-b081-a1c4311a50ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('compare_a_b/0013_with_0719_pressure.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "a6f0bef1-8b90-49d5-a8d8-6fbf3aa3726d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7213416091155113"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('compare_a_b/extracted_0013.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "22c75d0a-e845-4186-aaf8-4469e2a4a4f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.612882653061224"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('compare_a_b/extracted_0013.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "4c5ea3f6-1642-408d-a27b-6c935ed4b1a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.53515625"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('compare_a_b/0013_with_0719_pressure.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "843d1b52-e1e1-4207-8276-61997a99bf02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8765252969260813"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('compare_a_b/0013_with_0719_pressure.png','compare_a_b/0013_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "f4fd9ff3-d4cc-410c-823a-f63a1a851538",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9817'"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('compare_a_b/0013_actual_112.png', 'compare_a_b/extracted_0013.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "0bd6d0dd-9f0e-400e-9310-6e2f691e1d90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9724'"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('compare_a_b/0013_actual_112.png', 'compare_a_b/0013_with_0719_pressure.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a80c2a6d-a518-4fe9-8d2d-53672c50c5e1",
   "metadata": {},
   "source": [
    "# Aggregation Task"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9857849e-d46d-4cae-9313-7ce61ba9ef21",
   "metadata": {},
   "source": [
    "## Loop Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d83819a1-ca01-4244-b605-d63d22047aa8",
   "metadata": {},
   "source": [
    "Use airfoil 0027 as main subject. Choose 50 airfoils for using model. Use the same 50 airfoils for coordinates-pressure replacement. Compare result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d87c9895-34e3-4a28-82d6-d6ce09a50c85",
   "metadata": {},
   "source": [
    "1. Using Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "id": "0f2a8567-56b8-4a1b-91ca-fa467c6bfd8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'aggregation/original/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "id": "75f54702-b5f4-47de-b583-c21b6962b196",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data, 500, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'aggregation/actual')\n",
    "# 左上\n",
    "plot_black_and_white_LOOP(data, 500, BLACK, WHITE, -0.4, 1.4, -0.3, 0.3, 'aggregation/actual_bw')\n",
    "# 左下\n",
    "plot_black_and_white(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=500, inside_color=BLACK, outside_color=WHITE, x_min=-0.4, x_max=1.4, y_min=-0.3, y_max=0.3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 439,
   "id": "f93f61bc-b602-4c51-8907-65c4b016671f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# use model\n",
    "input_folder = 'aggregation/generated_grid'\n",
    "output_folder = 'aggregation/extracted'\n",
    "extract_last_image_LOOP(input_folder, output_folder)\n",
    "\n",
    "# 右下\n",
    "plot_pressure_on_grid(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.4, x_max=1.4, y_min=-0.3, y_max=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "id": "9336ffa4-506c-4b00-ae2c-0a320493c86b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def aggregate_images_mean(folder_path):\n",
    "    \n",
    "    image_files = [f for f in os.listdir(folder_path) if f.endswith('.png')]\n",
    "    image_sum = None\n",
    "    \n",
    "    for image_file in image_files:\n",
    "        image_path = os.path.join(folder_path, image_file)\n",
    "        image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
    "        if image_sum is None:\n",
    "            image_sum = np.zeros_like(image, dtype=np.float64)\n",
    "        image_sum += image\n",
    "    \n",
    "    mean_image = image_sum / len(image_files)\n",
    "    mean_image = np.clip(mean_image, 0, 255).astype(np.uint8)\n",
    "    \n",
    "    return mean_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "id": "6bc001d7-2191-4b04-8cf6-abefc371ca5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 442,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "folder_path = 'aggregation/extracted'\n",
    "mean_image = aggregate_images_mean(folder_path)\n",
    "cv2.imwrite('aggregation/mean_image_from_model_LOOP.png', mean_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2514b6-9e54-4597-8320-77ec41c0a45c",
   "metadata": {},
   "source": [
    "2. Use 0027's coordinates and other airfoils' pressure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 454,
   "id": "96212cb7-3535-47bf-b503-cde87ec5d8c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_in_many_files_2(FOLDER1, FOLDER2):\n",
    "    files_in_folder_1 = os.listdir(FOLDER1)\n",
    "    data = {}\n",
    "    for file1 in files_in_folder_1:\n",
    "        identifier = get_identifier(file1)\n",
    "        file2 = str(identifier) + '.csv'\n",
    "        if file2 in os.listdir(FOLDER2):\n",
    "            points, triangles, contour, boundary, pressure_coefs = read_all_data(file1, file2)\n",
    "        # store in dictionary\n",
    "        data[identifier] = {  \n",
    "                'points': points_0027,\n",
    "                'triangles': triangles_0027,\n",
    "                'contour': contour_0027,\n",
    "                'boundary': boundary_0027,\n",
    "                'pressure_coefs': pressure_coefs}\n",
    "    return data\n",
    "\n",
    "FOLDER1 = 'aggregation/original/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data = read_in_many_files_2(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "id": "da87e8bf-1293-44a0-a9a9-2dd739cadd6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_presure_on_grid_LOOP(data, 112, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'aggregation/actual_2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "id": "89365aa1-7de9-4229-9f40-ee52fcbc93a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "folder_path = 'aggregation/actual_2'\n",
    "mean_image = aggregate_images_mean(folder_path)\n",
    "cv2.imwrite('aggregation/mean_image_from_other_airfoils.png', mean_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19eda1c9-0b9f-469b-97ab-6d24c3da7cf6",
   "metadata": {},
   "source": [
    "### Compare Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 593,
   "id": "0d6f19c9-4c13-41f5-b131-c32843f5e883",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7088978396191871"
      ]
     },
     "execution_count": 593,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# IoU\n",
    "compare_airfoil_overlap('aggregation/result/mean_image_from_model_LOOP.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "id": "6f1eab28-e410-498d-a894-f44ff720da40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9420743639921723"
      ]
     },
     "execution_count": 466,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('aggregation/mean_image_from_other_airfoils.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 587,
   "id": "142b0f4a-e4d9-4b64-9fc9-81056562b83a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.732211706975114"
      ]
     },
     "execution_count": 587,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('aggregation/extracted/1.png', 'aggregation/0027_actual_112_LOOP.png') # single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 467,
   "id": "a8cd480c-3033-419a-899c-e2bef0014092",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8281972802542195"
      ]
     },
     "execution_count": 467,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SSIM\n",
    "compute_ssim('aggregation/mean_image_from_model_LOOP.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 468,
   "id": "a5ef6796-5be4-4438-b25f-c5ce1af33b0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9533368125054992"
      ]
     },
     "execution_count": 468,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('aggregation/mean_image_from_other_airfoils.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "id": "92711d90-981e-4d77-b4b3-db6ddd74d34a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6873163876826218"
      ]
     },
     "execution_count": 588,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('aggregation/extracted/1.png', 'aggregation/0027_actual_112_LOOP.png')  # single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 469,
   "id": "25545b65-1c41-449e-a638-20567bd29dbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.347735969387756"
      ]
     },
     "execution_count": 469,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MSE\n",
    "compute_mse('aggregation/mean_image_from_model_LOOP.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 470,
   "id": "7cb2b302-717d-488a-b18f-1aca89851985",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.23126594387755"
      ]
     },
     "execution_count": 470,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('aggregation/mean_image_from_other_airfoils.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "id": "e91978b0-6535-468d-a86e-0121353faaa4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80.77758290816327"
      ]
     },
     "execution_count": 589,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('aggregation/extracted/1.png', 'aggregation/0027_actual_112_LOOP.png')  # single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "id": "b362be0f-c2b4-4a67-9c6e-9982943a1069",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9922710859305456"
      ]
     },
     "execution_count": 471,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# R\n",
    "compute_r_squared('aggregation/mean_image_from_model_LOOP.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 472,
   "id": "baba4031-d4c3-44f1-80f1-656b9610f0fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9969190006743079"
      ]
     },
     "execution_count": 472,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('aggregation/mean_image_from_other_airfoils.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 590,
   "id": "47571107-9810-41bf-99d7-145f5f40f12b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9862905969304264"
      ]
     },
     "execution_count": 590,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('aggregation/extracted/1.png', 'aggregation/0027_actual_112_LOOP.png') # single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 473,
   "id": "df8334c1-b220-418b-bf6f-020d6c5d7259",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Overlay\n",
    "overlay_difference('aggregation/mean_image_from_model_LOOP.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 474,
   "id": "99101f6f-5b40-49e1-a7c9-9c6d2ac602e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('aggregation/mean_image_from_other_airfoils.png','aggregation/0027_actual_112_LOOP.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 591,
   "id": "cb5e8b28-83ba-4999-b962-e670a263e6d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('aggregation/extracted/1.png', 'aggregation/0027_actual_112_LOOP.png') # single"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bca14855-267b-4b99-94c7-963fd843d436",
   "metadata": {},
   "source": [
    "## Single Version"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c34608b0-d6f5-4b9e-95bb-54fa002ad6bb",
   "metadata": {},
   "source": [
    "Use airfoil 0027 as main subject."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "8cfec8e7-0bc3-4f95-a2db-9374020596bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# subject\n",
    "points_0027, triangles_0027, contour_0027, boundary_0027, pressure_coefs_0027 = read_all_data('0027.su2', '0027.csv')\n",
    "# train\n",
    "points_0028, triangles_0028, contour_0028, boundary_0028, pressure_coefs_0028 = read_all_data('0028.su2', '0028.csv')\n",
    "points_0423, triangles_0423, contour_0423, boundary_0423, pressure_coefs_0423 = read_all_data('0423.su2', '0423.csv')\n",
    "points_0427, triangles_0427, contour_0427, boundary_0427, pressure_coefs_0427 = read_all_data('0427.su2', '0427.csv')\n",
    "points_0528, triangles_0528, contour_0528, boundary_0528, pressure_coefs_0528 = read_all_data('0528.su2', '0528.csv')\n",
    "points_0729, triangles_0729, contour_0729, boundary_0729, pressure_coefs_0729 = read_all_data('0729.su2', '0729.csv')\n",
    "points_2022, triangles_2022, contour_2022, boundary_2022, pressure_coefs_2022 = read_all_data('2022.su2', '2022.csv')\n",
    "points_2230, triangles_2230, contour_2230, boundary_2230, pressure_coefs_2230 = read_all_data('2230.su2', '2230.csv')\n",
    "points_2526, triangles_2526, contour_2526, boundary_2526, pressure_coefs_2526 = read_all_data('2526.su2', '2526.csv')\n",
    "points_23122, triangles_23122, contour_23122, boundary_23122, pressure_coefs_23122 = read_all_data('23122.su2', '23122.csv')\n",
    "points_24024, triangles_24024, contour_24024, boundary_24024, pressure_coefs_24024 = read_all_data('24024.su2', '24024.csv')                                                                                            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "e714a1ea-3615-4bdb-894d-0d762e94e844",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0027\n",
    "plot_pressure_on_grid(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "plot_pressure_on_grid(points_0027, triangles_0027, pressure_coefs_0027, contour_0027, boundary_0027, res=112, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "\n",
    "# 0028\n",
    "plot_pressure_on_grid(points_0028, triangles_0028, pressure_coefs_0028, contour_0028, boundary_0028, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0028, triangles_0028, pressure_coefs_0028, contour_0028, boundary_0028, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 0423\n",
    "plot_pressure_on_grid(points_0423, triangles_0423, pressure_coefs_0423, contour_0423, boundary_0423, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0423, triangles_0423, pressure_coefs_0423, contour_0423, boundary_0423, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 0427\n",
    "plot_pressure_on_grid(points_0427, triangles_0427, pressure_coefs_0427, contour_0427, boundary_0427, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0427, triangles_0427, pressure_coefs_0427, contour_0427, boundary_0427, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 0528\n",
    "plot_pressure_on_grid(points_0528, triangles_0528, pressure_coefs_0528, contour_0528, boundary_0528, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0528, triangles_0528, pressure_coefs_0528, contour_0528, boundary_0528, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 0729\n",
    "plot_pressure_on_grid(points_0729, triangles_0729, pressure_coefs_0729, contour_0729, boundary_0729, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_0729, triangles_0729, pressure_coefs_0729, contour_0729, boundary_0729, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 2022\n",
    "plot_pressure_on_grid(points_2022, triangles_2022, pressure_coefs_2022, contour_2022, boundary_2022, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_2022, triangles_2022, pressure_coefs_2022, contour_2022, boundary_2022, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 2230\n",
    "plot_pressure_on_grid(points_2230, triangles_2230, pressure_coefs_2230, contour_2230, boundary_2230, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_2230, triangles_2230, pressure_coefs_2230, contour_2230, boundary_2230, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 2526\n",
    "plot_pressure_on_grid(points_2526, triangles_2526, pressure_coefs_2526, contour_2526, boundary_2526, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_2526, triangles_2526, pressure_coefs_2526, contour_2526, boundary_2526, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 23122\n",
    "plot_pressure_on_grid(points_23122, triangles_23122, pressure_coefs_23122, contour_23122, boundary_23122, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_23122, triangles_23122, pressure_coefs_23122, contour_23122, boundary_23122, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) \n",
    "\n",
    "# 24024\n",
    "plot_pressure_on_grid(points_24024, triangles_24024, pressure_coefs_24024, contour_24024, boundary_24024, res=1000, start_color=WHITE, end_color=BLACK, airfoil_color=BLACK, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4)\n",
    "plot_black_and_white(points_24024, triangles_24024, pressure_coefs_24024, contour_24024, boundary_24024, res=1000, inside_color=BLACK, outside_color=WHITE, x_min=-0.6, x_max=1.6, y_min=-0.4, y_max=0.4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "ac46378a-706e-44a0-9e73-77e9638e7d21",
   "metadata": {},
   "outputs": [],
   "source": [
    "# EXTRACT LAST IMAGE\n",
    "img = extract_last_image(\"aggregation/0028_grid.png\")\n",
    "cv2.imwrite(\"extracted_0028.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/0423_grid.png\")\n",
    "cv2.imwrite(\"extracted_0423.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/0427_grid.png\")\n",
    "cv2.imwrite(\"extracted_0427.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/0528_grid.png\")\n",
    "cv2.imwrite(\"extracted_0528.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/0729_grid.png\")\n",
    "cv2.imwrite(\"extracted_0729.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/2022_grid.png\")\n",
    "cv2.imwrite(\"extracted_2022.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/2230_grid.png\")\n",
    "cv2.imwrite(\"extracted_2230.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/2526_grid.png\")\n",
    "cv2.imwrite(\"extracted_2526.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/23122_grid.png\")\n",
    "cv2.imwrite(\"extracted_23122.png\", img)\n",
    "\n",
    "img = extract_last_image(\"aggregation/24024_grid.png\")\n",
    "cv2.imwrite(\"extracted_24024.png\", img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "96672bd3-b094-4467-9206-596187bd2967",
   "metadata": {},
   "outputs": [],
   "source": [
    "def aggregate_images_mean(image_paths):\n",
    "    image_sum = None\n",
    "    for image_path in image_paths:\n",
    "        image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
    "        if image_sum is None:\n",
    "            image_sum = np.zeros_like(image, dtype=np.float64)\n",
    "        image_sum += image\n",
    "    mean_image = image_sum / len(image_paths)\n",
    "    mean_image = np.clip(mean_image, 0, 255).astype(np.uint8)\n",
    "    return mean_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "c6e1c865-166a-4fca-ab48-a526338f1bee",
   "metadata": {},
   "outputs": [],
   "source": [
    "image_paths = ['extracted/extracted_0028.png','extracted/extracted_0423.png','extracted/extracted_0427.png','extracted/extracted_0528.png',\n",
    "              'extracted/extracted_0729.png','extracted/extracted_2022.png','extracted/extracted_2230.png','extracted/extracted_23122.png',\n",
    "              'extracted/extracted_24024.png','extracted/extracted_2526.png']\n",
    "mean_image = aggregate_images_mean(image_paths)\n",
    "cv2.imwrite('mean_image.png', mean_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fab859e7-1a84-4b72-b162-f859a7ee96bc",
   "metadata": {},
   "source": [
    "### Aggregated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "75e30458-1a97-4ea9-9faa-f3d754f906ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1325, 1901, '69.70%')"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compare_airfoil_overlap('aggregation/mean_image.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "24a7e684-5fda-4083-98c5-6874ee375dc2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.35028698979592"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('aggregation/mean_image.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "70ed5173-5078-4891-848f-ce31021102ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8410392406525449"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('aggregation/mean_image.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "64a35ded-4e8d-47db-8731-675fcc45914b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9888'"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('aggregation/0027_actual_112.png', 'aggregation/mean_image.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "29bfec79-1c6a-4652-beaa-5b29e22e2d39",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('aggregation/mean_image.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8bfdf5d-0624-4126-9b77-e47cd2df712d",
   "metadata": {},
   "source": [
    "### Single"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "219147da-deef-4344-ba65-f7292fc186d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1127, 1777, '63.42%')"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# can change the choice of single image in the folder <extracted>\n",
    "compare_airfoil_overlap('extracted/extracted_23122.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "e90225de-5fae-408c-a99d-b868948f37ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "68.95575573979592"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_mse('extracted/extracted_23122.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "c745da65-e032-45d5-9994-2b9cb898c972",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.794232118736409"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_ssim('extracted/extracted_23122.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "c7502a73-3548-47d6-bd48-d840e95f0076",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9844'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "compute_r_squared('aggregation/0027_actual_112.png', 'extracted/extracted_23122.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "6b869f86-f430-4fcf-92b5-e6b1dffa32bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "overlay_difference('extracted/extracted_23122.png','aggregation/0027_actual_112.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fbd6266-978a-4b60-b1b6-7c62b4c22fb0",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Use Similar Airfoils or Unsimilar Airfoils"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe91853f-4302-4588-957a-9e8cb0332874",
   "metadata": {},
   "source": [
    "Use 10 similar airfoils to predict 0027. Use 10 unsimilar airfoils to predict the same airfoil."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "420c3457-80e6-4e68-a817-47e08dfd03bd",
   "metadata": {},
   "source": [
    "## Similar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "id": "a95b43ee-5526-454c-a068-1068beeeaf3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'alike/similar/original/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data_similar = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 476,
   "id": "e107a946-942d-4aef-8b3b-8add1820ed5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_similar, 500, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'alike/similar/actual')\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_similar, 500, BLACK, WHITE, -0.4, 1.4, -0.3, 0.3, 'alike/similar/bw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 483,
   "id": "740ff3f1-1907-493a-bc2f-958aa90e360a",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = 'alike/similar/generated_grid'\n",
    "output_folder = 'alike/similar/extracted/'\n",
    "extract_last_image_LOOP(input_folder, output_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b610c5d0-104f-4934-9590-93f226be45d3",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Unsimilar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "id": "f3dbf1b4-bf2a-4255-97a8-cc8130df65a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "FOLDER1 = 'alike/unsimilar/original/'  # TO CHANGE\n",
    "FOLDER2 = 'restart_csv/'  # TO CHANGE\n",
    "data_unsimilar = read_in_many_files(FOLDER1, FOLDER2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 481,
   "id": "27cd5a5f-c874-438c-9b89-77d33a733adc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 右上\n",
    "plot_presure_on_grid_LOOP(data_unsimilar, 500, WHITE, BLACK, BLACK, -0.4, 1.4, -0.3, 0.3, 'alike/unsimilar/actual')\n",
    "# 左上  \n",
    "plot_black_and_white_LOOP(data_unsimilar, 500, BLACK, WHITE, -0.4, 1.4, -0.3, 0.3, 'alike/unsimilar/bw')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 484,
   "id": "3c46419f-76bf-4158-aa63-48cce7747dd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "input_folder = 'alike/unsimilar/generated_grid'\n",
    "output_folder = 'alike/unsimilar/extracted/'\n",
    "extract_last_image_LOOP(input_folder, output_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67d476ac-e6c7-4eab-85d6-3a06a01791b5",
   "metadata": {},
   "source": [
    "## Compare metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 505,
   "id": "762b0309-23b1-4e18-abcc-62d5bce527ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IoU similar: [0.81549296 0.81538462 0.72863404 0.77106742 0.74399126 0.7621098\n",
      " 0.80900457 0.77425044 0.76917808 0.73977695]\n",
      "IoU unsimilar: [0.65846995 0.68376645 0.66869712 0.70479189 0.72892857 0.73364655\n",
      " 0.70688456 0.68062317 0.74208633 0.73361227]\n",
      "\n",
      "IoU similar mean: 0.773\n",
      "IoU unsimilar mean: 0.704\n",
      "\n",
      "t-statistic for similar and unsimilar: 4.2343\n",
      "p-value for similar and unsimilar: 0.0022\n"
     ]
    }
   ],
   "source": [
    "# iou\n",
    "predicted_folder = 'alike/similar/extracted'\n",
    "actual_folder = 'alike/similar/LR_112'\n",
    "iou_similar = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'alike/unsimilar/extracted'\n",
    "actual_folder = 'alike/unsimilar/LR_112'\n",
    "iou_unsimilar = compare_airfoil_overlap_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "print(\"IoU similar:\", iou_similar)\n",
    "print(\"IoU unsimilar:\", iou_unsimilar)\n",
    "print(\"\\nIoU similar mean: {:.3f}\".format(iou_similar.mean()))\n",
    "print(\"IoU unsimilar mean: {:.3f}\\n\".format(iou_unsimilar.mean()))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(iou_similar, iou_unsimilar)\n",
    "print(\"t-statistic for similar and unsimilar: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for similar and unsimilar: {:.4f}\".format(p_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 507,
   "id": "becc0998-7166-480b-b259-34722fc562d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE similar: [32.26618304 31.98294005 47.98612883 32.29328763 43.38185587 36.17753508\n",
      " 34.2158801  32.21843112 34.63448661 33.8569037 ]\n",
      "MSE unsimilar: [67.21635842 69.86981824 70.7869898  76.97608418 72.23580995 60.80524554\n",
      " 64.90186543 74.94355867 85.21556122 77.49067283]\n",
      "\n",
      "MSE similar mean: 35.901\n",
      "MSE unsimilar mean: 72.044\n",
      "\n",
      "t-statistic for similar and unsimilar: -12.2865\n",
      "p-value for similar and unsimilar: 0.0000\n",
      "SIGNIFICANT!\n"
     ]
    }
   ],
   "source": [
    "# MSE\n",
    "predicted_folder = 'alike/similar/extracted'\n",
    "actual_folder = 'alike/similar/LR_112'\n",
    "mse_similar = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'alike/unsimilar/extracted'\n",
    "actual_folder = 'alike/unsimilar/LR_112'\n",
    "mse_unsimilar = compute_mse_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "print(\"MSE similar:\", mse_similar)\n",
    "print(\"MSE unsimilar:\", mse_unsimilar)\n",
    "print(\"\\nMSE similar mean: {:.3f}\".format(mse_similar.mean()))\n",
    "print(\"MSE unsimilar mean: {:.3f}\\n\".format(mse_unsimilar.mean()))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(mse_similar, mse_unsimilar)\n",
    "print(\"t-statistic for similar and unsimilar: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for similar and unsimilar: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 508,
   "id": "70f47c26-4c17-4fcf-853c-a64e15d475a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R^2 similar: [0.99071126 0.99151518 0.99075085 0.99074352 0.99124421 0.99181375\n",
      " 0.99139851 0.99302711 0.99028966 0.99158272]\n",
      "R^2 unsimilar: [0.98695398 0.9859423  0.98582768 0.98620747 0.98649519 0.98861768\n",
      " 0.9889374  0.98731409 0.9866483  0.98659822]\n",
      "\n",
      "R^2 similar mean: 0.991\n",
      "R^2 unsimilar mean: 0.987\n",
      "\n",
      "t-statistic for similar and unsimilar: 13.0401\n",
      "p-value for similar and unsimilar: 0.0000\n",
      "SIGNIFICANT!\n"
     ]
    }
   ],
   "source": [
    "# R^2\n",
    "predicted_folder = 'alike/similar/extracted'\n",
    "actual_folder = 'alike/similar/LR_112'\n",
    "r_similar = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "predicted_folder = 'alike/unsimilar/extracted'\n",
    "actual_folder = 'alike/unsimilar/LR_112'\n",
    "r_unsimilar = compute_r_squared_LOOP(predicted_folder, actual_folder)\n",
    "\n",
    "print(\"R^2 similar:\", r_similar)\n",
    "print(\"R^2 unsimilar:\", r_unsimilar)\n",
    "print(\"\\nR^2 similar mean: {:.3f}\".format(r_similar.mean()))\n",
    "print(\"R^2 unsimilar mean: {:.3f}\\n\".format(r_unsimilar.mean()))\n",
    "\n",
    "t_statistic, p_value = stats.ttest_rel(r_similar, r_unsimilar)\n",
    "print(\"t-statistic for similar and unsimilar: {:.4f}\".format(t_statistic))\n",
    "print(\"p-value for similar and unsimilar: {:.4f}\".format(p_value))\n",
    "print(\"SIGNIFICANT!\")"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}