diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 65fe4d801..5b2d435b8 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -1,11 +1,10 @@
 .. highlight:: shell
 
-============
+=============
 Contributing
-============
+=============
 
-Contributions are welcome, and they are greatly appreciated! Every little bit
-helps, and credit will always be given.
+Contributions are welcome and greatly appreciated! Every little bit helps, and credit will always be given.
 
 You can contribute in many ways:
 
@@ -26,21 +25,17 @@ If you are reporting a bug, please include:
 Fix Bugs
 ~~~~~~~~
 
-Look through the GitHub issues for bugs. Anything tagged with "bug" and "help
-wanted" is open to whoever wants to implement it.
+Look through the GitHub issues for bugs. Anything tagged with "bug" and "help wanted" is open to whoever wants to implement it.
 
 Implement Features
 ~~~~~~~~~~~~~~~~~~
 
-Look through the GitHub issues for features. Anything tagged with "enhancement"
-and "help wanted" is open to whoever wants to implement it.
+Look through the GitHub issues for features. Anything tagged with "enhancement" and "help wanted" is open to whoever wants to implement it.
 
 Write Documentation
 ~~~~~~~~~~~~~~~~~~~
 
-TIA Toolbox could always use more documentation, whether as part of the
-official TIA Toolbox docs, in docstrings, or even on the web in blog posts,
-articles, and such.
+TIA Toolbox could always use more documentation, whether as part of the official TIA Toolbox docs, in docstrings, or even on the web in blog posts, articles, and such.
 
 Submit Feedback
 ~~~~~~~~~~~~~~~
@@ -50,9 +45,8 @@ The best way to send feedback is to file an issue at https://github.com/TissueIm
 If you are proposing a feature:
 
 * Explain in detail how it would work.
-* Keep the scope as narrow as possible, to make it easier to implement.
-* Remember that this is a volunteer-driven project, and that contributions
-  are welcome :)
+* Keep the scope as narrow as possible to make it easier to implement.
+* Remember that this is a volunteer-driven project, and contributions are welcome :)
 
 Get Started!
 ------------
@@ -64,7 +58,7 @@ Ready to contribute? Here's how to set up ``tiatoolbox`` for local development.
 
     $ git clone git@github.com:your_name_here/tiatoolbox.git
 
-3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
+3. Install your local copy into a virtual environment. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
 
     $ mkvirtualenv tiatoolbox
     $ cd tiatoolbox/
@@ -76,13 +70,18 @@ Ready to contribute? Here's how to set up ``tiatoolbox`` for local development.
 
    Now you can make your changes locally.
 
-5. When you're done making changes, check that your changes pass flake8 and the
-   tests::
+5. When you're done making changes, check that your changes pass pre-commit and the tests::
 
-    $ flake8 tiatoolbox tests
+    $ pre-commit run --all-files
     $ python setup.py test or pytest
 
-   To get flake8, just pip install them into your virtualenv.
+   To get `pre-commit <https://pre-commit.com/#install>`_, just pip install it into your virtual environment using::
+
+    $ pip install pre-commit
+
+   To set up the git hook for pre-commit, run the following command after installing pre-commit::
+
+    $ pre-commit install
 
 6. Commit your changes and push your branch to GitHub::
 
@@ -98,20 +97,15 @@ Pull Request Guidelines
 Before you submit a pull request, check that it meets these guidelines:
 
 1. The pull request should include tests.
-2. If the pull request adds functionality, the docs should be updated. Put
-   your new functionality into a function with a docstring, and add the
-   feature to the list in README.rst.
-3. The pull request should work for Python 3.8, 3.9 and 3.10, and for PyPy. Check
-   https://travis-ci.com/tialab/tiatoolbox/pull_requests
-   and make sure that the tests pass for all supported Python versions.
+2. If the pull request adds functionality, the docs should be updated. Put your new functionality into a function with a docstring, and add the feature to the pull request description.
+3. The pull request should work for Python 3.9, 3.10, 3.11, and 3.12, and for PyPy. Check https://github.com/TissueImageAnalytics/tiatoolbox/actions/workflows/python-package.yml and make sure that the tests pass for all supported Python versions.
 
 Tips
 ----
 
 To run a subset of tests::
 
-$ pytest tests.test_tiatoolbox
-
+    $ pytest tests.test_tiatoolbox
 
 Deploying
 ---------
@@ -120,8 +114,8 @@ A reminder for the maintainers on how to deploy.
 Make sure all your changes are committed (including an entry in HISTORY.rst).
 Then run::
 
-$ poetry version patch # use: "poetry version --help" for other options
-$ git push
-$ git push --tags
+    $ poetry version patch  # use: "poetry version --help" for other options
+    $ git push
+    $ git push --tags
 
-Travis will then deploy to PyPI if tests pass.
+GitHub Actions will then deploy to PyPI if tests pass.
diff --git a/README.md b/README.md
index 3780805a7..1e517db0d 100644
--- a/README.md
+++ b/README.md
@@ -126,7 +126,7 @@ or
 
 ### License
 
