Handling image logs with dlisio.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Handling image logs with dlisio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook builds on the plotting work from Brendon Hall."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For using mayavi - make sure you install dependencies and on Windows 10 you will need the visual basic built tools from https://visualstudio.microsoft.com/visual-cpp-build-tools/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import re\n",
    "import os\n",
    "import pandas as pd\n",
    "import dlisio\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import numpy.lib.recfunctions as rfn\n",
    "from mayavi import mlab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the [NGI image](https://drive.google.com/file/d/1oY-a7d-lIG8mBNE52BGOeCmq6u1kbFkx/view?usp=sharing) from the Pharos well in Poseidon.  Source: https://nopims.dmp.wa.gov.au/Nopims/Search/WellDetails#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filepath = r\"ConocoPhillips Pharos-1 NGI Processed Images Static_Dynamic.dlis\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Which curves are available?\n",
    "\n",
    "### We can quickly pull the metadata of the file and the list of curves per frame to find the image log we are looking for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with dlisio.dlis.load(filepath) as file:\n",
    "    for d in file:\n",
    "        for origin in d.origins:\n",
    "            print(origin.describe())\n",
    "        for fram in d.frames:\n",
    "            print(fram.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will pull the depth track and the image track.  From the depth track we need the last array value so we can plot the limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in file:\n",
    "    for frame in d.frames:\n",
    "        for channel in frame.channels:\n",
    "            print(channel.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with dlisio.dlis.load(filepath) as file:\n",
    "    for d in file:\n",
    "        depth_channels = d.find('CHANNEL', 'TDEP')\n",
    "        for channel in depth_channels:\n",
    "            print(channel.name)\n",
    "            depth_array = channel.curves()\n",
    "            max_depth = depth_array[-1]\n",
    "        image_channels = d.find('CHANNEL','NGI DYNAMIC.')\n",
    "        for channel in image_channels:\n",
    "            print(channel.name)\n",
    "            image_array = channel.curves()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(image_array, index=depth_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize = (24,30))\n",
    "image_array[image_array == -9999.] = np.nan\n",
    "limit = int(100000 + max_depth)\n",
    "plt.imshow(image_array[100000:limit,:], cmap='YlOrBr')\n",
    "plot = plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot NGI wellbore image in 3D "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "myarr = image_array[100000:100800,:]\n",
    "max_value = np.nanmax(myarr)\n",
    "myarr = myarr / max_value\n",
    "im = Image.fromarray(np.uint8(plt.cm.YlOrBr(myarr)*255))\n",
    "\n",
    "\n",
    "im.save('test_image.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui qt\n",
    "\n",
    "cyl = mlab.pipeline.builtin_surface()\n",
    "cyl_surf = mlab.pipeline.surface(cyl)\n",
    "\n",
    "cyl.source = 'cylinder'\n",
    "cyl.data_source.resolution = 64\n",
    "cyl.data_source.height = 8.0\n",
    "\n",
    "img = mlab.pipeline.open('./test_image.png')\n",
    "cyl_surf.actor.enable_texture = True\n",
    "cyl_surf.actor.tcoord_generator_mode = 'cylinder'\n",
    "cyl_surf.actor.texture_source_object = img\n",
    "cyl_surf.actor.tcoord_generator.prevent_seam = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the wellbore image wrapped around a cylinder in 3D.  After running the cell below you may get a pop up window reporting an error.  Close this window and the image log in 3D will appear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mayavi import mlab\n",
    "from tvtk.api import tvtk # python wrappers for the C++ vtk ecosystem\n",
    "\n",
    "def auto_sphere(image_file):\n",
    "    # create a figure window (and scene)\n",
    "    fig = mlab.figure(size=(600, 600))\n",
    "\n",
    "    # load and map the texture\n",
    "    img = tvtk.JPEGReader()\n",
    "    img.file_name = image_file\n",
    "    texture = tvtk.Texture(input_connection=img.output_port, interpolate=1)\n",
    "    # (interpolate for a less raster appearance when zoomed in)\n",
    "\n",
    "    # use a TexturedSphereSource, a.k.a. getting our hands dirty\n",
    "    R = 1\n",
    "    Nrad = 180\n",
    "\n",
    "    # create the sphere source with a given radius and angular resolution\n",
    "    sphere = tvtk.TexturedSphereSource(radius=R, theta_resolution=Nrad,\n",
    "                                       phi_resolution=Nrad)\n",
    "\n",
    "    # assemble rest of the pipeline, assign texture    \n",
    "    sphere_mapper = tvtk.PolyDataMapper(input_connection=sphere.output_port)\n",
    "    sphere_actor = tvtk.Actor(mapper=sphere_mapper, texture=texture)\n",
    "    fig.scene.add_actor(sphere_actor)\n",
    "\n",
    "image_file = './blue_marble_spherical.jpg'\n",
    "auto_sphere(image_file)\n",
    "mlab.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}