referenceOrientationNotebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data analysis for different reference orientations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook changes the reference orientation for the calculation of lattice msiorientation from EBSD data. The reference orientations are:\n",
    "    - GROD Mean: The grain mean orientation (GROD Mean)\n",
    "    - GROD Mean Min: The pixel in the grain with the minimum misorientation as calculaed by GROD Mean\n",
    "    - GROD Mean Max: The pixel in the grain with the maximum misorientation as calculaed by GROD Mean\n",
    "    - GROD Centroid: The pixel at the EUclidean centre of the grain\n",
    "    - GROD Lowest KAM: The pixel with the lowest Kernal Avergae Misorientation value\n",
    "NB: To calculate the pixel misorientation with respect to the original grain orientation (prior to deformation), see the Linker class and the associated notebook (see Michael Atkinson)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from skimage import transform as tf\n",
    "from skimage import io\n",
    "\n",
    "import hrdic\n",
    "import ebsd\n",
    "\n",
    "import copy\n",
    "\n",
    "%matplotlib osx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load DIC data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded DaVis 8.1.5 data (dimensions: 1860 x 1628 pixels, sub-window size: 8 x 8 pixels)\n"
     ]
    }
   ],
   "source": [
    "#Load in DIC map\n",
    "DicFilePath = \"./example_data_AH/\"\n",
    "DicMap = hrdic.Map(DicFilePath, \"hrdicData.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load EBSD Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded EBSD data (dimensions: 612 x 465 pixels, step size: 0.5 um)\n",
      "Error with cpr file. Number of phases mismatch.\n",
      "Loaded EBSD data (dimensions: 612 x 465 pixels, step size: 0.5 um)\n",
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "mapFiles = [\"./example_data_AH/ebsdData\"]\n",
    "\n",
    "maps = []\n",
    "\n",
    "for i, mapFile in enumerate(mapFiles):\n",
    "    maps.append(ebsd.Map(mapFile, \"cubic\"))\n",
    "    maps[i].loadData(mapFile, \"cubic\")\n",
    "    maps[i].binData = maps[i].binData[::-1]  #rotate the map 180 degrees\n",
    "    maps[i].buildQuatArray()\n",
    "    maps[i].findBoundaries(boundDef = 6)\n",
    "    maps[i].findGrains(minGrainSize=10)\n",
    "    maps[i].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maps[0].plotMisOriMap()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Record the original grain reference orientations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def recordGrainOrigRefOri(self):\n",
    "    self.origRefOri = copy.deepcopy(self.refOri)\n",
    "\n",
    "ebsd.Grain.recordGrainOrigRefOri=recordGrainOrigRefOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6726, -0.2929, -0.0118, -0.6795]\n"
     ]
    }
   ],
   "source": [
    "# test the function\n",
    "maps[0].grainList[0].recordGrainOrigRefOri()\n",
    "print(maps[0].grainList[0].origRefOri)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [],
   "source": [
    "# record original reference oriengtation for each grain\n",
    "for grain in maps[0].grainList:\n",
    "    grain.recordGrainOrigRefOri()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Revert back to the original grain reference orientations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def revertGrainRefOriToOriginalRefOris(self):\n",
    "    self.refOri = copy.deepcopy(self.origRefOri)\n",
    "\n",
    "ebsd.Grain.revertGrainRefOriToOriginalRefOris=revertGrainRefOriToOriginalRefOris"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maps[0].plotMisOriMap(vmax=3,plotGBs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Link the DIC and EBSD data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finding grains in DIC map...\r"
     ]
    }
   ],
   "source": [
    "# load the disMap crop parameters\n",
    "DicMap.cropDists = np.loadtxt(\"./example_data_AH/dicMapCropDists.txt\")\n",
    "\n",
    "# set the dic map crop parameters\n",
    "DicMap.cropDists_temp=[]\n",
    "for p,q in DicMap.cropDists:\n",
    "    p,q = int(p),int(q)\n",
    "    DicMap.cropDists_temp.append([p,q])\n",
    "DicMap.cropDists_temp=np.array(DicMap.cropDists_temp)\n",
    "DicMap.cropDists=copy.deepcopy(DicMap.cropDists_temp)\n",
    "\n",
    "# define the crop\n",
    "DicMap.setCrop(xMin=DicMap.cropDists[0,0], xMax=DicMap.cropDists[0,1], yMin=DicMap.cropDists[1,0], yMax=DicMap.cropDists[1,1])\n",
    "\n",
    "# load and define the homogPoints\n",
    "DicMap.homogPoints = np.loadtxt(\"./example_data_AH/dicMapHomogPoints.txt\")\n",
    "maps[0].homogPoints = np.loadtxt(\"./example_data_AH/ebsdMapHomogPoints.txt\")\n",
    "\n",
    "# link the dic and ebsd data\n",
    "DicMap.linkEbsdMap(maps[0])\n",
    "\n",
    "# find the grains\n",
    "DicMap.findGrains(minGrainSize=1434)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grain ID: 32\n"
     ]
    }
   ],
   "source": [
    "DicMap.locateGrainID()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test the link has worked\n",
    "grainNum = DicMap.currGrainId\n",
    "DicMap.grainList[grainNum].plotMaxShear()\n",
    "maps[0].grainList[DicMap.ebsdGrainIds[grainNum]].plotMisOri()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot grain-to-grain DIC-EBSD correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Define the DicMap pixel resolution in order to obtain grain size information\n",
    "DicMap.pixelResolution = 0.117 # um"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot data correlation function\n",
    "def plotCorrelation(dicSelf,ebsdSelf,grainDiameter=False):\n",
    "    plt.figure()\n",
    "    for i,grain in enumerate(dicSelf):\n",
    "        x = np.nanmean(grain.maxShearList)\n",
    "        y = np.nanmean((np.arccos(ebsdSelf.grainList[dicSelf.ebsdGrainIds[i]].misOriList))*180/np.pi)\n",
    "        if grainDiameter:\n",
    "            area = len(grain.maxShearList)\n",
    "            diameter = ((area/np.pi)**0.5)*2*dicSelf.pixelResolution # um\n",
    "            plt.scatter(x,y,c=diameter,s=diameter,vmin=20,vmax=40,cmap=\"viridis\")\n",
    "        else:\n",
    "            plt.scatter(x,y,c=\"grey\")\n",
    "    if grainDiameter:    \n",
    "        plt.colorbar(label=\"Grain diameter [$\\\\mu$ m]\", shrink=0.8)\n",
    "    plt.xlabel(\"HRDIC strain, $\\epsilon_{eff}$ [ ]\")\n",
    "    plt.ylabel(\"EBSD misorientation, $\\phi$ [ $^o$ ]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change the reference orientation for the ebsd misOri calculation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Best Band Contrast value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define the BC map\n",
    "def generateBCMap(self):\n",
    "    self.bcmap = np.reshape(self.binData[('IB2')], (self.yDim, self.xDim))\n",
    "    \n",
    "ebsd.Map.generateBCMap=generateBCMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "maps[0].generateBCMap()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Change refOri to that of the pixel with best BC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def refOribestBC(self,ebsdSelf=maps[0]):\n",
    "\n",
    "    # create new refOri\n",
    "    grainBcList = []\n",
    "    for coord in self.coordList:\n",
    "        bcVal = ebsdSelf.bcmap[coord[1],coord[0]]\n",
    "        grainBcList.append(bcVal)\n",
    "    maxBcIdx = np.argmax(grainBcList)\n",
    "    newQuat = self.quatList[maxBcIdx]\n",
    "    self.refOri = copy.deepcopy(newQuat) \n",
    "\n",
    "ebsd.Grain.refOribestBC=refOribestBC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "metadata": {},
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.refOribestBC()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations..."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in true_divide\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in arccos\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in sqrt\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change back to original refOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate misOri wrt. mean-min misOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def refOriMeanMin(self):\n",
    "    # create new refOri\n",
    "    minIdx = np.argmax(self.misOriList) # use np.argmax as minMisOri inversely proportional to arccos(minMisOri)\n",
    "    newQuat = self.quatList[minIdx]\n",
    "    self.refOri = copy.deepcopy(newQuat) \n",
    "ebsd.Grain.refOriMeanMin=refOriMeanMin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.refOriMeanMin()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations..."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in true_divide\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in arccos\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in sqrt\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change back to original refOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate misOri wrt. mean-max misOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def refOriMeanMax(self):\n",
    "    # create new refOri\n",
    "    maxIdx = np.argmin(self.misOriList) # use np.argmin as maxMisOri inversely proportional to arccos(maxMisOri)\n",
    "    newQuat = self.quatList[maxIdx]\n",
    "    self.refOri = copy.deepcopy(newQuat) \n",
    "ebsd.Grain.refOriMeanMax=refOriMeanMax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.refOriMeanMax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations..."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in arccos\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in sqrt\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in true_divide\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change back to original refOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate misOri wrt. pixel with the lowest KAM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate map KAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcKamNxN(self,n=3,maxMisOri=5, plotKamData=False,plotGBs=False,localGrad=False,boundaryColour='black'):\n",
    "    \n",
    "    if n <= 1:\n",
    "        raise ValueError(\"Please enter a kernel dimenion n, where n > 1 and n is an odd number\")\n",
    "    oddCheck = n%2\n",
    "    if oddCheck == 0:\n",
    "        raise ValueError(\"Please enter a kernel dimenion n, where n > 1 and n is an odd number\")\n",
    "\n",
    "    # separate the quat coefficients\n",
    "    quatComps = np.empty((4, self.yDim, self.xDim))\n",
    "    for i, row in enumerate(self.quatArray):\n",
    "        for j, quat in enumerate(row):\n",
    "            quatComps[:, i, j] = quat.quatCoef\n",
    "    \n",
    "    # define the data as the separated quat coefficients\n",
    "    data = quatComps\n",
    "\n",
    "    # define r, the remainder, to define the boundary regions\n",
    "    r=int((n-1)/2)\n",
    "\n",
    "    # kamData=np.empty((data.shape[1]-r,data.shape[2]-r))\n",
    "    kamData=np.zeros((np.shape(data)[1],np.shape(data)[2])) # initialise with zeroes so that the final kamMap is the same size as the data\n",
    "\n",
    "    for i in range(r,np.shape(data)[1]-r): # avoid boundaries, r\n",
    "        for j in range(r,np.shape(data)[2]-r):\n",
    "\n",
    "            # initialise a data kernel\n",
    "            dataKernel=np.zeros((4,n,n))\n",
    "            dataKernelList=np.zeros((4,n*n))\n",
    "            \n",
    "            centralPixelIndex=int((n-1)/2)\n",
    "            cPixIdx=np.full((2,1),centralPixelIndex)\n",
    "            \n",
    "            distList=[]\n",
    "\n",
    "            # grab the quat data for the data kernel\n",
    "            for q in range(np.shape(data)[0]):\n",
    "\n",
    "                # define the data kernel\n",
    "                for row in range(n):\n",
    "                    for column in range(n):                            \n",
    "                        dataKernel[q,row,column] = data[q,i-r+row,j-r+column]\n",
    "                        \n",
    "                        if localGrad:\n",
    "                        \n",
    "                            distX = abs(row-cPixIdx[0])\n",
    "                            distY = abs(column-cPixIdx[1])\n",
    "                            dist = ((distX**2)+(distY**2))**0.5\n",
    "                            distList.append(dist.tolist())\n",
    "                            \n",
    "                        else:\n",
    "                            dist=1\n",
    "                            distList.append([dist])\n",
    "                            \n",
    "                dataKernelList[q,:]=dataKernel[q,:,:].flatten()\n",
    "            \n",
    "            distList_temp=[]\n",
    "            for dist in distList:\n",
    "                for k in dist:\n",
    "                    distList_temp.append(k)\n",
    "            distList=distList_temp\n",
    "            \n",
    "\n",
    "            #  find the mirOri between the central data pixel and the data kernel pixels\n",
    "            misOriKernel=abs(np.einsum(\"i,ij->j\",data[:,i,j],dataKernelList[:]))\n",
    "            # convert to degrees\n",
    "            misOriKernelDeg=2*np.arccos(misOriKernel)*180/np.pi\n",
    "\n",
    "            # replace misOris > maxMisOri with NaN\n",
    "            misOriKernelDeg_new=np.empty(n*n)\n",
    "            for val in range(len(misOriKernelDeg_new)):\n",
    "                if misOriKernelDeg[val] >= maxMisOri:\n",
    "                    newVal=np.nan\n",
    "                else:\n",
    "                    newVal=misOriKernelDeg[val]\n",
    "                misOriKernelDeg_new[val]=newVal\n",
    "\n",
    "            # replace central value with NaN\n",
    "            centralPixelIndex=int(((n*n)-1)/2)\n",
    "            misOriKernelDeg_new[centralPixelIndex] = np.nan\n",
    "            \n",
    "            gradList=[]\n",
    "            for dif,dist in zip(misOriKernelDeg_new,distList):\n",
    "                if np.isnan(dif):\n",
    "                    gradList.append(np.nan)\n",
    "                else:\n",
    "                    gradVal = dif/dist\n",
    "                    gradList.append(gradVal)\n",
    "                    \n",
    "            \n",
    "            # find mean of all misOris in kernel\n",
    "            meanMisOri=np.nanmean(gradList)    \n",
    "\n",
    "            # place misOri in kamData\n",
    "            kamData[i,j] = meanMisOri\n",
    "\n",
    "    # Plotting\n",
    "    if plotKamData:\n",
    "        plt.figure()\n",
    "        plt.imshow(kamData,vmin=0,vmax=1)\n",
    "        plt.colorbar(shrink=0.8,label=\"KAM [ $^o$ ]\")\n",
    "\n",
    "        if plotGBs:\n",
    "            self.plotGBs(colour=boundaryColour)\n",
    "\n",
    "    self.kamData=kamData\n",
    "\n",
    "ebsd.Map.calcKamNxN=calcKamNxN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/anaconda/envs/py36/lib/python3.6/site-packages/ipykernel_launcher.py:67: RuntimeWarning: invalid value encountered in arccos\n",
      "/Users/mclijah5/anaconda/envs/py36/lib/python3.6/site-packages/ipykernel_launcher.py:92: RuntimeWarning: Mean of empty slice\n"
     ]
    }
   ],
   "source": [
    "maps[0].calcKamNxN()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot KAM without re-calculating KAM map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plotKAMMap(self,plotGBs=False,boundaryColour='black'):\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.imshow(self.kamData,vmin=0,vmax=1)\n",
    "    plt.colorbar(shrink=0.8,label=\"KAM [ $^o$ ]\")\n",
    "        \n",
    "    if plotGBs:\n",
    "        self.plotGBs(colour=boundaryColour)\n",
    "        \n",
    "ebsd.Map.plotKAMMap=plotKAMMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "maps[0].plotKAMMap(plotGBs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Find grain KAM values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getGrainKam(self,kamMap=maps[0].kamData):\n",
    "    kamList = []\n",
    "    for coord in self.coordList:\n",
    "        kamVal = kamMap[coord[1],coord[0]]\n",
    "        kamList.append(kamVal)\n",
    "    self.kamList=kamList\n",
    "ebsd.Grain.getGrainKam=getGrainKam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.getGrainKam()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot grain KAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plotKAM(self):\n",
    "    \n",
    "    plt.figure()\n",
    "    x0, y0, xmax, ymax = self.extremeCoords\n",
    "#     x0, y0, xmax, ymax = int(x0), int(y0), int(xmax), int(ymax)\n",
    "    plotArea = np.full((ymax - y0 + 1, xmax - x0 + 1), np.nan, dtype=float)\n",
    "    plotData = self.kamList\n",
    "    coord0s,coord1s=[],[]\n",
    "    for coord0,coord1 in self.coordList:\n",
    "        coord0s.append(coord0)\n",
    "        coord1s.append(coord1)\n",
    "    for coord0,coord1,data in zip(coord0s,coord1s,plotData):\n",
    "        plotArea[coord1 - y0, coord0 - x0] = data\n",
    "    plt.imshow(plotArea, vmin=0, vmax=0.3, cmap=\"viridis\")\n",
    "    \n",
    "ebsd.Grain.plotKAM=plotKAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "maps[0].grainList[32].plotKAM()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set grain refOri to pixel with lowest KAM, re-calculate misOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def refOriLowestKAM(self):\n",
    "    minKamValIndx = np.argmin(self.kamList)\n",
    "    newQuat = self.quatList[minKamValIndx]\n",
    "    self.refOri = copy.deepcopy(newQuat)   \n",
    "ebsd.Grain.refOriLowestKAM=refOriLowestKAM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.refOriLowestKAM()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations..."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in true_divide\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in arccos\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in sqrt\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change back to original refOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate refOri as the grain centroid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Calculate GB proxigram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcProxiGram(self):\n",
    "    indexBoundaries = []\n",
    "    for index, value in np.ndenumerate(self.boundaries):\n",
    "        if value == -1:\n",
    "            indexBoundaries.append(index)\n",
    "\n",
    "    proxBoundaries = np.copy(self.boundaries[:,:])\n",
    "\n",
    "    numTrials = 1000\n",
    "    trialDistances = np.ones((numTrials+1, proxBoundaries.shape[0], proxBoundaries.shape[1]))*1000\n",
    "\n",
    "    # array of x and y coordinate of each pixel in the map\n",
    "    coords = np.zeros((2, proxBoundaries.shape[0], proxBoundaries.shape[1]))\n",
    "    for index, value in np.ndenumerate(proxBoundaries):\n",
    "        coords[0, index[0], index[1]] = index[0]\n",
    "        coords[1, index[0], index[1]] = index[1]\n",
    "\n",
    "    # loop over each boundary point (p) and calcuale distance from p to all points in the map\n",
    "    # once numTrails have been made the minimum of them will be found and stored\n",
    "    j=1\n",
    "    for indexBoundary in indexBoundaries:    \n",
    "        trialDistances[j] = np.sqrt((coords[0] - indexBoundary[0])**2 + (coords[1] - indexBoundary[1])**2)\n",
    "\n",
    "        if j==numTrials:\n",
    "            trialDistances[0] = trialDistances.min(axis=0)\n",
    "            j=0\n",
    "        j+=1\n",
    "\n",
    "    # find minimum distance to a boundary\n",
    "    minDistances = trialDistances.min(axis=0)\n",
    "    \n",
    "    self.GBProxigram=minDistances\n",
    "\n",
    "ebsd.Map.calcProxiGram=calcProxiGram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {},
   "outputs": [],
   "source": [
    "maps[0].calcProxiGram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot proxigram map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotGBProxiGramMap(self):\n",
    "    plt.figure()\n",
    "    plt.imshow(self.GBProxigram)\n",
    "    plt.colorbar(label=\"Proximity to nearest GB [$\\\\mu$ m]\",shrink=0.8)\n",
    "\n",
    "ebsd.Map.plotGBProxiGramMap=plotGBProxiGramMap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [],
   "source": [
    "maps[0].plotGBProxiGramMap()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get grain proxigram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def getGrainGBProxiGram(self,GBProxiGramMap=maps[0].GBProxigram):\n",
    "    GBProxiGramList = []\n",
    "    for coord in self.coordList:\n",
    "        GBProxiGramVal = GBProxiGramMap[coord[1],coord[0]]\n",
    "        GBProxiGramList.append(GBProxiGramVal)\n",
    "    self.GBProxiGramList=GBProxiGramList\n",
    "\n",
    "ebsd.Grain.getGrainGBProxiGram=getGrainGBProxiGram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.getGrainGBProxiGram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot proxigram for a grain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plotGBProxigram(self):    \n",
    "    plt.figure()\n",
    "    x0, y0, xmax, ymax = self.extremeCoords\n",
    "#     x0, y0, xmax, ymax = int(x0), int(y0), int(xmax), int(ymax)\n",
    "    plotArea = np.full((ymax - y0 + 1, xmax - x0 + 1), np.nan, dtype=float)\n",
    "    plotData = self.GBProxiGramList\n",
    "    coord0s,coord1s=[],[]\n",
    "    for coord0,coord1 in self.coordList:\n",
    "        coord0s.append(coord0)\n",
    "        coord1s.append(coord1)\n",
    "    for coord0,coord1,data in zip(coord0s,coord1s,plotData):\n",
    "        plotArea[coord1 - y0, coord0 - x0] = data\n",
    "    plt.imshow(plotArea, cmap=\"viridis\")\n",
    "    plt.axis(\"off\")\n",
    "    plt.colorbar(label=\"Proximity to nearest GB [$\\\\mu$ m]\",shrink=0.8)\n",
    "    \n",
    "ebsd.Grain.plotGBProxigram=plotGBProxigram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [],
   "source": [
    "maps[0].grainList[32].plotGBProxigram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### refOri as that of central pixel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def refOriGreatestGBDistance(self):\n",
    "    # find max distance pixel and set to new quat\n",
    "    maxDistanceIndx = np.argmax(self.GBProxiGramList)\n",
    "    newQuat = self.quatList[maxDistanceIndx]\n",
    "    self.refOri = copy.deepcopy(newQuat)\n",
    "\n",
    "ebsd.Grain.refOriGreatestGBDistance=refOriGreatestGBDistance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for grain in maps[0].grainList:\n",
    "    grain.refOriGreatestGBDistance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations..."
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in arccos\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in sqrt\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n",
      "/Users/mclijah5/Dropbox (Research Group)/Allan/Macbook_2/Python/DataAnalysisUtilities/ebsd.py:636: RuntimeWarning: invalid value encountered in true_divide\n",
      "  misOriAxis[:, :] = (2 * Dq[1:4, :] * np.arccos(Dq[0, :])) / np.sqrt(1 - np.power(Dq[0, :], 2))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change back to original refOri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# revert grain reference ori to original reference ori\n",
    "for grain in maps[0].grainList:\n",
    "    grain.revertGrainRefOriToOriginalRefOris()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating grain misorientations...\r"
     ]
    }
   ],
   "source": [
    "# re-calculate misOri\n",
    "maps[0].calcGrainMisOri(calcAxis = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# plot the correlation\n",
    "plotCorrelation(DicMap,maps[0],grainDiameter=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}