-The source code TIA Toolbox (tiatoolbox) as hosted on GitHub is released under the [BSD-3-Clause license](https://github.com/TissueImageAnalytics/tiatoolbox/blob/develop/LICENSE). The full text of the licence is included in [LICENSE](https://raw.githubusercontent.com/TissueImageAnalytics/tiatoolbox/develop/LICENSE).
+The source code TIAToolbox (tiatoolbox) as hosted on GitHub is released under the [BSD-3-Clause license](https://github.com/TissueImageAnalytics/tiatoolbox/blob/develop/LICENSE). The full text of the licence is included in [LICENSE](https://raw.githubusercontent.com/TissueImageAnalytics/tiatoolbox/develop/LICENSE).
 
 Models weights are dependent on the datasets that they were trained on. Please refer to the [documentation](https://tia-toolbox.readthedocs.io/en/latest/pretrained.html) for more details.
 
diff --git a/docs/conf.py b/docs/conf.py
index 91fd2df51..a16b690a8 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -2016,7 +2016,7 @@ def all_but_ipynb(dir_path, contents):
 # Replace the target string
 file_data = file_data.replace(".rst", ".html")
 file_data = file_data.replace(".ipynb", ".html")
-file_data = file_data.replace("](./", "](./jnb/")
+file_data = file_data.replace("](./", "](./_notebooks/jnb/")
 file_data = file_data.replace("../docs/", "./")
 
 # Write the file out again
diff --git a/docs/installation.rst b/docs/installation.rst
index 28c9911da..4739b2c86 100644
--- a/docs/installation.rst
+++ b/docs/installation.rst
@@ -7,28 +7,26 @@ Installation
 
 Prerequisites
 =============
-The prerequisites for tiatoolbox installation are OpenSlide binaries and OpenJpeg version 2.3.0 or above.
-Please follow the instructions below to install prerequisite software according to the platform you are using.
+
+The prerequisites for TIAToolbox installation are OpenSlide binaries and OpenJPEG version 2.3.0 or above. Please follow the instructions below to install the prerequisite software according to your platform.
 
 Linux (Ubuntu)
 --------------
-On Linux the prerequisite software can be installed using the command
+
+On Linux, the prerequisite software can be installed using the following command:
 
 .. code-block:: console
 
     $ apt-get -y install libopenjp2-7-dev libopenjp2-tools openslide-tools
 
-The same command is used when working on the Colab or Kaggle platforms.
-When working on Google Colab, we remove the packages ``datascience`` and ``albumentations`` because they conflict
-and produce an error message.
+The same command is used when working on the Colab or Kaggle platforms. When working on Google Colab, we remove the packages ``datascience`` and ``albumentations`` because they conflict and produce an error message.
 
 Windows (10+)
--------------------
-1. Download OpenSlide binaries from `this page <https://openslide.org/download/>`_. Extract the folder and add ``bin`` and ``lib`` subdirectories to
-Windows `system path <https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14)>`_. If you are using a conda environment you can also copy ``bin`` and ``lib`` subdirectories to ``[Anaconda Installation Path]/envs/[tiatoolbox-environment]/Library/``.
+-------------
 
-2. Install OpenJPEG. The easiest way is to install OpenJpeg is through conda
-using
+1. Download OpenSlide binaries from `this page <https://openslide.org/download/>`_. Extract the folder and add the ``bin`` and ``lib`` subdirectories to the Windows `system path <https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-2010/ee537574(v=office.14)>`_. If you are using a conda environment, you can also copy the ``bin`` and ``lib`` subdirectories to ``[Anaconda Installation Path]/envs/[tiatoolbox-environment]/Library/``.
+
+2. Install OpenJPEG. The easiest way to install OpenJPEG is through conda:
 
 .. code-block:: console
 
@@ -37,7 +35,7 @@ using
 macOS
 -----
 
-On macOS there are two popular package managers, `homebrew`_ and `macports`_.
+On macOS, there are two popular package managers, `homebrew`_ and `macports`_.
 
 .. _homebrew: https://brew.sh/
 .. _macports: https://www.macports.org/
@@ -56,26 +54,26 @@ MacPorts
 
     $ port install openjpeg openslide
 
-
 Installing Stable Release
 =========================
 
-Please note that TIAToolbox is tested for python version 3.9, 3.10, 3.11 and 3.12.
+Please note that TIAToolbox is tested for Python versions 3.9, 3.10, 3.11, and 3.12.
 
 Recommended
 -----------
+
 To install TIAToolbox, run this command in your terminal after you have installed the prerequisite software:
 
 .. code-block:: console
 
     $ pip install tiatoolbox
 
-This is the preferred method to install TIA Toolbox, as it will always install the most recent stable release.
+This is the preferred method to install TIAToolbox, as it will always install the most recent stable release.
 
 Upgrade
 -------
 
-To upgrade an existing version of tiatoolbox to the latest stable release, run this command in your terminal:
+To upgrade an existing version of TIAToolbox to the latest stable release, run this command in your terminal:
 
 .. code-block:: console
 
@@ -84,21 +82,19 @@ To upgrade an existing version of tiatoolbox to the latest stable release, run t
 Without Dependencies
 --------------------
 
-If you already have setup a Python environment with all the pre-requisite software and dependencies installed and you would like to keep the existing versions of these dependencies, run this command in your terminal:
+If you already have a Python environment set up with all the prerequisite software and dependencies installed and you would like to keep the existing versions of these dependencies, run this command in your terminal:
 
 .. code-block:: console
 
     $ pip install --no-deps tiatoolbox
 
-If you don't have `pip`_ installed, this `Python installation guide`_ can guide
-you through the process.
+If you don't have `pip`_ installed, this `Python installation guide`_ can guide you through the process.
 
 .. _pip: https://pip.pypa.io
 .. _Python installation guide: http://docs.python-guide.org/en/latest/starting/installation/
 
-
-Alternative Method(s)
-=====================
+Alternative Methods
+===================
 
 Using Anaconda
 --------------
@@ -115,13 +111,12 @@ or
 
     $ mamba install tiatoolbox
 
+Please note that conda-forge installation support is limited on Windows as OpenSlide binaries are not supported on official conda channels. An alternate way to install using conda on Windows could be to install it in `WSL2 with CUDA support <https://docs.microsoft.com/en-us/windows/ai/directml/gpu-cuda-in-wsl>`_. In some cases, WSL2 runs faster on Python code, and therefore we **recommend** this option.
 
-Please note that conda-forge installation support is limited on Windows as openslide binaries are not supported on official conda channels. An alternate way to install using conda on Windows could be to install it in `WSL2 with CUDA support <https://docs.microsoft.com/en-us/windows/ai/directml/gpu-cuda-in-wsl>`_. In some cases, WSL2 runs faster on Python codes and therefore we **recommend** this option.
-
-From sources
+From Sources
 ------------
 
-The sources for TIA Toolbox can be downloaded from the `Github repo`_.
+The sources for TIAToolbox can be downloaded from the `GitHub repo`_.
 
 You can either clone the public repository:
 
@@ -141,69 +136,65 @@ Once you have a copy of the source, you can install it with:
 
     $ python setup.py install
 
-
-.. _Github repo: https://github.com/TissueImageAnalytics/tiatoolbox.git
+.. _GitHub repo: https://github.com/TissueImageAnalytics/tiatoolbox.git
 .. _tarball: https://github.com/TissueImageAnalytics/tiatoolbox/tarball/master
 
 Using Docker
 ------------
 
-To run TIA toolbox in an isolated environment, use our `Docker image <https://github.com/tissueimageanalytics/tiatoolbox-docker/pkgs/container/tiatoolbox>`_ . We host different Dockerfiles in our github repository `tiatoolbox-docker <https://github.com/TissueImageAnalytics/tiatoolbox-docker>`_. Please report any issues related to the docker image in the repository `tiatoolbox-docker <https://github.com/TissueImageAnalytics/tiatoolbox-docker>`_.
+To run TIAToolbox in an isolated environment, use our `Docker image <https://github.com/tissueimageanalytics/tiatoolbox-docker/pkgs/container/tiatoolbox>`_. We host different Dockerfiles in our GitHub repository `tiatoolbox-docker <https://github.com/TissueImageAnalytics/tiatoolbox-docker>`_. Please report any issues related to the Docker image in the repository `tiatoolbox-docker <https://github.com/TissueImageAnalytics/tiatoolbox-docker>`_.
 
-After `installing Docker <https://docs.docker.com/get-docker/>`_ (or Docker Desktop), you can use our TIA toolbox image in 3 different ways.
+After `installing Docker <https://docs.docker.com/get-docker/>`_ (or Docker Desktop), you can use our TIAToolbox image in three different ways.
 
 Use the Pre-Built Docker Image
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-TIAToolbox provides pre-built docker containers which can be downloaded using the instructions below:
 
-1. Pull the Image From Github Container Registry
-""""""""""""""""""""""""""""""""""""""""""""""""""""
+TIAToolbox provides pre-built Docker containers which can be downloaded using the instructions below:
+
+1. Pull the Image From GitHub Container Registry:
+
 .. code-block:: console
 
     $ docker pull ghcr.io/tissueimageanalytics/tiatoolbox:latest
 
-2. Use the Pre-Built Docker Image as a Base Image in a Dockerfile
-"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
-.. code-block:: console
+2. Use the Pre-Built Docker Image as a Base Image in a Dockerfile:
 
-    $ FROM ghcr.io/tissueimageanalytics/tiatoolbox:latest
+.. code-block:: dockerfile
 
-Build the image locally
+    FROM ghcr.io/tissueimageanalytics/tiatoolbox:latest
+
+Build the Image Locally
 ^^^^^^^^^^^^^^^^^^^^^^^
-1. Navigate to the Dockerfile that you want to use,
-based on the Python version and Operating System that you prefer
 
-2. Build the
-Docker image
+1. Navigate to the Dockerfile that you want to use, based on the Python version and Operating System that you prefer.
+
+2. Build the Docker image:
 
 .. code-block:: console
 
     $ docker build -t <IMAGE_NAME> .
 
-3. Check that the image
-has been created
+3. Check that the image has been created:
 
 .. code-block:: console
 
     $ docker images
 
-4. Deploy the image
-as a Docker container
+4. Deploy the image as a Docker container:
 
 .. code-block:: console
 
     $ docker run -it --rm --name <CONTAINER_NAME> <IMAGE_NAME>
 
-5. Connect to the
-running container
+5. Connect to the running container:
 
 .. code-block:: console
 
     $ docker exec -it <CONTAINER_NAME> bash
 
-To add your own script and run it through the Docker container, first copy your script into the docker environment and then execute it.
+To add your own script and run it through the Docker container, first copy your script into the Docker environment and then execute it:
 
-.. code-block:: console
+.. code-block:: dockerfile
 
-    $ COPY /path/to/<script>.py .
-    $ CMD ["python3", "<script>.py"]
+    COPY /path/to/<script>.py .
+    CMD ["python3", "<script>.py"]
diff --git a/docs/visualization.rst b/docs/visualization.rst
index af237dfb6..0ff795e01 100644
--- a/docs/visualization.rst
+++ b/docs/visualization.rst
@@ -5,34 +5,41 @@ Visualization Interface Usage
 
 TIAToolbox provides a flexible visualization tool for viewing slides and overlaying associated model outputs or annotations. It is a browser-based UI built using TIAToolbox and `Bokeh <https://bokeh.org/>`_. The following assumes TIAToolbox has been installed per the instructions here: :ref:`Installation <installation>`.
 
-1. Launching the interface
+1. Launching the Interface
 --------------------------
 
-Start the interface using the command::
+Start the interface using the command:
+
+.. code-block:: console
 
     tiatoolbox visualize --slides path/to/slides --overlays path/to/overlays
 
-This should cause the interface to appear in a new browser tab.
-Alternatively just one base path can be provided; in this case it is assumed that slides and overlays are in subdirectories of that provided directory called 'slides' and 'overlays' respectively::
+This should cause the interface to appear in a new browser tab. Alternatively, you can provide just one base path; in this case, it is assumed that slides and overlays are in subdirectories of that provided directory called 'slides' and 'overlays' respectively:
+
+.. code-block:: console
 
     tiatoolbox visualize --base-path path/to/parent_of_slides_and_overlays
 
-In the folder(s) that your command pointed to, should be the things that you want to visualize, following the conventions in :ref:`Data formats <data_format>`.
+In the folder(s) that your command pointed to, there should be the items you want to visualize, following the conventions in :ref:`Data formats <data_format>`.
+
+If you need to change the port on which the interface is launched from the default of 5006, you can do so using the --port flag:
 
-If you need to change the port on which the interface is launched from the default of 5006, you can do so using the --port flag::
+.. code-block:: console
 
     tiatoolbox visualize --slides path/to/slides --overlays path/to/overlays --port 5001
 
 Though in most cases this should not be necessary.
 
-Launching on a remote machine
+Launching on a Remote Machine
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-As the UI is browser-based, you can launch the interface on a remote machine by logging in via ssh and forwarding the relevant ports so that the visualization of the remote slides and overlays can be viewed in the browser on your local machine. For example, connect via ssh to your remote machine::
+As the UI is browser-based, you can launch the interface on a remote machine by logging in via SSH and forwarding the relevant ports so that the visualization of the remote slides and overlays can be viewed in the browser on your local machine. For example, connect via SSH to your remote machine:
+
+.. code-block:: console
 
     ssh -L 5006:localhost:5006 -L 5000:localhost:5000 user@remote_machine
 
-This will start a ssh session where the two ports the interface uses by default (5006 and 5000) are forwarded.
+This will start an SSH session where the two ports the interface uses by default (5006 and 5000) are forwarded.
 
 You can then launch the interface on the remote machine as above (TIAToolbox must be installed on the remote machine) and open the browser on your local machine. Navigate to ``localhost:5006`` to view the interface.
 
@@ -46,13 +53,13 @@ You can then launch the interface on the remote machine as above (TIAToolbox mus
     :align: center
     :alt: visualize interface
 
-The interface is split into two main sections. The left-hand side contains the main window, which displays the slide and overlays (or potentially a linked pair of slide views), and the right hand side contains a number of UI elements to control the display of the overlays.
+The interface is split into two main sections. The left-hand side contains the main window, which displays the slide and overlays (or potentially a linked pair of slide views), and the right-hand side contains a number of UI elements to control the display of the overlays.
 
 The main window can be zoomed in and out using the mouse wheel and panned by clicking and dragging. The slide can be changed using the slide dropdown menu. The overlay can be changed, or additional overlays added using the overlay dropdown menu. Note: overlays involving a large number of annotations may take a short while to load. The alpha of the slide and overlay can be controlled using the slide and overlay alpha sliders respectively.
 
-Information about the currently open slide can be found below the main window including slide name, dimensions, and level resolution information.
+Information about the currently open slide can be found below the main window, including slide name, dimensions, and level resolution information.
 
-Type and layer select
+Type and Layer Select
 ^^^^^^^^^^^^^^^^^^^^^
 
 .. image:: images/type_select.png
@@ -60,26 +67,25 @@ Type and layer select
     :align: right
     :alt: type select example
 
-If annotations have a type property, this will be used to populate the type select boxes. This allows you to toggle on/off annotations of a specific type. You can also modify the default colors that each type is displayed in by using the color picker widgets next to each type name (note these will only have an effect if the property to color by is selected as 'type'). Individual image overlays or graph overlays will also get their own toggle, labelled for example 'layer_i' or 'nodes', that can be used to toggle the respective overlays on or off.
+If annotations have a type property, this will be used to populate the type select boxes. This allows you to toggle on/off annotations of a specific type. You can also modify the default colors that each type is displayed in by using the color picker widgets next to each type name (note these will only have an effect if the property to color by is selected as 'type'). Individual image overlays or graph overlays will also get their own toggle, labeled for example 'layer_i' or 'nodes', that can be used to toggle the respective overlays on or off.
 
-Colormaps/coloring by property values
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Colormaps/Coloring by Property Values
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Once you have selected a slide with the slide dropdown, you can add overlays by repeatedly choosing files containing overlays from the overlay drop menu. They will be overlaid on the slide as separate layers. In the case of segmentations, if your segmentations have the 'type' property as one of their properties, this can additionally be used to show/hide annotations of that specific type. colors can be individually selected for each type also if the randomly generated color scheme is not suitable.
+Once you have selected a slide with the slide dropdown, you can add overlays by repeatedly choosing files containing overlays from the overlay drop menu. They will be overlaid on the slide as separate layers. In the case of segmentations, if your segmentations have the 'type' property as one of their properties, this can additionally be used to show/hide annotations of that specific type. Colors can be individually selected for each type if the randomly generated color scheme is not suitable.
 
-You can select the property that will be used to color annotations in the color_by box. The corresponding property should be either categorical (strings or ints), in which case a dict-based color mapping should be used, or a float between 0-1 in which case a matplotlib colormap should be applied.
-There is also the option for the special case 'color' to be used. If your annotations have a property called color, this will be assumed to be an RGB value in the form of a tuple (R, G, B) of floats between 0-1 for each annotation which will be used directly without any mapping.
+You can select the property that will be used to color annotations in the color_by box. The corresponding property should be either categorical (strings or ints), in which case a dict-based color mapping should be used, or a float between 0-1 in which case a matplotlib colormap should be applied. There is also the option for the special case 'color' to be used. If your annotations have a property called color, this will be assumed to be an RGB value in the form of a tuple (R, G, B) of floats between 0-1 for each annotation which will be used directly without any mapping.
 
-The 'color type by property' box allows annotations of the specified type to be colored by a different property to the 'global' one. For example, this could be used to have all detections colored according to their type, but for Glands, color by some feature describing them instead (their area, for example)
+The 'color type by property' box allows annotations of the specified type to be colored by a different property to the 'global' one. For example, this could be used to have all detections colored according to their type, but for Glands, color by some feature describing them instead (their area, for example).
 
-Running models
+Running Models
 ^^^^^^^^^^^^^^
 
 Regions of the image can be selected, using either a box select or points, which can be sent to a model via selecting the model in the drop-down menu and then clicking go. Available so far is hovernet, and nuclick will likely be added in the future.
 
-To save the annotations resulting from a model, or loaded from a .geojson or .dat (will be saved as a SQLiteStore .db file which will be far quicker to load) use the save button (for the moment it is just saved in a file '{slide_name}\_saved_anns.db' in the overlays folder).
+To save the annotations resulting from a model, or loaded from a .geojson or .dat (will be saved as a SQLiteStore .db file which will be far quicker to load), use the save button (for the moment it is just saved in a file '{slide_name}\_saved_anns.db' in the overlays folder).
 
-Dual window mode
+Dual Window Mode
 ^^^^^^^^^^^^^^^^
 
 .. image:: images/dual_win.png
@@ -87,10 +93,9 @@ Dual window mode
     :align: center
     :alt: dual window example
 
-A second window can be opened by selecting the 'window 2' tab in the top right. This will open the currently selected slide in a second window as illustrated above. The overlay shown in each window can be controlled independently to allow comparison of different overlays, or viewing of a model output side-by-side with the raw image (slide), or ground truth annotations. Slide navigation will be linked between both windows.
-Two different slides can also be opened in the two windows, although this will only be useful in cases where the two slides are registered so that a shared coordinate space/slide navigation makes sense.
+A second window can be opened by selecting the 'window 2' tab in the top right. This will open the currently selected slide in a second window as illustrated above. The overlay shown in each window can be controlled independently to allow comparison of different overlays, or viewing of a model output side-by-side with the raw image (slide), or ground truth annotations. Slide navigation will be linked between both windows. Two different slides can also be opened in the two windows, although this will only be useful in cases where the two slides are registered so that a shared coordinate space/slide navigation makes sense.
 
-Inspecting annotations
+Inspecting Annotations
 ^^^^^^^^^^^^^^^^^^^^^^
 
 .. image:: images/properties_window.png
@@ -98,21 +103,19 @@ Inspecting annotations
     :align: right
     :alt: properties window example
 
-Annotations can be inspected by double clicking on them. This will open a popup showing the annotation in more detail, and allowing the properties to be viewed in a sortable table. An example can be seen to the right for a patch prediction overlay where multiple targets have been predicted for each patch.
+Annotations can be inspected by double-clicking on them. This will open a popup showing the annotation in more detail, and allowing the properties to be viewed in a sortable table. An example can be seen to the right for a patch prediction overlay where multiple targets have been predicted for each patch.
 
-Zoomed out plotting
+Zoomed Out Plotting
 ^^^^^^^^^^^^^^^^^^^
 
 By default, the interface is set up to show only larger annotations while zoomed out. Smaller annotations which would be too small to see clearly while zoomed out will not be displayed. The 'max-scale' value can be changed to control the zoom level at which this happens. A larger value will mean smaller annotations remain visible at more zoomed out scale. If you want all annotations to be displayed always regardless of zoom, just type in a large value (1000+) to set it to its max. In the case of very many annotations, this may result in some loading lag when zoomed out.
 
-Other options
+Other Options
 ^^^^^^^^^^^^^
 
-There are a few options for how annotations are displayed. You can change the colormap used in the colormap field if you are coloring objects according to a continuous property (values should be between 0-1), by choosing one of the matplotlib cmaps.
-The buttons 'filled', 'mpp', 'grid', respectively toggle between filled and outline only rendering of annotations, using mpp or baseline pixels as the scale for the plot, and showing a grid overlay.
+There are a few options for how annotations are displayed. You can change the colormap used in the colormap field if you are coloring objects according to a continuous property (values should be between 0-1), by choosing one of the matplotlib cmaps. The buttons 'filled', 'mpp', 'grid', respectively toggle between filled and outline only rendering of annotations, using mpp or baseline pixels as the scale for the plot, and showing a grid overlay.
 
-A filter can be applied to annotations using the filter box. For example, entering props\['score'\]>0.5 would show only annotations for which the 'score' property is greater than 0.5.
-See the documentation in :obj:`AnnotationStore <tiatoolbox.annotation.storage.AnnotationStore>` on valid 'where' statements for more details.
+A filter can be applied to annotations using the filter box. For example, entering props\['score'\]>0.5 would show only annotations for which the 'score' property is greater than 0.5. See the documentation in :obj:`AnnotationStore <tiatoolbox.annotation.storage.AnnotationStore>` on valid 'where' statements for more details.
 
 The main slide view can be made fullscreen by clicking the fullscreen icon in the small toolbar to the immediate right of the main window. This toolbar also provides a button to save the current view as a .png file.
 
@@ -121,7 +124,7 @@ The main slide view can be made fullscreen by clicking the fullscreen icon in th
 3. Data Format Conventions and File Structure
 ---------------------------------------------
 
-In the slides folder should be all the slides you want to use, and the overlays folder should contain whatever graphs, segmentations, heatmaps etc you are interested in overlaying over the slides.
+In the slides folder should be all the slides you want to use, and the overlays folder should contain whatever graphs, segmentations, heatmaps, etc., you are interested in overlaying over the slides.
 
 When a slide is selected in the interface, any valid overlay file that can be found that *contains the same name* (not including extension) will be available to overlay upon it.
 
@@ -133,9 +136,9 @@ Segmentation
     :align: right
     :alt: segmentation example
 
-To visualize segmentation, please save your results in the AnnotationStore format (more information about the TIAToolbox annotation store can be found at :obj:`storage <tiatoolbox.annotation.storage>`).  The other options are GeoJSON (.geojson), or a HoVerNet -style .dat (see :obj:`hovernet <tiatoolbox.models.architecture.hovernet>`). The GeoJSON and dat format can be loaded within the interface but will incur a delay as the data needs to be converted internally into an AnnotationStore for optimized visualization experience.
+To visualize segmentation, please save your results in the AnnotationStore format (more information about the TIAToolbox annotation store can be found at :obj:`storage <tiatoolbox.annotation.storage>`). Other options are GeoJSON (.geojson) or a HoVerNet-style .dat (see :obj:`hovernet <tiatoolbox.models.architecture.hovernet>`). The GeoJSON and .dat formats can be loaded within the interface but will incur a delay as the data needs to be converted internally into an AnnotationStore for an optimized visualization experience.
 
-If your annotations are in a geojson format following the sort of thing QuPath would output, that should be ok. Contours stored following hovernet-style output in a .dat file should also work. An overview of the data structure in these formats is below.
+If your annotations are in a GeoJSON format following the sort of thing QuPath would output, that should be okay. Contours stored following HoVerNet-style output in a .dat file should also work. An overview of the data structure in these formats is below.
 
 HoVerNet style::
 
@@ -145,14 +148,13 @@ HoVerNet style::
                     contour: List[List[]],
                     prob: float,
                     type: int
-                ... #can add as many additional properties as we want...
+                ... # can add as many additional properties as we want...
                             }
                 ... # other instances
                 }
 
 Files in this format can be converted to an AnnotationStore using: :obj:`store_to_dat <tiatoolbox.utils.misc.store_from_dat>`. This utility function should also be able to handle .dats output from `Cerberus <https://github.com/TissueImageAnalytics/cerberus>`_.
 
-
 GeoJSON::
 
     {
@@ -164,14 +166,13 @@ GeoJSON::
     }}
 
 Files in this format can be converted to an AnnotationStore using the method:
-:obj:`AnnotationStore.from_geojson() <tiatoolbox.annotation.storage.AnnotationStore>`
+:obj:`AnnotationStore.from_geojson() <tiatoolbox.annotation.storage.AnnotationStore>`.
 
-While data in these formats can be loaded directly into the interface, it is recommended to convert and save them as an annotation store outside the interface, as this will be much faster to load.
+While data in these formats can be loaded directly into the interface, it is recommended to convert and save them as an AnnotationStore outside the interface, as this will be much faster to load.
 
-TIAToolbox also provides a function to convert the output of PatchPredictor to an annotation store, which can be found at :obj:`dict_to_store <tiatoolbox.utils.misc.dict_to_store>`.
+TIAToolbox also provides a function to convert the output of PatchPredictor to an AnnotationStore, which can be found at :obj:`dict_to_store <tiatoolbox.utils.misc.dict_to_store>`.
 
-If your data is not in one of these formats, it is usually fairly straightforward to build an annotation store out of your model outputs. A small script of 6-10 lines is usually all that is required. There are example code snippets illustrating how to create an annotation store in a variety of common scenarios in the examples section.
-Most use-cases should be covered in there, or something close enough that a few tweaks to a snippet will do what is needed.
+If your data is not in one of these formats, it is usually fairly straightforward to build an AnnotationStore out of your model outputs. A small script of 6-10 lines is usually all that is required. There are example code snippets illustrating how to create an AnnotationStore in a variety of common scenarios in the examples section. Most use-cases should be covered in there, or something close enough that a few tweaks to a snippet will do what is needed.
 
 Heatmaps
 ^^^^^^^^
@@ -183,7 +184,7 @@ Single channel images can also be used but are not recommended; they should take
 Whole Slide Overlays
 ^^^^^^^^^^^^^^^^^^^^
 
-It is possible to overlay multiple WSI's on top of each other as separate layers simply by selecting them in the overlays dropdown, though if the visualization task can be achieved using another form of overlay, that would be recommended as it will usually be more flexible and faster to load.
+It is possible to overlay multiple WSIs on top of each other as separate layers simply by selecting them in the overlays dropdown, though if the visualization task can be achieved using another form of overlay, that would be recommended as it will usually be more flexible and faster to load.
 
 Graphs
 ^^^^^^
@@ -193,8 +194,7 @@ Graphs
     :align: right
     :alt: graph example
 
-Graphs can also be overlaid. The display of nodes and edges can be toggled on/off independently in the right hand panel of the interface (note, edges will be turned off by default; they can be made visible by toggling the 'edges' toggle in the UI). An example of a graph overlay is shown to the right. Graph overlays should be provided in a dictionary format with keys as described below, saved as a .json file.
-
+Graphs can also be overlaid. The display of nodes and edges can be toggled on/off independently in the right-hand panel of the interface (note, edges will be turned off by default; they can be made visible by toggling the 'edges' toggle in the UI). An example of a graph overlay is shown to the right. Graph overlays should be provided in a dictionary format with keys as described below, saved as a .json file.
 
 E.g.::
 
@@ -203,8 +203,7 @@ E.g.::
             'coordinates': n x 2 array of x, y coordinates for each graph node (at baseline resolution)
             }
 
-
-Additional features can be added to nodes by adding extra keys to the dictionary, eg:
+Additional features can be added to nodes by adding extra keys to the dictionary, e.g.:
 
 ::
 
@@ -215,20 +214,17 @@ Additional features can be added to nodes by adding extra keys to the dictionary
                 'feat_names': list n_features names for each feature
             }
 
-
-It will be possible to color the nodes by these features in the interface, and the top 10 will appear in a tooltip when hovering over a node (you will have to turn on the hovertool in the small toolbar to the right of the main window to enable this, it is disabled by default.)
-
+It will be possible to color the nodes by these features in the interface, and the top 10 will appear in a tooltip when hovering over a node (you will have to turn on the hovertool in the small toolbar to the right of the main window to enable this, it is disabled by default).
 
 .. _examples:
 
-4. Annotation Store examples
+4. Annotation Store Examples
 ----------------------------
 
 Patch Predictions
 ^^^^^^^^^^^^^^^^^
 
-Let's say you have patch level predictions for a model. The top left corner
-of each patch, and two predicted scores are in a .csv file. Patch size is 512.
+Let's say you have patch-level predictions for a model. The top left corner of each patch, and two predicted scores are in a .csv file. Patch size is 512.
 
 ::
 
@@ -244,15 +240,14 @@ of each patch, and two predicted scores are in a .csv file. Patch size is 512.
             Annotation(Polygon.from_bounds(x, y, x + 512, y + 512), properties=properties)
         )
     db.append_many(annotations)
-    db.dump("path/to/filename.db")   # filename should contain its associated slides name
+    db.dump("path/to/filename.db")   # filename should contain its associated slide's name
 
 When loading the above in the interface, you will be able to select any of the properties to color the overlay by.
 
-GeoJSON outputs
+GeoJSON Outputs
 ^^^^^^^^^^^^^^^
 
-While .geojson files can be loaded in the interface directly, it is often more convenient to convert them to a .db file first, as this will avoid the delay while the geojson is converted to an annotation store.
-The TIAToolbox AnnotationStore class provides a method to do this.
+While .geojson files can be loaded in the interface directly, it is often more convenient to convert them to a .db file first, as this will avoid the delay while the geojson is converted to an AnnotationStore. The TIAToolbox AnnotationStore class provides a method to do this.
 
 ::
 
@@ -260,18 +255,18 @@ The TIAToolbox AnnotationStore class provides a method to do this.
     db1 = SQLiteStore.from_geojson(geojson_path)
     db1.dump("path/to/annotations.db")
 
-Raw contours and properties
+Raw Contours and Properties
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-If you have a collection of raw centroids or detection contours with corresponding properties/scores, you can easily convert these to an annotation store.
+If you have a collection of raw centroids or detection contours with corresponding properties/scores, you can easily convert these to an AnnotationStore.
 
 ::
 
     centroid_list = [[1, 4], [3, 2]] # etc...
-    # if its contours each element is a list of points instead
+    # if it's contours each element is a list of points instead
     properties_list = [
         {"score": "some_score", "class": "some_class"},
-        {"score": "other _score", "class": "other_class"},
+        {"score": "other_score", "class": "other_class"},
         # etc...
     ]
 
@@ -288,11 +283,10 @@ If you have a collection of raw centroids or detection contours with correspondi
 
 Note that in the above we saved the 'class' property as 'type' - this is because the UI treats the 'type' property as a special property, and will allow you to toggle annotations of a specific type on/off, in addition to other functionality.
 
-Graphs example
+Graphs Example
 ^^^^^^^^^^^^^^
 
-Let's say you have a graph defined by nodes and edges,
-and associated node properties. The following example demonstrates how to package this into a .json file
+Let's say you have a graph defined by nodes and edges, and associated node properties. The following example demonstrates how to package this into a .json file:
 
 ::
 
@@ -305,11 +299,10 @@ and associated node properties. The following example demonstrates how to packag
     with open("path/to/graph.json", "w") as f:
         json.dump(graph_dict, f)
 
-Modifying an existing annotation store
+Modifying an Existing Annotation Store
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-If you have an existing annotation store and want to add/change
-properties of annotations (or can also do similarly for geometry)
+If you have an existing annotation store and want to add/change properties of annotations (or can also do similarly for geometry):
 
 ::
 
@@ -329,12 +322,10 @@ properties of annotations (or can also do similarly for geometry)
         db.keys(), properties_iter=new_props
     )  # replace the properties dict for each annotation
 
-Merging two annotation stores
+Merging Two Annotation Stores
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The interface will only open one annotation store at a time. If you have annotations
-belonging to the same slide in different stores that you want to display
-at the same time, just put them all in the same store as follows
+The interface will only open one annotation store at a time. If you have annotations belonging to the same slide in different stores that you want to display at the same time, just put them all in the same store as follows:
 
 ::
 
@@ -343,10 +334,10 @@ at the same time, just put them all in the same store as follows
     anns = list(db1.items())
     db2.append_many(anns)  # db2 .db file now contains all annotations from db1 too
 
-Shifting coordinates
+Shifting Coordinates
 ^^^^^^^^^^^^^^^^^^^^
 
-Let's say you have some annotations that were created on a slide, and you want to grab the annotations in a particular region and display them on a tile from that slide. You will need their coordinates to be relative to the tile. You can do this as follows
+Let's say you have some annotations that were created on a slide, and you want to grab the annotations in a particular region and display them on a tile from that slide. You will need their coordinates to be relative to the tile. You can do this as follows:
 
 ::
 
@@ -357,23 +348,21 @@ Let's say you have some annotations that were created on a slide, and you want t
         top_left[0], top_left[1], top_left[0] + tile_size, top_left[1] + tile_size
     )
     db2 = SQLiteStore()
-    tile_anns = db1.query(query_geom) # get all annotations in the tile
-    db2.append_many(tile_anns.values(), tile_anns.keys()) # add them to a new store
-
+    tile_anns = db1.query(query_geom)  # get all annotations in the tile
+    db2.append_many(tile_anns.values(), tile_anns.keys())  # add them to a new store
 
     def translate_geom(geom):
         return geom.translate(-top_left[0], -top_left[1])
 
-
     db2.transform(translate_geom)  # translate so coordinates relative to top left of tile
     db2.dump("path/to/tile_annotations.db")
 
 .. _config:
 
-5. Config files
+5. Config Files
 ---------------
 
-A JSON config file can be placed in the overlays folder, to customize various aspects of the UI and annotation display when visualizing overlays in that location. This is especially useful for customising online demos. An example .json explaining all the fields is shown below.
+A JSON config file can be placed in the overlays folder to customize various aspects of the UI and annotation display when visualizing overlays in that location. This is especially useful for customizing online demos. An example .json explaining all the fields is shown below.
 
 There are settings to control how slides are loaded:
 
@@ -431,7 +420,7 @@ and the ability to toggle on or off specific UI elements:
         "cprop_input": 1,           # box to select which property to color annotations by ('color by' box)
         "cmap_row": 1,              # row of UI elements with colormap select, blur, max_scale
         "type_cmap_select": 1,      # UI element to select a secondary colormap for a specific type (i.e 'color type by' box)
-        "model_row": 0,             # UI elements to chose and run a model
+        "model_row": 0,             # UI elements to choose and run a model
         "type_select_row": 1        # button group for toggling specific types of annotations on/off
     },
 
diff --git a/examples/README.md b/examples/README.md
index 376b61c11..d33e6884d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,40 +1,40 @@
 # About the Example Notebooks
 
-In this directory, you will find some example use cases of the TIAToolbox functionalities in the form of Jupyter Notebooks. All of these notebooks are designed and maintained to run on Colab platforms (unless otherwise stated) but you can run them on your own system as well. In the first cell of each example notebook, there are links to open the notebook in Google Colab and GitHub. Simply clicking on one of these links opens that notebook on the selected platform. You can right-click on "Open in Colab" and select "Open in new tab" if the left click does not work for you.
+In this directory, you will find example use cases of TIAToolbox functionalities in the form of Jupyter Notebooks. These notebooks are designed to run on Google Colab (unless otherwise stated), but you can also run them on your local system. Each example notebook includes links to open the notebook in Google Colab and GitHub. Simply click on one of these links to open the notebook on the selected platform. If the left click does not work, you can right-click on "Open in Colab" and select "Open in new tab".
 
-## Local Machine
+## Running Notebooks Locally
 
-To run the notebook on other platforms, such as your own computer, set up your Python environment, as explained in the [installation guide](../docs/installation.rst).
+To run the notebooks on your local machine, set up your Python environment as explained in the [installation guide](../docs/installation.rst).
 
-## [Google Colab](https://colab.research.google.com/)
+## Running Notebooks on [Google Colab](https://colab.research.google.com/)
 
-Each notebook contains all the information needed to run the example remotely on Colab. All that you need is a local computer at your fingertips, with a standard browser connected to the Internet. The local computer does not even need a programming language to be installed—all the crucial resources are provided at the remote site, free of charge, thanks to Google Colaboratory. Check that "colab" appears in the address bar. Familiarize yourself with the drop-down menus near the top of the window. You can edit the notebook during the session, for example substituting your own image files for the image files used in this demo. Experiment by changing the parameters of functions. It is not possible for an ordinary user to permanently change this version of the notebook on GitHub or Colab, so you cannot inadvertently mess it up. Use the notebook's File Menu if you wish to save your own (changed) notebook.
+Each notebook contains all the information needed to run the example remotely on Colab. All you need is a local computer with a standard browser connected to the Internet. The local computer does not need to have any programming languages installed—all necessary resources are provided at the remote site, free of charge, thanks to Google Colaboratory. Ensure that "colab" appears in the address bar. Familiarize yourself with the drop-down menus near the top of the window. You can edit the notebook during the session, for example, by substituting your own image files for those used in the demo. Experiment by changing the parameters of functions. You cannot permanently change this version of the notebook on GitHub or Colab, so you cannot inadvertently mess it up. Use the notebook's File Menu if you wish to save your own (changed) version.
 
-### GPU or CPU runtime
+### GPU or CPU Runtime
 
-Processes in the notebooks can be accelerated by using a GPU. Therefore, whether you are running the notebook on your system or Colab, you need to check and specify if you are using GPU or CPU hardware acceleration. In Colab, you need to make sure that the runtime type is set to GPU in the *"Runtime→Change runtime type→Hardware accelerator"*. If you are *not* using GPU, consider changing the `ON_GPU` flag to `False` value, otherwise, some errors will be raised when running the following cells.
+Processes in the notebooks can be accelerated by using a GPU. Whether you are running the notebook on your system or Colab, you need to check and specify if you are using GPU or CPU hardware acceleration. In Colab, ensure that the runtime type is set to GPU in the *"Runtime → Change runtime type → Hardware accelerator"*. If you are *not* using GPU, consider changing the `device` variable to `cpu`, otherwise, some errors may occur when running the following cells.
 
-> **IMPORTANT**: If you are using Colab and install tiatoolbox, please note that you need to restart the runtime after tiatoolbox installation before proceeding through (menu) *"Runtime→Restart runtime"* . This is needed to load the latest versions of prerequisite packages installed with TIAToolbox. Doing so, you should be able to run all the remaining cells altogether (*"Runtime→Run after"* from the next cell) or one by one.
+> **IMPORTANT**: If you are using Colab and install TIAToolbox, please note that you need to restart the runtime after installation before proceeding (menu: *"Runtime → Restart runtime"*). This is necessary to load the latest versions of prerequisite packages installed with TIAToolbox. After restarting, you should be able to run all the remaining cells together (*"Runtime → Run after"* from the next cell) or one by one.
 
-## Structure of the examples directory
+## Structure of the Examples Directory
 
-We explain here the structure of the examples directory and briefly describe our notebooks. (Except for technical minutiae, the words _folder_ and _directory_ are interchangeable.) The examples directory includes general notebooks explaining different functionalities/modules incorporated in TIAToolbox. Most of these notebooks are written with less advanced users in mind—some familiarity with Python is assumed—but the capabilities they demonstrate would also be useful to more advanced users.
+The examples directory includes general notebooks explaining different functionalities/modules incorporated in TIAToolbox. Most of these notebooks are written with less advanced users in mind—some familiarity with Python is assumed—but the capabilities they demonstrate are also useful to more advanced users.
 
-The example directory contains two subdirectories called `full-pipelines` and `inference-pipelines` that include examples of using TIAToolbox in training of neural networks or inference of WSIs for high-level CPath applications, such as patient survival prediction and MSI status prediction from H&E whole slide images.
+The examples directory contains two subdirectories: `full-pipelines` and `inference-pipelines`, which include examples of using TIAToolbox for training neural networks or inference of WSIs for high-level computational pathology applications, such as patient survival prediction and MSI status prediction from H&E whole slide images.
 
-## A) Examples of TIAToolbox functionalities
+## A) Examples of TIAToolbox Functionalities
 
-We now give a list of our Jupyter notebooks, giving a brief description of the TIAToolbox functionalities that each of the notebook provides.
+Below is a list of our Jupyter notebooks, with brief descriptions of the TIAToolbox functionalities each notebook provides.
 
-### 1- Reading Whole Slide Images ([01-wsi-reading](./01-wsi-reading.ipynb))
+### 1. Reading Whole Slide Images ([01-wsi-reading](./01-wsi-reading.ipynb))
 
 This notebook shows how to use TIAToolbox to read different kinds of WSIs. TIAToolbox provides a uniform interface to various WSI formats. To see what formats are dealt with, click [here](https://tia-toolbox.readthedocs.io/en/latest/usage.html?highlight=wsiread#tiatoolbox.wsicore.wsireader.WSIReader) and then search for _format_. In this notebook, you will learn some well-known techniques for WSI masking and patch extraction.
 
 [![image](../docs/images/wsi-reading.png)](./01-wsi-reading.ipynb)
 
-### 2- Stain normalization of histology images ([02-stain-normalization](./02-stain-normalization.ipynb))
+### 2. Stain Normalization of Histology Images ([02-stain-normalization](./02-stain-normalization.ipynb))
 
-Stain normalization is a common pre-processing step in computational pathology, whose objective is to reduce, as much as possible, colour variation that has no clinical significance. This variation may be caused by using different scanners, different staining protocols and practices, staining agents that have been left on the laboratory shelf for different lengths of time, different settings when using the scanner, etc. It has been shown in many studies that stain normalization can make an algorithm more robust against such differences. TIAToolbox makes a few different stain-normalization algorithms available to the use. The implemented stain normalization methods in TIAToolbox are:
+Stain normalization is a common pre-processing step in computational pathology to reduce color variation that has no clinical significance. This variation may be caused by using different scanners, different staining protocols and practices, staining agents that have been left on the laboratory shelf for different lengths of time, different settings when using the scanner, etc. It has been shown in many studies that stain normalization can make an algorithm more robust against such differences. TIAToolbox offers several stain-normalization algorithms, including:
 
 - Reinhard stain normalization
 - Ruifork
@@ -45,69 +45,67 @@ Alternatively, if you prefer, you can use your own stain matrix for stain normal
 
 [![image](../docs/images/stain-norm-example.png)](./02-stain-normalization.ipynb))
 
-### 3- Extracting tissue mask (tissue region) from whole slide images ([03-tissue-masking](./03-tissue-masking.ipynb))
+### 3. Extracting Tissue Mask from Whole Slide Images ([03-tissue-masking](./03-tissue-masking.ipynb))
 
-WSIs often show large blank (glass) background areas that contain no information. Therefore, it is essential to detect the informative (tissue) region in the WSI before taking any action (like patch extraction and classification). We call this step, "tissue masking" which is the focus of this example notebook. This notebook shows how to extract tissue regions from a WSI with the help of TIAToolbox and a single line of Python code.
+WSIs often show large blank (glass) background areas that contain no information. Therefore, it is essential to detect the informative (tissue) region in the WSI before taking any action (like patch extraction and classification). We call this step, "tissue masking" which is the focus of this example notebook. This notebook shows how to extract tissue regions from a WSI using TIAToolbox with a single line of Python code.
 
 [![image](../docs/images/tissue-mask.png)](./03-tissue-masking.ipynb)
 
-### 4- Extracting patches from whole slide images ([04-patch-extraction](./04-patch-extraction.ipynb))
+### 4. Extracting Patches from Whole Slide Images ([04-patch-extraction](./04-patch-extraction.ipynb))
 
-This notebook uses TIAToolbox to extract patches from a large histology image. Tiatoolbox can extract patches based on point annotations or using a fixed-size sliding window. The patch extraction module of TIAToolbox supports mask-based patch extraction which means you can extract (overlapping, if you prefer) patches from a certain region of WSI (for example a region consisting of a particular type of tissue).
+Learn how to use TIAToolbox to extract patches from large histology images based on point annotations or using a fixed-size sliding window. The patch extraction module of TIAToolbox supports mask-based patch extraction which means you can extract (overlapping, if you prefer) patches from a certain region of WSI (for example a region consisting of a particular type of tissue).
 
 [![image](../docs/images/patch-extraction.png)](./04-patch-extraction.ipynb)
 
-### 5- Patch prediction in whole slide images ([05-patch-prediction](./05-patch-prediction.ipynb))
+### 5. Patch Prediction in Whole Slide Images ([05-patch-prediction](./05-patch-prediction.ipynb))
 
-In this notebook, we use TIAToolbox for patch-level prediction, using a range of deep learning models. TIAToolbox can be used to make predictions on pre-extracted image patches or on larger image tiles / whole-slide images (WSIs), where image patches are extracted on the fly. There are various state-of-the-art deep learning models implemented in TIAToolbox, pretrained on datasets related to different cancer types. With just two lines of Python code, any of these models can be used out of the box to predict the type of patches in a WSI. For example, in colorectal cancer, TIAToolbox can classify whole slide image regions into nine different categories (Empty glass, Lymphocytes, Normal colon mucosa, Debris, Smooth muscle, Cancer-associated stroma, Adipose, Mucus, Colorectal adenocarcinoma epithelium).
+Use TIAToolbox for patch-level prediction with a range of deep learning models. Predict the type of patches in a WSI with just two lines of Python code. TIAToolbox can be used to make predictions on pre-extracted image patches or on larger image tiles / whole-slide images (WSIs), where image patches are extracted on the fly. For example, in colorectal cancer, TIAToolbox can classify whole slide image regions into nine different categories (Empty glass, Lymphocytes, Normal colon mucosa, Debris, Smooth muscle, Cancer-associated stroma, Adipose, Mucus, Colorectal adenocarcinoma epithelium).
 
 [![image](../docs/images/patch-prediction.png)](./05-patch-prediction.ipynb)
 
-### 6- Semantic segmentation of whole slide images ([06-semantic-segmentation](./06-semantic-segmentation.ipynb))
+### 6. Semantic Segmentation of Whole Slide Images ([06-semantic-segmentation](./06-semantic-segmentation.ipynb))
 
-_Semantic segmentation_ groups together similar parts of an image that belong to the same class, as in the image immediately above and in the image below. Semantic segmentation of tissue regions plays an important role in developing algorithms for cancer diagnosis and prognosis, as it can help measure tissue attributes in an objective and reproducible fashion. In this notebook, we use pretrained models to automatically segment different tissue region types in a set of input images or WSIs. We first use a pretrained model to semantically annotate images of breast cancer, needing only two lines of codes to do so. After that, we explain how to use a pretrained TIAToolbox model inference pipeline to do prediction on a set of WSIs.
+Use pretrained models to automatically segment different tissue region types in WSIs. _Semantic segmentation_ groups together similar parts of an image that belong to the same class, as in the image immediately above and in the image below. Semantic segmentation of tissue regions plays an important role in developing algorithms for cancer diagnosis and prognosis, as it can help measure tissue attributes in an objective and reproducible fashion.
 
 [![image](../docs/images/sematic-segment.png)](./06-semantic-segmentation.ipynb)
 
-### 7- Advanced model techniques ([07-advanced-modeling](./07-advanced-modeling.ipynb))
+### 7. Advanced Model Techniques ([07-advanced-modeling](./07-advanced-modeling.ipynb))
 
-This notebook is aimed at advanced users of TIAToolbox, familiar with object-oriented programming concepts in Python and the TIAToolbox models framework. We demonstrate the use of TIAToolbox models with your current workflow and how you can integrate your solutions into the TIAToolbox model framework. By doing so, you will be able to utilize extensively tested TIAToolbox tools in your experiments and speed up your computational pathology research.
+This notebook is aimed at advanced users familiar with object-oriented programming concepts in Python and the TIAToolbox models framework. We demonstrate the use of TIAToolbox models with your current workflow and how you can integrate your solutions into the TIAToolbox model framework. By doing so, you will be able to utilize extensively tested TIAToolbox tools in your experiments and speed up your computational pathology research.
 
 [![image](../docs/images/advanced-techniques.png)](./07-advanced-modeling.ipynb)
 
-### 8- Nucleus instance segmentation in whole slide images using the HoVer-Net model ([08-nucleus-instance-segmentation](./08-nucleus-instance-segmentation.ipynb))
+### 8. Nucleus Instance Segmentation in Whole Slide Images Using the HoVer-Net Model ([08-nucleus-instance-segmentation](./08-nucleus-instance-segmentation.ipynb))
 
-Each WSI can contain up to a million nuclei of various types. These can analysed systematically and used for predicting clinical outcomes. Nucleus segmentation and classification must be carried out before using nuclear features in downstream analysis. In this example, we will demonstrate the use of the TIAToolbox implementation of the [HoVer-Net model](https://www.sciencedirect.com/science/article/pii/S1361841519301045) to solve the problem of nucleus instance segmentation and classification.
+Demonstrates the use of the TIAToolbox implementation of the [HoVer-Net model](https://www.sciencedirect.com/science/article/pii/S1361841519301045) for nucleus instance segmentation and classification. Each WSI can contain up to a million nuclei of various types. These can analysed systematically and used for predicting clinical outcomes. Nucleus segmentation and classification must be carried out before using nuclear features in downstream analysis.
 
 [![image](../docs/images/hovernet.png)](./08-nucleus-instance-segmentation.ipynb)
 
-### 9- Multi-task segmentation in whole slide images using the HoVer-Net+ model ([09-multi-task-segmentation](./09-multi-task-segmentation.ipynb))
+### 9. Multi-task Segmentation in Whole Slide Images Using the HoVer-Net+ Model ([09-multi-task-segmentation](./09-multi-task-segmentation.ipynb))
 
-Each WSI consists of a multitude of different tissue types, each containing many nuclei of varying types. In computational pathology, it is often important to generate tissue specific morphological features for downstream analyses. It can therefore be beneficial to perform multiple tasks such as semantic segmentation of tissue regions and nuclear instance segmentation/classification simultaneously in order to exploit useful information learnt from each task to further advance both tasks. If inflammatory cells are more common in connective tissue, and epithelial cells are more common in the epithelium, then it is logical that performing these tasks simultaneously may be beneficial to each task. In this example, we will demonstrate the use of the TIAToolbox implementation of the [HoVer-Net+ model](https://arxiv.org/pdf/2108.13904.pdf) to solve the problem of nucleus instance segmentation/classification and the semantic segmentation of intra-epithelial layers.
+Demonstrates the use of the TIAToolbox implementation of the [HoVer-Net+ model](https://openaccess.thecvf.com/content/ICCV2021W/CDPath/papers/Shephard_Simultaneous_Nuclear_Instance_and_Layer_Segmentation_in_Oral_Epithelial_Dysplasia_ICCVW_2021_paper.pdf) for nucleus instance segmentation/classification and semantic segmentation of intra-epithelial layers. Each WSI consists of a multitude of different tissue types, each containing many nuclei of varying types. In computational pathology, it is often important to generate tissue specific morphological features for downstream analyses. It can therefore be beneficial to perform multiple tasks such as semantic segmentation of tissue regions and nuclear instance segmentation/classification simultaneously in order to exploit useful information learnt from each task to further advance both tasks.
 
 [![image](../docs/images/hovernetplus.png)](./09-multi-task-segmentation.ipynb)
 
-### 10- Image Alignment ([10-wsi_registration](./10-wsi-registration.ipynb))
+### 10. Image Alignment ([10-wsi_registration](./10-wsi-registration.ipynb))
 
-This notebook presents an example to show how to use TIAToolbox for registration of an image pair using [Deep Feature Based Registration](https://arxiv.org/pdf/2202.09971.pdf) (DFBR) [1], followed by non-rigid alignment using [SimpleITK](https://simpleitk.readthedocs.io/en/master/registrationOverview.html). The registration tool in the TIAToolbox also comprises a pre-alignment step, a pre-requisite to DFBR. In particular, we will introduce the use of our registration tool `wsi_registration`.
-
-In this example, the affine transformation is computed using thumbnails of the fixed and moving images. The estimated transformation is then used to extract corresponding tiles from both fixed and moving images at a higher magnification level. The non-rigid deformation between the two tiles is then dealt with using the SimpleITK.
+Shows how to use TIAToolbox for registration of an image pair using [Deep Feature Based Registration (DFBR)](https://arxiv.org/pdf/2202.09971.pdf) followed by non-rigid alignment using [SimpleITK](https://simpleitk.readthedocs.io/en/master/registrationOverview.html). The registration tool in the TIAToolbox also comprises a pre-alignment step, a pre-requisite to DFBR. In this example, the affine transformation is computed using thumbnails of the fixed and moving images. The estimated transformation is then used to extract corresponding tiles from both fixed and moving images at a higher magnification level. The non-rigid deformation between the two tiles is then dealt with using the SimpleITK.
 
 [1] Awan, Ruqayya, et al. "Deep Feature based Cross-slide Registration." arXiv preprint arXiv:2202.09971 (2022).
 
 [![image](../docs/images/wsi-registration.png)](./10-wsi-registration.ipynb)
 
-### 11- Feature Extraction using Foundation Models ([11-import-foundation-models](./11-import-foundation-models.ipynb))
+### 11. Feature Extraction Using Foundation Models ([11-import-foundation-models](./11-import-foundation-models.ipynb))
 
-This Jupyter notebook in TIAToolbox explains how to extract features from whole slide images (WSI) using pre-trained models from the `timm` library. It guides users through selecting appropriate model architectures, visualizing the extracted features using `UMAP` feature embedding, and verifying the model's performance by checking if different tissue types are correctly identified and separated in the feature map.
+Explains how to extract features from WSIs using pre-trained models from the `timm` library. The notebook guides users through selecting appropriate model architectures, visualizing the extracted features using `UMAP` feature embedding, and verifying the model's performance by checking if different tissue types are correctly identified and separated in the feature map.
 
 [![image](../docs/images/feature_extraction.png)](./11-import-foundation-models.ipynb)
 
-## B) Examples of high-level analysis (pipelines) using TIAToolbox
+## B) Examples of High-Level Analysis (Pipelines) Using TIAToolbox
 
-List of Jupyter notebooks that demonstrate how you can use TIAToolbox to simplify high-level analysis in computational pathology.
+List of Jupyter notebooks demonstrating how to use TIAToolbox for high-level analysis in computational pathology.
 
-### 1- Prediction of molecular pathways and key mutations in colorectal cancer from whole slide images ([idars](./inference-pipelines/idars.ipynb))
+### 1. Prediction of Molecular Pathways and Key Mutations in Colorectal Cancer from Whole Slide Images (idars)
 
 Prediction of molecular pathways and key mutations directly from Haematoxylin and Eosin stained histology images can help bypass additional genetic (e.g., polymerase chain reaction or PCR) or immunohistochemistry (IHC) testing, with a view to saving both money and time. In this notebook, we use TIAToolbox's pretrained models to reproduce the inference results obtained by the IDaRS pipeline due to <a href="https://www.thelancet.com/journals/landig/article/PIIS2589-7500(2100180-1/fulltext">Bilal et al</a>. In TIAToolbox, we include models that are capable of predicting the following in whole slide images:
 
@@ -120,11 +118,11 @@ Prediction of molecular pathways and key mutations directly from Haematoxylin an
 
 [![image](../docs/images/idars.png)](./inference-pipelines/idars.ipynb)
 
-### 2- Prediction of HER2 status in breast cancer from H&E stained whole slide images
+### 2. Prediction of HER2 Status in Breast Cancer from H&E Stained Whole Slide Images
 
-This notebook demonstrates how the functionalities available in TIAToolbox can be used to reproduce the ["SlideGraph+ method" ("SlideGraph+: Whole Slide Image-Level Graphs to Predict HER2Status in Breast Cancer" by Lu et al. (2021))](https://arxiv.org/abs/2110.06042) to predict HER2 status of breast cancer samples from H&E stained whole slide images. As a brief overview, this method involves several steps generating a graph that represents a WSI. The graph is then fed into a special convolutional graph network, called SlideGraph, to predict whether that WSI is HER2 negative or positive.
+Demonstrates how to use TIAToolbox to reproduce the ["SlideGraph+ method" ("SlideGraph+: Whole Slide Image-Level Graphs to Predict HER2Status in Breast Cancer" by Lu et al. (2021))](https://arxiv.org/abs/2110.06042) to predict HER2 status of breast cancer samples from H&E stained WSIs. As a brief overview, this method involves several steps generating a graph that represents a WSI. The graph is then fed into a special convolutional graph network, called SlideGraph, to predict whether that WSI is HER2 negative or positive.
 
-- Example notebook on training the SlideGraph model is available here: [slide-graph for training](./full-pipelines/slide-graph.ipynb)
-- Example notebook on using SlideGraph model for WSI inference is available here: [slide-graph for inference](./inference-pipelines/slide-graph.ipynb)
+- Example notebook on training the SlideGraph model: [slide-graph for training](./full-pipelines/slide-graph.ipynb)
+- Example notebook on using SlideGraph model for WSI inference: [slide-graph for inference](./inference-pipelines/slide-graph.ipynb)
 
 [![image](../docs/images/her2-prediction-example.png)](./inference-pipelines/slide-graph.ipynb)