{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added new repo: scijava.public\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c7f61dd8-96fb-4b0c-928c-6e4468c6b686",
       "version_major": 2,
       "version_minor": 0
      },
      "method": "display_data"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "net.imagej.ImageJ@6d87e0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//load ImageJ\n",
    "%classpath config resolver scijava.public https://maven.scijava.org/content/groups/public\n",
    "%classpath add mvn net.imagej imagej 2.0.0-rc-67\n",
    "\n",
    "//create ImageJ object\n",
    "ij = new net.imagej.ImageJ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many `Op`s are written on single `RealType` inputs and outputs for simplicity. This can prove problematic, however, since `Ops` is used most often with images. Thus `map` was created to take such `Op`s and apply them to take pixel of an image. `map` is called as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Available operations:\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapViewIIToII(\n",
       "\t\tIterableInterval in,\n",
       "\t\tUnaryComputerOp op,\n",
       "\t\tType type)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$IIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$IIToRAIParallel(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$RAIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$IIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$IIToRAI(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapUnaryComputers$RAIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapViewRAIToRAI(\n",
       "\t\tRandomAccessibleInterval in,\n",
       "\t\tUnaryComputerOp op,\n",
       "\t\tType type)\n",
       "\t(RandomAccessible out) =\n",
       "\tnet.imagej.ops.map.MapViewRandomAccessToRandomAccess(\n",
       "\t\tRandomAccessible in,\n",
       "\t\tUnaryComputerOp op,\n",
       "\t\tType type)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndIIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndIIToRAIParallel(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndRAIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndRAIToRAIParallel(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndIIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$IIAndIIParallel(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndIIToRAIParallel(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$IIAndRAIParallel(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tRandomAccessibleInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndRAIToIIParallel(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(RandomAccessibleInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$RAIAndIIParallel(\n",
       "\t\tRandomAccessibleInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapIIAndIIInplaceParallel(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplaceOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndIIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndIIToRAI(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndRAIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapIIInplaceParallel(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tUnaryInplaceOp op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$IIAndRAIToRAI(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tIterableInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndIIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$IIAndII(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(RandomAccessibleInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndIIToRAI(\n",
       "\t\tRandomAccessibleInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tIterableInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$IIAndRAI(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tRandomAccessibleInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapBinaryComputers$RAIAndRAIToII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tRandomAccessibleInterval in2,\n",
       "\t\tBinaryComputerOp op)\n",
       "\t(RandomAccessibleInterval arg) =\n",
       "\tnet.imagej.ops.map.MapBinaryInplace1s$RAIAndII(\n",
       "\t\tRandomAccessibleInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplace1Op op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.MapNullaryII(\n",
       "\t\tIterableInterval out,\n",
       "\t\tNullaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.neighborhood.MapNeighborhoodWithCenter(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tShape in2,\n",
       "\t\tCenterAwareComputerOp op)\n",
       "\t(IterableInterval arg) =\n",
       "\tnet.imagej.ops.map.MapIIAndIIInplace(\n",
       "\t\tIterableInterval arg,\n",
       "\t\tIterableInterval in,\n",
       "\t\tBinaryInplaceOp op)\n",
       "\t(Iterable arg) =\n",
       "\tnet.imagej.ops.map.MapIterableInplace(\n",
       "\t\tIterable arg,\n",
       "\t\tUnaryInplaceOp op)\n",
       "\t(Iterable out) =\n",
       "\tnet.imagej.ops.map.MapNullaryIterable(\n",
       "\t\tIterable out,\n",
       "\t\tNullaryComputerOp op)\n",
       "\t(IterableInterval out) =\n",
       "\tnet.imagej.ops.map.neighborhood.DefaultMapNeighborhood(\n",
       "\t\tIterableInterval out,\n",
       "\t\tRandomAccessibleInterval in1,\n",
       "\t\tShape in2,\n",
       "\t\tUnaryComputerOp op)\n",
       "\t(Iterable out) =\n",
       "\tnet.imagej.ops.map.MapIterableToIterable(\n",
       "\t\tIterable out,\n",
       "\t\tIterable in,\n",
       "\t\tUnaryComputerOp op)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ij.op().help(\"map\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see there are a lot of options. Never fear, however, because they all follow a basic pattern of parameters:\n",
    "\n",
    "* output / input: Depending on the `arity` (Nullary/Unary/Binary) and the kind (Computer/Function/Inplace) of `Op`s we are dealing with input(s) and output may be required. The output always comes before the input(s) in the signature.\n",
    "* The `Op` instance: This is made before the call to `map`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import net.imglib2.FinalInterval\n",
    "import net.imglib2.type.numeric.integer.UnsignedByteType\n",
    "\n",
    "//create two images using specified dimensions and type\n",
    "exampleImgDims = new FinalInterval(200, 200)\n",
    "input1 = ij.op().create().img(exampleImgDims, new UnsignedByteType())\n",
    "input2 = ij.op().create().img(exampleImgDims, new UnsignedByteType())\n",
    "\n",
    "//get the maximum possible value of an image data point\n",
    "maxValue = input1.firstElement().getMaxValue()\n",
    "\n",
    "//create a diagonal ramp on the first image\n",
    "cursor1 = input1.cursor()\n",
    "while(cursor1.hasNext()){\n",
    "    intensityValue = (cursor1.getDoublePosition(0) + cursor1.getDoublePosition(1)) * maxValue / 400\n",
    "    cursor1.next().set(intensityValue as int)\n",
    "}\n",
    "\n",
    "//create a blob pattern on the second\n",
    "cursor2 = input2.cursor()\n",
    "while(cursor2.hasNext()){\n",
    "    intensityValue = 64 * (Math.sin(0.1 * cursor2.getDoublePosition(0)) + Math.cos(0.1 * cursor2.getDoublePosition(1))) + 128\n",
    "    cursor2.next().set(intensityValue as int)\n",
    "}\n",
    "\n",
    "//TODO display both inputs side by side\n",
    "ij.notebook().display(input2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have our images we can create the `Op` instance that we will pass to `map`. Let's create a `UnaryComputerOp` that adds two `RealType`s. We can then pass this `UnaryComputerOp` to `map` to add the two images together:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import net.imagej.ops.Ops\n",
    "import net.imagej.ops.special.computer.Computers\n",
    "import net.imglib2.type.numeric.integer.IntType\n",
    "\n",
    "\n",
    "//create an output image with the same dimensions as the input, but with IntType (to prevent overflow)\n",
    "output = ij.op().create().img(input1, new IntType())\n",
    "\n",
    "//the Op needs to know the Type it is working on,\n",
    "//so we will pass through the first element of the image as an example.\n",
    "tempType = input1.firstElement()\n",
    "tempOutputType = output.firstElement()\n",
    "\n",
    "//parameters are (OpService, Class (Op Type), RealType (output), RealType (input 1), RealType(input 2))\n",
    "addOp = Computers.binary(ij.op(), Ops.Math.Add.class, tempOutputType, tempType, tempType)\n",
    "\n",
    "//call the Map Op\n",
    "ij.op().run(\"map\", output, input1, input2, addOp)\n",
    "\n",
    "ij.notebook().display(output)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Groovy",
   "language": "groovy",
   "name": "groovy"
  },
  "language_info": {
   "codemirror_mode": "groovy",
   "file_extension": ".groovy",
   "mimetype": "",
   "name": "Groovy",
   "nbconverter_exporter": "",
   "version": "2.4.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}