3_attempt to merge 3 images.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Main import block and TODO list\n",
    "\n",
    "# TODO: see how uri calculated the ridges\n",
    "\n",
    "# TODO: Perform Histogram equalization - start with it\n",
    "\n",
    "# TODO: \n",
    "# take integral from the Highest peak+-0.005 divide by integral of the entire graph \n",
    "# This will be the peakness measure for the PSD ==> The desired ridge index\n",
    "\n",
    "# TODO:\n",
    "# take integral from the Highest peak+-0.005 divide by integral of the entire graph - it's the peakness measure for the PSD\n",
    "# must select a peak above a min threshold in order to ignore noisy frequency\n",
    "# must ignore peaks above a certain threshold in order to detect meaningful frequency\n",
    "# run the PSD in moving windows every 200 px (deduced from the below PSD pointing to a freq of 1/0.02=50-> times 4= 200px)\n",
    "# and medianf the result of the windows\n",
    "\n",
    "# TODO:\n",
    "# Another alternative: (with Yariv)\n",
    "# Run PSD column by column - get the phase, freq, peakness and reconstruct an artificial ridge slice\n",
    "# from this - reconstruct a \"clean\" artificial ridge image\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.image as img\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import urllib.request\n",
    "import os\n",
    "import glob\n",
    "from scipy import ndimage\n",
    "from scipy import signal\n",
    "\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "\n",
    "import mahotas as mh\n",
    "from mahotas import polygon\n",
    "# import pymorph as pm\n",
    "\n",
    "import networkx as nx\n",
    "\n",
    "from scipy import ndimage as nd\n",
    "import skimage.transform as transform\n",
    "import skimage.morphology as mp\n",
    "import skimage.io as sio\n",
    "import scipy.misc as sm\n",
    "from skimage.filters import threshold_otsu, threshold_adaptive\n",
    "from skimage.feature import hessian_matrix, hessian_matrix_eigvals\n",
    "from skimage import exposure\n",
    "from skimage import data, img_as_float\n",
    "\n",
    "from bisect import bisect_left\n",
    "import math\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "code_folding": [
     4,
     7,
     25,
     33,
     46,
     52,
     58,
     68,
     74,
     79,
     103,
     120,
     126,
     146,
     158
    ],
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Utility functions\n",
    "def crop(image, ymin, ymax, xmin, xmax):\n",
    "    return image[ymin:ymax, xmin:xmax]\n",
    "\n",
    "def thresholded(image, val): \n",
    "    return np.logical_and(*[image[...] > val  for t in enumerate([0, 0])])\n",
    "\n",
    "def find_min_max_without_orphand_pixels(nonzero_dimension, crop_filter=20):\n",
    "    sorted = np.sort(nonzero_dimension)\n",
    "    prev=-1\n",
    "    min_val = sorted[0]\n",
    "    for i, x in enumerate(sorted[:100]):\n",
    "        if prev >= 0 and x - prev > crop_filter:\n",
    "            min_val = x\n",
    "        prev = x\n",
    "    prev=-1\n",
    "    max_val = sorted[-1]\n",
    "    for i, x in enumerate(sorted[-100:]):\n",
    "        if prev >= 0 and x - prev > crop_filter:\n",
    "            max_val = prev\n",
    "            break\n",
    "        prev = x\n",
    "    \n",
    "    return min_val, max_val\n",
    "\n",
    "def calc_min_max_coordinates(image, crop_val=50):\n",
    "    temp = thresholded(image, crop_val)\n",
    "    temp = temp * 1\n",
    "    temp = np.nonzero(temp)\n",
    "    ymin, ymax = find_min_max_without_orphand_pixels(temp[0])\n",
    "    xmin,xmax = find_min_max_without_orphand_pixels(temp[1])\n",
    "    return ymin, ymax, xmin, xmax\n",
    "\n",
    "def calc_min_max_coordinates_dynamic(image, cutoff=1):\n",
    "    temp = exposure.equalize_adapthist(image, clip_limit=0.03)\n",
    "    flat = np.sort(np.matrix.getA1(temp))\n",
    "    sum_all = np.sum(flat)\n",
    "    index = np.argmin(flat.cumsum() < (sum_all * cutoff))\n",
    "\n",
    "    temp = thresholded(temp, flat[index])\n",
    "    temp = temp * 1\n",
    "    temp = np.nonzero(temp)\n",
    "    ymin, ymax = find_min_max_without_orphand_pixels(temp[0])\n",
    "    xmin,xmax = find_min_max_without_orphand_pixels(temp[1])\n",
    "    return ymin, ymax, xmin, xmax\n",
    "\n",
    "def crop_full_scan(image):\n",
    "    temp = crop(image, 600, 4300, 1000, 6000)\n",
    "    ymin, ymax, xmin, xmax = calc_min_max_coordinates_dynamic(temp, cutoff=0.88)\n",
    "    temp = crop(image, 600+ymin, 600+ymax, 1000+xmin, 1000+xmax)\n",
    "    return temp, ymin, ymax, xmin, xmax\n",
    "\n",
    "def crop_thresholded(image):\n",
    "    temp = crop(image, 0, image.shape[0]-1, 0, image.shape[1]-1)\n",
    "    ymin, ymax, xmin, xmax = calc_min_max_coordinates_dynamic(temp, cutoff=0.82)\n",
    "    temp = crop(image, ymin, ymax, xmin, xmax)\n",
    "    return temp, ymin, ymax, xmin, xmax\n",
    "\n",
    "def read_and_crop(image_name):\n",
    "    if \"il239838\" in os.getcwd():\n",
    "        image = img.imread(\"/Users/il239838/Downloads/private/Thesis/Papyrus/jm_4a36716c764b6d6b4c442f464b3342347436653838673d3d/P598-Fg009-R/\" + image_name)\n",
    "    else:\n",
    "        f = urllib.request.urlopen(\"https://dl.dropboxusercontent.com/s/31b96942qdcn73k/\" + image_name)\n",
    "        image = img.imread(f, format='jpeg')\n",
    "\n",
    "    # Smart-crop the image to get rid of all the noise and redundant area\n",
    "    return crop_full_scan(image)\n",
    "\n",
    "def read_and_crop_full_path(image_path):\n",
    "    image = img.imread(image_path)\n",
    "\n",
    "    # Smart-crop the image to get rid of all the noise and redundant area\n",
    "    return crop_full_scan(image)\n",
    "\n",
    "def read_file_list_in_dir(dir_name, file_filter=\"*.jpg\"):\n",
    "    return glob.glob(\"/Users/il239838/Downloads/private/Thesis/Papyrus/jm_4a36716c764b6d6b4c442f464b3342347436653838673d3d/\" +\n",
    "                     dir_name + \"/\" + file_filter)\n",
    "\n",
    "# TODO: fix performance!!! http://scikit-image.org/docs/dev/user_guide/tutorial_parallelization.html\n",
    "def combine_3_images_to_RGB(red, green, blue):\n",
    "    new_image = np.empty((blue.shape[0],blue.shape[1],3))\n",
    "    for x in range(0, blue.shape[0]):\n",
    "        for y in range(0, blue.shape[1]):\n",
    "            new_image[x,y,0] = red[x,y]\n",
    "            new_image[x,y,1] = green[x,y]\n",
    "            new_image[x,y,2] = blue[x,y]\n",
    "    return new_image\n",
    "\n",
    "def slice_image_left_edge(original, width=200, rotate=0):\n",
    "    rot = ndimage.rotate(original, rotate)\n",
    "    # Slice the left slice of the so-called \"blue\" image\n",
    "    left_edge_orig = crop(rot, 1, 1400, 1, width)\n",
    "    left_edge_orig, ymin, ymax, xmin, xmax = crop_thresholded(left_edge_orig)\n",
    "\n",
    "    # Copy to a new array so we don't thrash the origin\n",
    "    left_edge = np.empty_like (left_edge_orig)\n",
    "    np.copyto(left_edge, left_edge_orig)\n",
    "\n",
    "    # Zero down low level \"noise\" values\n",
    "    low_values_indices = left_edge < 30  # Where values are low\n",
    "    left_edge[low_values_indices] = 0  # All low values set to 0\n",
    "    return left_edge, ymin+1, ymax+1400, xmin+1, xmax+width\n",
    "\n",
    "def get_best_angle_rotation(original, crop=True, width=200):\n",
    "    min_var = 99999999999\n",
    "    best_angle = -10\n",
    "    for x in range(-5,5):\n",
    "        if crop:            \n",
    "            rot_edge = slice_image_left_edge(original, width, x)\n",
    "        else:\n",
    "            rot_edge = ndimage.rotate(original, x)\n",
    "        left_var = np.var(rot_edge, axis=1)\n",
    "        # left_var = np.apply_along_axis(lambda v: np.var(v[np.nonzero(v)]), 1, rot_edge)\n",
    "        var_sum = np.sum(left_var)\n",
    "        if (var_sum < min_var):\n",
    "            min_var = var_sum\n",
    "            best_angle = x\n",
    "    print (\"best_angle=\"+str(best_angle))\n",
    "    return best_angle\n",
    "\n",
    "def do_ridge_filter(input):\n",
    "    # The ridge filter is the major eigenvalue of the Hessian matrix\n",
    "    hxx, hxy, hyy = hessian_matrix(input, sigma=5)\n",
    "    i1, i2 = hessian_matrix_eigvals(hxx, hxy, hyy)\n",
    "    return i2\n",
    "\n",
    "def get_signal_to_noise_ratio(input):\n",
    "    f, pxx = signal.welch(input)\n",
    "    #     print(\"VALUES: \")\n",
    "    #     print(f)\n",
    "    #     print(pxx)\n",
    "\n",
    "    bisect_val = bisect_left(f, 0.01)\n",
    "    noise_reduced_power = pxx[bisect_val:]\n",
    "    peak_index = np.argmax(noise_reduced_power)\n",
    "    peak_power = noise_reduced_power[peak_index] + noise_reduced_power[peak_index-1] + noise_reduced_power[peak_index+1]\n",
    "    total_power = np.sum(noise_reduced_power)\n",
    "    return peak_power / total_power\n",
    "     \n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "def get_image_ridge_index(image_path, rotate):\n",
    "    return get_image_ridge_index_file(read_and_crop_full_path(image_path))\n",
    "\n",
    "def get_image_ridge_index_file(image, rotate):\n",
    "    if (rotate == np.iinfo(np.int32).min):\n",
    "        best_rotation = get_best_angle_rotation(image, True, 280)\n",
    "    else:\n",
    "        best_rotation = rotate\n",
    "    \n",
    "    left_edge_rotated = slice_image_left_edge(image, 280, best_rotation)\n",
    "    left_ridge_filtered = do_ridge_filter(left_edge_rotated)\n",
    "    left_sum_filtered = np.sum(left_ridge_filtered, axis=1)\n",
    "    ridge_index = get_signal_to_noise_ratio(left_sum_filtered)\n",
    "    return ridge_index, best_rotation, image\n",
    "\n",
    "def get_image_ridge_index(image_path, rotate):\n",
    "    image = read_and_crop_full_path(image_path)\n",
    "    if (rotate == np.iinfo(np.int32).min):\n",
    "        best_rotation = get_best_angle_rotation(image, True, 280)\n",
    "    else:\n",
    "        best_rotation = rotate\n",
    "    \n",
    "    left_edge_rotated = slice_image_left_edge(image, 280, best_rotation)\n",
    "    left_ridge_filtered = do_ridge_filter(left_edge_rotated)\n",
    "    left_sum_filtered = np.sum(left_ridge_filtered, axis=1)\n",
    "    ridge_index = get_signal_to_noise_ratio(left_sum_filtered)\n",
    "    return ridge_index, best_rotation, image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Image utility functions (external source)\n",
    "def branchedPoints(skel):\n",
    "    branch1=np.array([[2, 1, 2], [1, 1, 1], [2, 2, 2]])\n",
    "    branch2=np.array([[1, 2, 1], [2, 1, 2], [1, 2, 1]])\n",
    "    branch3=np.array([[1, 2, 1], [2, 1, 2], [1, 2, 2]])\n",
    "    branch4=np.array([[2, 1, 2], [1, 1, 2], [2, 1, 2]])\n",
    "    branch5=np.array([[1, 2, 2], [2, 1, 2], [1, 2, 1]])\n",
    "    branch6=np.array([[2, 2, 2], [1, 1, 1], [2, 1, 2]])\n",
    "    branch7=np.array([[2, 2, 1], [2, 1, 2], [1, 2, 1]])\n",
    "    branch8=np.array([[2, 1, 2], [2, 1, 1], [2, 1, 2]])\n",
    "    branch9=np.array([[1, 2, 1], [2, 1, 2], [2, 2, 1]])\n",
    "    br1=mh.morph.hitmiss(skel,branch1)\n",
    "    br2=mh.morph.hitmiss(skel,branch2)\n",
    "    br3=mh.morph.hitmiss(skel,branch3)\n",
    "    br4=mh.morph.hitmiss(skel,branch4)\n",
    "    br5=mh.morph.hitmiss(skel,branch5)\n",
    "    br6=mh.morph.hitmiss(skel,branch6)\n",
    "    br7=mh.morph.hitmiss(skel,branch7)\n",
    "    br8=mh.morph.hitmiss(skel,branch8)\n",
    "    br9=mh.morph.hitmiss(skel,branch9)\n",
    "    return br1+br2+br3+br4+br5+br6+br7+br8+br9\n",
    "\n",
    "def endPoints(skel):\n",
    "    endpoint1=np.array([[0, 0, 0],\n",
    "                        [0, 1, 0],\n",
    "                        [2, 1, 2]])\n",
    "    \n",
    "    endpoint2=np.array([[0, 0, 0],\n",
    "                        [0, 1, 2],\n",
    "                        [0, 2, 1]])\n",
    "    \n",
    "    endpoint3=np.array([[0, 0, 2],\n",
    "                        [0, 1, 1],\n",
    "                        [0, 0, 2]])\n",
    "    \n",
    "    endpoint4=np.array([[0, 2, 1],\n",
    "                        [0, 1, 2],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint5=np.array([[2, 1, 2],\n",
    "                        [0, 1, 0],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint6=np.array([[1, 2, 0],\n",
    "                        [2, 1, 0],\n",
    "                        [0, 0, 0]])\n",
    "    \n",
    "    endpoint7=np.array([[2, 0, 0],\n",
    "                        [1, 1, 0],\n",
    "                        [2, 0, 0]])\n",
    "    \n",
    "    endpoint8=np.array([[0, 0, 0],\n",
    "                        [2, 1, 0],\n",
    "                        [1, 2, 0]])\n",
    "    \n",
    "    ep1=mh.morph.hitmiss(skel,endpoint1)\n",
    "    ep2=mh.morph.hitmiss(skel,endpoint2)\n",
    "    ep3=mh.morph.hitmiss(skel,endpoint3)\n",
    "    ep4=mh.morph.hitmiss(skel,endpoint4)\n",
    "    ep5=mh.morph.hitmiss(skel,endpoint5)\n",
    "    ep6=mh.morph.hitmiss(skel,endpoint6)\n",
    "    ep7=mh.morph.hitmiss(skel,endpoint7)\n",
    "    ep8=mh.morph.hitmiss(skel,endpoint8)\n",
    "    ep = ep1+ep2+ep3+ep4+ep5+ep6+ep7+ep8\n",
    "    return ep\n",
    "\n",
    "def pruning(skeleton, size):\n",
    "    '''remove iteratively end points \"size\" \n",
    "       times from the skeleton\n",
    "    '''\n",
    "    for i in range(0, size):\n",
    "        endpoints = endPoints(skeleton)\n",
    "        endpoints = np.logical_not(endpoints)\n",
    "        skeleton = np.logical_and(skeleton,endpoints)\n",
    "    return skeleton\n",
    "\n",
    "def plot_comparison(original, filtered, filter_name):\n",
    "\n",
    "    fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True, sharey=True)\n",
    "    ax1.imshow(original, cmap=plt.cm.gray)\n",
    "    ax1.set_title('original')\n",
    "    ax1.axis('off')\n",
    "    ax1.set_adjustable('box-forced')\n",
    "    ax2.imshow(filtered, cmap=plt.cm.gray)\n",
    "    ax2.set_title(filter_name)\n",
    "    ax2.axis('off')\n",
    "    ax2.set_adjustable('box-forced')\n",
    "    \n",
    "    \n",
    "def plot_img_and_hist(img, axes, bins=256):\n",
    "    \"\"\"Plot an image along with its histogram and cumulative histogram.\n",
    "\n",
    "    \"\"\"\n",
    "    img = img_as_float(img)\n",
    "    ax_img, ax_hist = axes\n",
    "    ax_cdf = ax_hist.twinx()\n",
    "\n",
    "    # Display image\n",
    "    ax_img.imshow(img, cmap=plt.cm.gray)\n",
    "    ax_img.set_axis_off()\n",
    "    ax_img.set_adjustable('box-forced')\n",
    "\n",
    "    # Display histogram\n",
    "    ax_hist.hist(img.ravel(), bins=bins, histtype='step', color='black')\n",
    "    ax_hist.ticklabel_format(axis='y', style='scientific', scilimits=(0, 0))\n",
    "    ax_hist.set_xlabel('Pixel intensity')\n",
    "    ax_hist.set_xticks([])\n",
    "    ax_hist.set_yticks([])\n",
    "\n",
    "    # Display cumulative distribution\n",
    "    img_cdf, bins = exposure.cumulative_distribution(img, bins)\n",
    "    ax_cdf.plot(bins, img_cdf, 'r')\n",
    "    ax_cdf.set_yticks([])\n",
    "\n",
    "    return ax_img, ax_hist, ax_cdf\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "code_folding": [
     0
    ],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------INDEX:0.474053059054\n"
     ]
    }
   ],
   "source": [
    "# merge 3 images in a linear average and check if the ridge index is better... hint: NO!\n",
    "images_paths = read_file_list_in_dir(\"P598-Fg009-R\", \"*LR7*.jpg\")\n",
    "merged_image = np.mean( np.array([img.imread(images_paths[0]), \\\n",
    "                                  img.imread(images_paths[1]), \\\n",
    "                                  img.imread(images_paths[2])]), axis=0 )\n",
    "merged_image = np.uint8(merged_image)\n",
    "cropped_merged = crop_full_scan(merged_image)\n",
    "\n",
    "image_rotation = 4 # np.iinfo(np.int32).min\n",
    "\n",
    "ridge_index, image_rotation, image = get_image_ridge_index_file(cropped_merged, image_rotation)\n",
    "print(\"--------INDEX:\"+str(ridge_index)) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "code_folding": [],
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1286, 2933)\n",
      "(1286, 2933)\n",
      "(1286, 2933)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1286, 2933)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TRYING !!! to merge 3 images AFTER we calculate the hessian matrix and then check it...\n",
    "images_paths = read_file_list_in_dir(\"P598-Fg009-R\", \"*LR7*.jpg\")\n",
    "\n",
    "image_yy = []\n",
    "image_rotation = 4\n",
    "first = True\n",
    "xmin = -1\n",
    "ymin = -1\n",
    "xmax = -1\n",
    "ymax = -1\n",
    "for image_path in images_paths:\n",
    "    single_image = img.imread(image_path)\n",
    "    if first:\n",
    "        cropped, ymin, ymax, xmin, xmax = crop_full_scan(single_image)\n",
    "        first = False\n",
    "    else:\n",
    "        cropped = crop(single_image, 600, 4300, 1000, 6000)\n",
    "        cropped = crop(single_image, 600+ymin, 600+ymax, 1000+xmin, 1000+xmax)\n",
    "    print(cropped.shape)\n",
    "#     left_edge_rotated = slice_image_left_edge(cropped, 280, image_rotation)\n",
    "    left_edge_rotated = cropped\n",
    "    hxx, hxy, hyy = hessian_matrix(left_edge_rotated, sigma=5)\n",
    "    image_yy.append((image_path, hyy))\n",
    "  \n",
    "merged_yy = np.mean( np.array([image_yy[0][1], \\\n",
    "                                image_yy[1][1], \\\n",
    "                                image_yy[2][1]]), axis=0 )\n",
    "\n",
    "merged_yy = np.uint8(merged_yy)\n",
    "\n",
    "merged_yy.shape\n",
    "\n",
    "# ridge_index, image_rotation, image = get_image_ridge_index_file(merged_yy, image_rotation)\n",
    "# print(\"--------INDEX:\"+str(ridge_index)) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x106cbfe80>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAg0AAAD6CAYAAAAiEHQcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAAPYQAAD2EBqD+naQAAGBBJREFUeJzt3X+QX3V97/HnCwJYoiFcaVgdUaAURAchiUC4SKRdS8ZS\n6TjOQKu22nvpUIQpl7kClykOXJjxB3ekKD+8XChV+dVRbK96pUagFSw/S0BKRWht+VFMNxhJAwQQ\nSD73j3O+cPgmu/vJZr+72ezzMfMZcs7nfU4+3w/f3fPK53vObkopSJIkjWe76R6AJEmaGQwNkiSp\niqFBkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVQwNkiSpylYdGpKclOSRJM8n\nuTPJwdM9JkmSZqutNjQkOQ74PHA2sBC4H1ieZLdpHZgkSbNUttZfWJXkTuCuUsop7XaAfwO+WEo5\nf1oHJ0nSLLRVrjQk2QFYDNzc21eadHMTcNh0jUuSpNlsqwwNwG7A9sCqvv2rgKGpH44kSZoz3QPY\nTAE2+XlKkjcCy4BHgRemcEySJM10rwP2BJaXUn4+WtHWGhpWA+uB3fv2L2Dj1YeeZcA1gxyUJEnb\nuI8A147WuVV+PFFKeQlYAQz39rU3Qg4Dt49y2KODH5kkSdu0R8fq3FpXGgAuAL6SZAVwN3AqsDPw\n5VHq/UhCkqQtM+a1dKsNDaWUr7U/k+Fcmo8pfggsK6X8bHpHJknS7LTV/pyGzZVkEc1HGpIkaWIW\nl1LuHa1zq7ynQZIkbX0MDZIkqYqhQZIkVTE0SJKkKoYGSZJUxdAgSZKqGBokSVIVQ4MkSapiaJAk\nSVUMDZIkqYqhQZIkVTE0SJKkKoYGSZJUxdAgSZKqGBokSVIVQ4MkSapiaJAkSVUMDZIkqYqhQZIk\nVTE0SJKkKoYGSZJUZdJDQ5Izk9yd5Okkq5L8VZJ9+2p2SnJJktVJnklyfZIFfTV7JPlOknVJRpKc\nn8SQI0nSNBnERfgI4CLgUOB9wA7A95L8UqfmQuBo4EPAUuDNwDd6nW04uAGYAywBPgZ8HDh3AOOV\nJEk1SikDbcBuwAbgPe32POAXwAc7Nfu1NYe02+8HXgJ269ScAKwB5ozy9ywCis1ms9lstgm3RWNd\n06diuX9+O5Cn2u3FNCsIN/cKSikPA48Dh7W7lgAPlFJWd86zHNgFeOegByxJkjY20NCQJDQfRfxd\nKeXBdvcQ8GIp5em+8lVtX69m1Sb66dRIkqQpNGfA578UeAfwnora0KxIjKemRpIkTbKBrTQkuRj4\nTeDIUsrKTtcIsGOSeX2HLODV1YQRYPe+/t52/wqEJEmaAgMJDW1g+G3g10opj/d1rwBeBoY79fsC\nbwVub3fdARyQZLfOcUcBa4EHkSRJU27SP55Icinwu8AxwLokvRWCtaWUF0opTyf5M+CCJGuAZ4Av\nAreVUv6+rf0eTTi4KskZwJuA84CLSykvTfaYJUnS+AZxT8Mf0dx38P2+/X8AfLX986nAeuB6YCfg\nu8BJvcJSyoYkvwV8iWb1YR3wZeDsAYxXkiRVSPszDma8JItoPvqQJEkTs7iUcu9onf5YZkmSVMXQ\nIEmSqhgaJElSFUODJEmqYmiQJElVDA2SJKmKoUGSJFUxNEiSpCqGBkmSVMXQIEmSqhgaJElSFUOD\nJEmqYmiQJElVDA2SJKmKoUGSJFUxNEiSpCqGBkmSVMXQIEmSqhgaJElSFUODJEmqMvDQkOTMJBuS\nXNDZt1OSS5KsTvJMkuuTLOg7bo8k30myLslIkvOTGHIkSZomA70IJzkY+EPg/r6uC4GjgQ8BS4E3\nA9/oHLcdcAMwB1gCfAz4OHDuIMcrSZJGN7DQkOT1wNXA8cB/dPbPA/4LcGop5ZZSyn3AHwCHJzmk\nLVsGvB34SCnlgVLKcuBTwElJ5gxqzJIkaXSDXGm4BPh2KeVv+va/m2YF4ebejlLKw8DjwGHtriXA\nA6WU1Z3jlgO7AO8c2IglSdKoBvKv9iS/AxxEExD67Q68WEp5um//KmCo/fNQu93f3+vr/7hDkiQN\n2KSHhiRvobln4TdKKS9tzqFAqairqZEkSZNsEB9PLAZ+GViR5KUkLwHvBU5J8iLNisFO7b0NXQt4\ndTVhhGZFoqu33b8CIUmSpsAgQsNNwAE0H08c2LZ7aG6K7P35JWC4d0CSfYG3Are3u+4ADkiyW+e8\nRwFrgQcHMGZJkjSOSf94opSyjr4Le5J1wM9LKT9ut/8MuCDJGuAZ4IvAbaWUv28P+V57jquSnAG8\nCTgPuHgzP/KQJEmTZKoeX+y/D+FUYD1wPbAT8F3gpFeKS9mQ5LeAL9GsPqwDvgycPRWDlSRJG0sp\n28Z9hUkWASumexySJM1gi0sp947W6Y9lliRJVQwNkiSpiqFBkiRVMTRIkqQqhgZJklTF0CBJkqoY\nGiRJUhVDgyRJqmJokCRJVQwNkiSpiqFBkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJo\nkCRJVQwNkiSpiqFBkiRVMTRIkqQqhgZJklRlIKEhyZuTXJVkdZLnktyfZFFfzblJVrb9NybZp69/\n1yTXJFmbZE2SK5LMHcR4JUnS+CY9NCSZD9wG/AJYBuwP/HdgTafmDOBk4ATgEGAdsDzJjp1TXdse\nOwwcDSwFLpvs8UqSpEqllEltwGeBW8apWQmc2tmeBzwPHNtu7w9sABZ2apYBLwNDo5xzEVBsNpvN\nZrNNuC0a6/o9iI8nPgDck+RrSVYluTfJ8b3OJHsBQ8DNvX2llKeBu4DD2l1LgDWllPs6572pfUGH\nDmDMkiRpHIMIDXsDJwIPA0cB/xv4YpKPtv1DNBf/VX3HrWr7ejVPdjtLKeuBpzo1kiRpCs0ZwDm3\nA+4upXyq3b4/yTtpgsTVYxwXmjAxlpoaSZI0AINYafh34Md9+34MvLX98wjNxX/3vpoFvLr6MNJu\nvyLJ9sCubLxCIUmSpsAgQsNtwH59+/YDHgMopTxCEwqGe51J5tHcq3B7u+sOYH6ShZ1zDNOEjbsG\nMGZJkjSOQXw88afAbUnOBL5GEwaOB/6wU3MhcFaSnwCPAucBTwDfBCilPJRkOXB5khOBHYGLgOtK\nKSMDGLMkSRrHpIeGUso9ST5I8+jlp4BHgFNKKX/RqTk/yc40P3dhPvAD4P2llBc7p/owcDHNUxMb\ngOuBUyZ7vJIkqU7an3Ew47U/cXLFdI9DkqQZbHEp5d7ROv3dE5IkqYqhQZIkVTE0SJKkKoYGSZJU\nxdAgSZKqGBokSVIVQ4MkSapiaJAkSVUMDZIkqYqhQZIkVTE0SJKkKoYGSZJUxdAgSZKqGBokSVIV\nQ4MkSapiaJAkSVUMDZIkqYqhQZIkVTE0SJKkKoYGSZJUxdAgSZKqTHpoSLJdkvOS/GuS55L8JMlZ\nm6g7N8nKtubGJPv09e+a5Joka5OsSXJFkrmTPV5JklRnECsN/wM4AfgE8HbgdOD0JCf3CpKcAZzc\n1h0CrAOWJ9mxc55rgf2BYeBoYClw2QDGK0mSapRSJrUB3wYu79t3PfDVzvZK4NTO9jzgeeDYdnt/\nYAOwsFOzDHgZGBrl710EFJvNZrPZbBNui8a6xg9ipeF2YDjJrwIkORA4HLih3d4LGAJu7h1QSnka\nuAs4rN21BFhTSrmvc96b2hd06ADGLEmSxjFnAOf8LM3KwUNJ1tN8BPInpZS/aPuHaC7+q/qOW9X2\n9Wqe7HaWUtYneapTI0mSptAgQsNxwIeB3wEeBA4CvpBkZSnlqjGOC02YGEtNjSRJGoBBhIbzgU+X\nUr7ebv8oyZ7AmcBVwAjNxX93XrvasADofRwx0m6/Isn2wK5svEIhSZKmwCDuadiZjVcDNvT+rlLK\nIzShYLjXmWQezb0Kt7e77gDmJ1nYOccwTdi4awBjliRJ4xjESsO3gT9J8m/Aj2ieajgVuKJTcyFw\nVpKfAI8C5wFPAN8EKKU8lGQ5cHmSE4EdgYuA60opIwMYsyRJGscgQsPJNCHgEpqPGFYCX2r3AVBK\nOT/JzjQ/d2E+8APg/aWUFzvn+TBwMc1TExtoHts8ZQDjlSRJFdL+jIMZL8kiYMV0j0OSpBlscSnl\n3tE6/d0TkiSpiqFBkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVQwNkiSpiqFB\nkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVQwNkiSpiqFBkiRVMTRIkqQqhgZJ\nklTF0CBJkqpsdmhIckSSbyX5aZINSY7ZRM25SVYmeS7JjUn26evfNck1SdYmWZPkiiRz+2releTW\nJM8neSzJaZv/8iRJ0mSZyErDXOCHwElA6e9McgZwMnACcAiwDlieZMdO2bXA/sAwcDSwFLisc443\nAMuBR4BFwGnAOUmOn8B4JUnSZCilTLgBG4Bj+vatBE7tbM8DngeObbf3b49b2KlZBrwMDLXbJwKr\ngTmdms8AD44xlkU0IcZms9lsNtvE2qKxrvuTek9Dkr2AIeDm3r5SytPAXcBh7a4lwJpSyn2dQ29q\nB3top+bWUsrLnZrlwH5JdpnMMUuSpDqTfSPkEM3Ff1Xf/lVtX6/myW5nKWU98FRfzabOQadGkiRN\noal6eiI0YWJLatL+d7zzSJKkAZjs0DBCc3HfvW//Al5dKRhpt1+RZHtg17avV7Opc8DGKxCSJGkK\nTGpoKKU8QnPBH+7tSzKP5l6F29tddwDzkyzsHDpMEzbu7tQsbcNEz1HAw6WUtZM5ZkmSVGciP6dh\nbpIDkxzU7tq73d6j3b4QOCvJB5IcAHwVeAL4JkAp5SGamxovT3JwksOBi4DrSim9lYZrgReBK5O8\nI8lxwB8Dn5/g65QkSVtqAo9Zvpfmkcn1fe3KTs05NI9ePkcTEPbpO8d84GpgLbAGuBzYua/mAOCW\n9hyPA58cZ1w+cmmz2Ww225a1MR+5THvBnfGSLAJWTPc4JEmawRaXUu4drdPfPSFJkqoYGiRJUhVD\ngyRJqmJokCRJVQwNkiSpiqFBkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVQwN\nkiSpiqFBkiRVMTRIkqQqhgZJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVTY7NCQ5Ism3kvw0yYYk\nx3T65iT5XJJ/SPJsW/OVJG/qO8euSa5JsjbJmiRXJJnbV/OuJLcmeT7JY0lOm/jLlCRJW2oiKw1z\ngR8CJwGlr29n4CDgfwILgQ8C+wHf7Ku7FtgfGAaOBpYCl/U6k7wBWA48AiwCTgPOSXL8BMYrSZIm\nQyllwg3YABwzTs27gfXAW9rt/dvjFnZqlgEvA0Pt9onAamBOp+YzwINj/D2LaEKMzWaz2Wy2ibVF\nY13Tp+KehvntQP6j3V4CrCml3NepuamtObRTc2sp5eVOzXJgvyS7DHi8kiRpEwYaGpLsBHwWuLaU\n8my7ewh4sltXSlkPPNX29WpW9Z1uVadPkiRNsYGFhiRzgK/TrCB8ouaQtnasfsapkSRJAzJnECft\nBIY9gF/vrDIAjAAL+uq3B3Zt+3o1u/edtndM/wqEJEmaApO+0tAJDHsDw6WUNX0ldwDzkyzs7Bum\nWUm4u1OztA0TPUcBD5dS1k72mCVJ0vgm8nMa5iY5MMlB7a692+092ov8N2ieZPgosEOS3du2A0Ap\n5SGamxovT3JwksOBi4DrSim9lYZrgReBK5O8I8lxwB8Dn9+SFytJkrbABB6zfC/NI5Pr+9qVwNs2\n0dfbXto5x3zgamAtsAa4HNi57+85ALgFeA54HPjkOOPykUubzWaz2basjfnIZdoL7oyXZBGwYrrH\nIUnSDLa4lHLvaJ3+7glJklTF0CBJkqoYGiRJUhVDgyRJqmJokCRJVQwNkiSpiqFBkiRV2ZZCw+um\newCSJM1wY15Lt6XQsOd0D0CSpBluz7E6t6WfCPlGYBnwKPDC9I5GkqQZ5XU0gWF5KeXnoxVtM6FB\nkiQN1rb08YQkSRogQ4MkSapiaJAkSVUMDZIkqco2ERqSnJTkkSTPJ7kzycHTPabpluTsJBv62oOd\n/p2SXJJkdZJnklyfZEHfOfZI8p0k65KMJDk/yTbxnulKckSSbyX5aTtPx2yi5twkK5M8l+TGJPv0\n9e+a5Joka5OsSXJFkrl9Ne9Kcmv7Pn0syWmDfm1TYbz5S/Lnm3gv3tBXM+vmL8mZSe5O8nSSVUn+\nKsm+fTWT8nWa5MgkK5K8kOSfknxsKl7jIFXO3/f73nfrk1zaVzMr52+iZvwFIMlxwOeBs4GFwP3A\n8iS7TevAtg7/COwODLXtPZ2+C4GjgQ8BS4E3A9/odbZfNDcAc4AlwMeAjwPnTsG4p9pc4IfAScBG\njxMlOQM4GTgBOARYR/Me27FTdi2wPzBMM69Lgcs653gDsBx4BFgEnAack+T4AbyeqTbm/LX+mte+\nF3+3r382zt8RwEXAocD7gB2A7yX5pU7NFn+dJtkT+H/AzcCBwBeAK5L8xkBe1dSpmb8C/B9efe+9\nCTi91znL529iSikzugF3Al/obAd4Ajh9usc2zfNyNnDvKH3zgF8AH+zs2w/YABzSbr8feAnYrVNz\nArAGmDPdr2+A87YBOKZv30rg1L75ex44tt3evz1uYadmGfAyMNRunwis7s4d8Bngwel+zVMwf38O\n/OUYx7zd+SsAu7Xz8J7O+2yLv06BzwH/0Pd3XQfcMN2veZDz1+77W+CCMY5x/jazzeiVhiQ7AItp\nEiAApfk/ehNw2HSNayvyq+2S8b8kuTrJHu3+xTTJujtvDwOP8+q8LQEeKKWs7pxvObAL8M7BD33r\nkGQvmn+hdOfqaeAuXjtXa0op93UOvYnmXzmHdmpuLaW83KlZDuyXZJcBDX9rcmS7hPxQkkuT/KdO\n32E4fwDzaV7zU+32ZH2dLqGZT/pqtrXvkf3z1/ORJD9L8kCST/etRDh/m2lGhwaaZLk9sKpv/yqa\nb/Sz2Z00y2zLgD8C9gJubT8nHgJebC9+Xd15G2LT8wqza26HaL4RjfUeGwKe7HaWUtbTfPNyPpuP\nJn4f+HWapeH3AjckSds/6+evnYsLgb8rpfTuPZqsr9PRauYl2WlLx741GGX+AK4BPgocCXwa+D3g\nqk6/87eZ5kz3AAYkjP7Z6qxQSlne2fzHJHcDjwHHMvqP2a6dt1k9t62auRqvpnfR3Kbns5Tytc7m\nj5I8APwLzTfyvx3j0Nk0f5cC7+C19x2NZjK+TreluYNX5+/w7s5SyhWdzR8lGQFuTrJXKeWRcc45\nm+av2kxfaVgNrKe5yaVrARsnw1mtlLIW+CdgH2AE2DHJvL6y7ryNsPG89rZn09yO0HyDGOs9NtJu\nvyLJ9sCubV+vZlPngNk1n7TfrFfTvBdhls9fkouB3wSOLKWs7HRt6dfpeHP3dCnlxS0Z+9agb/7+\nfZzyu9r/dt97s3r+NteMDg2llJeAFTR3XAOvLFMNA7dP17i2RkleD/wKzU19K2huMuvO277AW3l1\n3u4ADuh7CuUoYC3QXf7bprUXuBFeO1fzaD5r787V/CQLO4cO04SNuzs1S9uLYc9RwMNtoJs1krwF\neCPQ+wY/a+evveD9NvBrpZTH+7q39Ov0x52aYV7rqHb/jDbO/G3KQprVge57b9bO34RM952YW9po\nltufp/nM9O00j2n9HPjl6R7bNM/L/6J5ROttwH8GbqT518kb2/5LaR5fO5LmhqvbgB90jt+O5vHV\nvwbeRXNvxCrgvOl+bQOYq7k0j1IdRHP39X9rt/do+09v31MfAA4A/i/wz8COnXPcANwDHEyzRPow\ncFWnfx5NYPsKzTLqccCzwH+d7tc/yPlr+86nCVlvo/nmew/NN+QdZvP8tV+Da2geHdy9017XV7NF\nX6c0v7nwWZqnAPYDPgG8CLxvuudgkPMH7A2cRfOI7tuAY4CfAH/j/G3BvE/3ACbpzfMJml+J/TxN\n+nv3dI9puhvNI0FPtHPyOM1z8Ht1+neiecZ5NfAM8HVgQd859qB5PvnZ9gvpc8B20/3aBjBX720v\nduv72pWdmnPai9ZzNHdO79N3jvnA1TT/QlkDXA7s3FdzAHBLe47HgU9O92sf9PzR/Lrd79Ks1rwA\n/CvwJfpC/Wycv1HmbD3w+52aSfk6bf8frWi/H/wz8HvT/foHPX/AW4DvAz9r3zMP0zym+3rnb+LN\nX40tSZKqzOh7GiRJ0tQxNEiSpCqGBkmSVMXQIEmSqhgaJElSFUODJEmqYmiQJElVDA2SJKmKoUGS\nJFUxNEiSpCqGBkmSVMXQIEmSqvx//ZkOWG3pY8YAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x113e30fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(merged_yy, cmap='gray')\n",
    "# ridge_index, image_rotation, image = get_image_ridge_index_file(merged_yy, image_rotation)\n",
    "# print(\"--------INDEX:\"+str(ridge_index)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}