diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..2127be1 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,54 @@ +# Changelog +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). + +## [1.6.1] - 2020-08-20 +### Added +- support mask for matchTemplates and findMatches as in cv2.matchTemplates with method 0 or 3 +- notebook tutorial with mask +- CHANGELOG.MD + +### Changed +- better docstrings + +## [1.6.0.post1] - 2020-08-04 +### Fixed +- issue when no detection found (see Changed of version 1.5.3.post2) + + +## [1.6.0] - 2020-08-03 +### Changed +- NMS is now using the opencv `cv2.dnn.NMSBoxes` function +- use timeit for benchmark in example notebook + +### Removed +- `MTM.NMS.Point_in_Rectangle` and `MTM.NMS.computeIoU` as they are not used anymore for the NMS + +## [1.5.3.post2] - 2020-08-04 +### Fixed +- issue when no detection found (see Changed) + +### Changed +- `MTM.findMatches` return a dataframe with proper column names (not just empty) +- better handle the different opencv matchTemplate methods + +## [1.5.3.post1] - 2020-05-11 +### Removed +- remove the hardcoded version requirement for opencv-python-headless in setup.py + +### Added +- MTM version is now defined in a dedicated version.py file + +## [1.5.3] - 2020-04-28 +### Added +- `MTM.computeScoreMap` which is like `cv2.matchTemplate` but checking for image types + + +## [1.5.2] - 2019-12-19 +### Changed +- `MTM.findMatches` automatically cast 16-bit images and/or template to 32-bit + +## [1.5.1] - 2019-10-10 +### Changed +- use pandas dataframe to return list of hits for `MTM.matchTemplates` and `MTM.findMatches` diff --git a/MTM/NMS.py b/MTM/NMS.py index 2ea0be8..cc478b1 100644 --- a/MTM/NMS.py +++ b/MTM/NMS.py @@ -1,12 +1,14 @@ # -*- coding: utf-8 -*- """ -Non-Maxima Supression (NMS) for match template +Non-Maxima Supression (NMS) for match template. + From a pool of bounding box each predicting possible object locations with a given score, the NMS removes the bounding boxes overlapping with a bounding box of higher score above the maxOverlap threshold This effectively removes redundant detections of the same object and still allow the detection of close objects (ie small possible overlap) The "possible" allowed overlap is set by the variable maxOverlap (between 0 and 1) which is the ratio Intersection over Union (IoU) area for a given pair of overlaping BBoxes +Since version 1.6.0 the NMS is assured by opencv cv2.dnn.NMSBoxes function @author: Laurent Thomas """ @@ -15,33 +17,37 @@ def NMS(tableHit, scoreThreshold=0.5, sortAscending=False, N_object=float("inf"), maxOverlap=0.5): - ''' - Perform Non-Maxima supression : it compares the hits after maxima/minima detection, and removes the ones that are too close (too large overlap) - This function works both with an optionnal threshold on the score, and number of detected bbox - - if a scoreThreshold is specified, we first discard any hit below/above the threshold (depending on sortDescending) - if sortDescending = True, the hit with score below the treshold are discarded (ie when high score means better prediction ex : Correlation) - if sortDescending = False, the hit with score above the threshold are discared (ie when low score means better prediction ex : Distance measure) - - Then the hit are ordered so that we have the best hits first. - Then we iterate over the list of hits, taking one hit at a time and checking for overlap with the previous validated hit (the Final Hit list is directly iniitialised with the first best hit as there is no better hit with which to compare overlap) + """ + Perform Non-Maxima Supression (NMS). - This iteration is terminate once we have collected N best hit, or if there are no more hit left to test for overlap + it compares the hits after maxima/minima detection, and removes detections overlapping above the maxOverlap + Also removes detections that do not satisfy a minimum score - INPUT - - tableHit : (Panda DataFrame) Each row is a hit, with columns "TemplateName"(String),"BBox"(x,y,width,height),"Score"(float) + INPUT + - tableHit : Pandas DataFrame + List of potential detections as returned by MTM.findMatches. + Each row is a hit, with columns "TemplateName"(String),"BBox"(x,y,width,height),"Score"(float). - - scoreThreshold : Float (or None), used to remove hit with too low prediction score. - If sortAscending=False (ie we use a correlation measure so we want to keep large scores) the scores above that threshold are kept - If True (we use a difference measure ie we want to keep low score), the scores below that threshold are kept - - - N_object : maximum number of hit to return. Default=-1, ie return all hit passing NMS - - maxOverlap : float between 0 and 1, the maximal overlap authorised between 2 bounding boxes, above this value, the bounding box of lower score is deleted - - sortAscending : use True when low score means better prediction (Difference-based score), True otherwise (Correlation score) + - scoreThreshold : Float, used to remove low score detections. + If sortAscending=False, ie when best detections have high scores (correlation method), the detections with score below the threshold are discarded. + If sortAscending=True, ie when best detections have low scores (difference method), the detections with score above the threshold are discarded. + + - sortAscending : Boolean + use True when low score means better prediction (Difference-based score), False otherwise (Correlation score). + + - N_object : int or infinity/float("inf") + maximum number of best detections to return, to use when the number of object is known. + Otherwise Default=infinity, ie return all detections passing NMS. + + - maxOverlap : float between 0 and 1 + the maximal overlap (IoU: Intersection over Union of the areas) authorised between 2 bounding boxes. + Above this value, the bounding box of lower score is deleted. + - OUTPUT - Panda DataFrame with best detection after NMS, it contains max N detection (but potentially less) - ''' + Returns + ------- + Panda DataFrame with best detection after NMS, it contains max N detections (but potentially less) + """ listBoxes = tableHit["BBox"].to_list() listScores = tableHit["Score"].to_list() diff --git a/MTM/__init__.py b/MTM/__init__.py index b6cbcf2..adffb32 100644 --- a/MTM/__init__.py +++ b/MTM/__init__.py @@ -1,6 +1,8 @@ +"""Main code for Multi-Template-Matching (MTM).""" import cv2 import numpy as np import pandas as pd +import warnings from skimage.feature import peak_local_max from scipy.signal import find_peaks from .version import __version__ @@ -10,10 +12,7 @@ __all__ = ['NMS'] def _findLocalMax_(corrMap, score_threshold=0.6): - ''' - Get coordinates of the local maximas with values above a threshold in the image of the correlation map - ''' - + """Get coordinates of the local maximas with values above a threshold in the image of the correlation map.""" # IF depending on the shape of the correlation map if corrMap.shape == (1,1): ## Template size = Image size -> Correlation map is a single digit') @@ -42,50 +41,79 @@ def _findLocalMax_(corrMap, score_threshold=0.6): def _findLocalMin_(corrMap, score_threshold=0.4): - '''Find coordinates of local minimas with values below a threshold in the image of the correlation map''' + """Find coordinates of local minimas with values below a threshold in the image of the correlation map.""" return _findLocalMax_(-corrMap, -score_threshold) -def computeScoreMap(template, image, method=cv2.TM_CCOEFF_NORMED): - ''' - Compute score map provided numpy array for template and image. - Automatically converts images if necessary - return score map as numpy as array - ''' +def computeScoreMap(template, image, method=cv2.TM_CCOEFF_NORMED, mask=None): + """ + Compute score map provided numpy array for template and image (automatically converts images if necessary). + A mask can be provided to limit the comparison of the pixel values to a fraction of the template region. + The mask should have the same dimensions and image type than the template. + + Return + ------ + score map as numpy array + """ if template.dtype == "float64" or image.dtype == "float64": - raise ValueError("64-bit not supported, max 32-bit") + raise ValueError("64-bit images not supported, max 32-bit") - # Convert images if not both 8-bit (OpenCV matchTempalte is only defined for 8-bit OR 32-bit) + # Convert images if not both 8-bit (OpenCV matchTemplate is only defined for 8-bit OR 32-bit) if not (template.dtype == "uint8" and image.dtype == "uint8"): template = np.float32(template) image = np.float32(image) + if mask is not None: mask = np.float32(mask) + + if mask is not None: + + if method not in (0,3): + mask = None + warnings.warn("Template matching method not compatible with use of mask (only 0/TM_SQDIFF or 3/TM_CCORR_NORMED).\n-> Ignoring mask.") + + else: # correct method + # Check that mask has the same dimensions and type than template + sameDimension = mask.shape == template.shape + sameType = mask.dtype == template.dtype + if not (sameDimension and sameType): + mask = None + warnings.warn("Mask does not have the same dimension or bit depth than the template.\n-> Ignoring mask.") + # Compute correlation map - return cv2.matchTemplate(template, image, method) + return cv2.matchTemplate(image, template, method, mask=mask) def findMatches(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=float("inf"), score_threshold=0.5, searchBox=None): - ''' - Find all possible templates locations provided a list of template to search and an image + """ + Find all possible templates locations provided a list of templates to search and an image. + Parameters ---------- - - listTemplates : list of tuples (LabelString, Grayscale or RGB numpy array) - templates to search in each image, associated to a label + - listTemplates : list of tuples (LabelString, template, mask (optional)) + templates to search in each image, associated to a label + labelstring : string + template : numpy array (grayscale or RGB) + mask (optional): numpy array, should have the same dimensions and type than the template + - image : Grayscale or RGB numpy array image in which to perform the search, it should be the same bitDepth and number of channels than the templates + - method : int one of OpenCV template matching method (0 to 5), default 5=0-mean cross-correlation - - N_object: int - expected number of objects in the image, -1 if unknown + + - N_object: int or float("inf") + expected number of objects in the image, default to infinity if unknown + - score_threshold: float in range [0,1] - if N>1, returns local minima/maxima respectively below/above the score_threshold + if N_object>1, returns local minima/maxima respectively below/above the score_threshold + - searchBox : tuple (X, Y, Width, Height) in pixel unit optional rectangular search region as a tuple Returns ------- - Pandas DataFrame with 1 row per hit and column "TemplateName"(string), "BBox":(X, Y, Width, Height), "Score":float - ''' + """ if N_object!=float("inf") and type(N_object)!=int: raise TypeError("N_object must be an integer") @@ -95,13 +123,24 @@ def findMatches(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=floa image = image[yOffset:yOffset+searchHeight, xOffset:xOffset+searchWidth] else: xOffset=yOffset=0 - + listHit = [] - for templateName, template in listTemplates: + for tempTuple in listTemplates: - #print('\nSearch with template : ',templateName) + if not isinstance(tempTuple, tuple) or len(tempTuple)==1: + raise ValueError("listTemplates should be a list of tuples as ('name','array') or ('name', 'array', 'mask')") + + templateName, template = tempTuple[:2] + mask = None - corrMap = computeScoreMap(template, image, method) + if len(tempTuple)>=3: + if method in (0,3): + mask = tempTuple[2] + else: + warnings.warn("Template matching method not supporting the use of Mask. Use 0/TM_SQDIFF or 3/TM_CCORR_NORMED.") + + #print('\nSearch with template : ',templateName) + corrMap = computeScoreMap(template, image, method, mask=mask) ## Find possible location of the object if N_object==1: # Detect global Min/Max @@ -144,24 +183,34 @@ def findMatches(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=floa def matchTemplates(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=float("inf"), score_threshold=0.5, maxOverlap=0.25, searchBox=None): - ''' - Search each template in the image, and return the best N_object location which offer the best score and which do not overlap + """ + Search each template in the image, and return the best N_object locations which offer the best score and which do not overlap above the maxOverlap threshold. + Parameters ---------- - - listTemplates : list of tuples (LabelString, Grayscale or RGB numpy array) - templates to search in each image, associated to a label + - listTemplates : list of tuples as (LabelString, template, mask (optional)) + templates to search in each image, associated to a label + labelstring : string + template : numpy array (grayscale or RGB) + mask (optional): numpy array, should have the same dimensions and type than the template + - image : Grayscale or RGB numpy array image in which to perform the search, it should be the same bitDepth and number of channels than the templates + - method : int - one of OpenCV template matching method (1 to 5), default 5=0-mean cross-correlation - method 0 is not supported (no NMS implemented for non-bound difference score), use 1 instead - - N_object: int - expected number of objects in the image + one of OpenCV template matching method (1 to 5), default 5=0-mean cross-correlation + method 0 is not supported (no NMS implemented for non-bound difference score), use 1 instead + + - N_object: int or foat("inf") + expected number of objects in the image, default to infinity if unknown + - score_threshold: float in range [0,1] if N>1, returns local minima/maxima respectively below/above the score_threshold + - maxOverlap: float in range [0,1] This is the maximal value for the ratio of the Intersection Over Union (IoU) area between a pair of bounding boxes. If the ratio is over the maxOverlap, the lower score bounding box is discarded. + - searchBox : tuple (X, Y, Width, Height) in pixel unit optional rectangular search region as a tuple @@ -169,9 +218,9 @@ def matchTemplates(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=f ------- Pandas DataFrame with 1 row per hit and column "TemplateName"(string), "BBox":(X, Y, Width, Height), "Score":float if N=1, return the best matches independently of the score_threshold - if N1: raise ValueError("Maximal overlap between bounding box is in range [0-1]") @@ -185,19 +234,24 @@ def matchTemplates(listTemplates, image, method=cv2.TM_CCOEFF_NORMED, N_object=f def drawBoxesOnRGB(image, tableHit, boxThickness=2, boxColor=(255, 255, 00), showLabel=False, labelColor=(255, 255, 0), labelScale=0.5 ): - ''' + """ Return a copy of the image with predicted template locations as bounding boxes overlaid on the image The name of the template can also be displayed on top of the bounding box with showLabel=True + Parameters ---------- - image : image in which the search was performed + - tableHit: list of hit as returned by matchTemplates or findMatches + - boxThickness: int thickness of bounding box contour in pixels - boxColor: (int, int, int) RGB color for the bounding box + - showLabel: Boolean Display label of the bounding box (field TemplateName) + - labelColor: (int, int, int) RGB color for the label @@ -205,7 +259,7 @@ def drawBoxesOnRGB(image, tableHit, boxThickness=2, boxColor=(255, 255, 00), sho ------- outImage: RGB image original image with predicted template locations depicted as bounding boxes - ''' + """ # Convert Grayscale to RGB to be able to see the color bboxes if image.ndim == 2: outImage = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB) # convert to RGB to be able to show detections as color box on grayscale image else: outImage = image.copy() @@ -219,19 +273,25 @@ def drawBoxesOnRGB(image, tableHit, boxThickness=2, boxColor=(255, 255, 00), sho def drawBoxesOnGray(image, tableHit, boxThickness=2, boxColor=255, showLabel=False, labelColor=255, labelScale=0.5): - ''' + """ Same as drawBoxesOnRGB but with Graylevel. If a RGB image is provided, the output image will be a grayscale image + Parameters ---------- - image : image in which the search was performed + - tableHit: list of hit as returned by matchTemplates or findMatches + - boxThickness: int thickness of bounding box contour in pixels + - boxColor: int Gray level for the bounding box + - showLabel: Boolean Display label of the bounding box (field TemplateName) + - labelColor: int Gray level for the label @@ -239,7 +299,7 @@ def drawBoxesOnGray(image, tableHit, boxThickness=2, boxColor=255, showLabel=Fal ------- outImage: Single channel grayscale image original image with predicted template locations depicted as bounding boxes - ''' + """ # Convert RGB to grayscale if image.ndim == 3: outImage = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) # convert to RGB to be able to show detections as color box on grayscale image else: outImage = image.copy() diff --git a/MTM/version.py b/MTM/version.py index 61f565c..960d363 100644 --- a/MTM/version.py +++ b/MTM/version.py @@ -2,4 +2,4 @@ # 1) we don't load dependencies by storing it in __init__.py # 2) we can import it in setup.py for the same reason # 3) we can import it into your module module -__version__ = '1.6.0.post1' \ No newline at end of file +__version__ = '1.6.1' \ No newline at end of file diff --git a/test.py b/test.py index 714512f..404368d 100644 --- a/test.py +++ b/test.py @@ -1,6 +1,8 @@ -''' +""" +TEST SCRIPT. + Make sure the active directory is the directory of the repo when running the test in a IDE -''' +""" from skimage.data import coins import matplotlib.pyplot as plt import MTM, cv2 diff --git a/tutorials/InteractiveParameters.ipynb b/tutorials/InteractiveParameters.ipynb index 17c5235..655d7de 100644 --- a/tutorials/InteractiveParameters.ipynb +++ b/tutorials/InteractiveParameters.ipynb @@ -10,14 +10,32 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MTM version : 1.15.1\n" + "C:\\Users\\Laurent Thomas\\Documents\\repo-MTM-Python\n" + ] + } + ], + "source": [ + "# If using local source code, set working directory to repo directory\n", + "%cd .." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MTM version : 1.6.1\n" ] } ], @@ -44,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -776,12 +794,9 @@ " // Check for shift+enter\n", " if (event.shiftKey && event.which == 13) {\n", " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", " }\n", "}\n", "\n", @@ -830,7 +845,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -842,10 +857,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 28, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -866,16 +881,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 29, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -895,7 +910,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -1627,12 +1642,9 @@ " // Check for shift+enter\n", " if (event.shiftKey && event.which == 13) {\n", " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", " }\n", "}\n", "\n", @@ -1681,7 +1693,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -1709,7 +1721,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1740,27 +1752,27 @@ " \n", " \n", " \n", - " 0\n", + " 4\n", " 0\n", - " [946, 784, 414, 400]\n", + " (946, 784, 414, 400)\n", " 1.000000\n", " \n", " \n", - " 1\n", + " 100\n", " 180\n", - " [1525, 968, 414, 400]\n", + " (1525, 968, 414, 400)\n", " 0.591937\n", " \n", " \n", - " 2\n", + " 72\n", " 180\n", - " [1173, 1354, 414, 400]\n", + " (1173, 1354, 414, 400)\n", " 0.551068\n", " \n", " \n", - " 3\n", + " 17\n", " 90\n", - " [1459, 474, 400, 414]\n", + " (1459, 474, 400, 414)\n", " 0.538105\n", " \n", " \n", @@ -1768,14 +1780,14 @@ "" ], "text/plain": [ - " TemplateName BBox Score\n", - "0 0 [946, 784, 414, 400] 1.000000\n", - "1 180 [1525, 968, 414, 400] 0.591937\n", - "2 180 [1173, 1354, 414, 400] 0.551068\n", - "3 90 [1459, 474, 400, 414] 0.538105" + " TemplateName BBox Score\n", + "4 0 (946, 784, 414, 400) 1.000000\n", + "100 180 (1525, 968, 414, 400) 0.591937\n", + "72 180 (1173, 1354, 414, 400) 0.551068\n", + "17 90 (1459, 474, 400, 414) 0.538105" ] }, - "execution_count": 31, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -1797,7 +1809,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -2529,12 +2541,9 @@ " // Check for shift+enter\n", " if (event.shiftKey && event.which == 13) {\n", " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", + " // select the cell after this one\n", + " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", + " IPython.notebook.select(index + 1);\n", " }\n", "}\n", "\n", @@ -2583,7 +2592,7 @@ { "data": { "text/html": [ - "" + "" ], "text/plain": [ "" @@ -2595,7 +2604,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "75afa734751f42b1b3fbafa96f0098c1", + "model_id": "8d0f681f7ab74d39bedfd5784c86c2ac", "version_major": 2, "version_minor": 0 }, @@ -2651,7 +2660,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.8.3" } }, "nbformat": 4, diff --git a/tutorials/WithMask.ipynb b/tutorials/WithMask.ipynb new file mode 100644 index 0000000..0634fa1 --- /dev/null +++ b/tutorials/WithMask.ipynb @@ -0,0 +1,721 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## This notebook is currently only compatible with v1.6.1 available via the \"use-mask\" branch" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook demonstrates how to use the `mask` option of cv2.matchTemplate with MTM. \n", + "The mask is used in combination with the template (it has the same dimensions) to __limit the comparison of the pixel values to only some specific region of the template__. This allows to overcome the default square shape of the template. \n", + "\n", + "__N:B__: This option in MTM is __only supported with the method 3/TM_CCORR_NORMED__ (because in opencv it is supported only for method 0/TM_SQ_DIFF and 3, but method 0 is not supported by MTM). \n", + "\n", + "Here it is illustrated with the coin image. Actually the result with mask than without ! \n", + "This is because in this particular case, the background around the coins was also matching well. \n", + "In other cases, the background might not match well and so using the mask can help." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\Laurent Thomas\\Documents\\repo-MTM-Python\n" + ] + } + ], + "source": [ + "# If you use the package locally from the repo root folder (without having installed via pip)\n", + "%cd .." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.6.1\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import cv2, MTM\n", + "print(MTM.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from skimage.data import coins\n", + "image = coins()\n", + "template = image[37:37+38, 80:80+41]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Threshold the template\n", + "The result is not perfect but it does not matter if a few pixels are missing. \n", + "The pixel in dark blue (equal to 0) will not be used for the pixel value comparison, only the yellow area. \n", + "A fillHoles would be great, but it does not exist in OpenCV (dilate+erode instead ?)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# threshold\n", + "theshold, mask = cv2.threshold(template,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)\n", + "plt.imshow(mask)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Usual call without mask" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TemplateNameBBoxScore
139testMask(80, 37, 41, 38)1.000000
95testMask(82, 106, 41, 38)0.977762
140testMask(22, 37, 41, 38)0.977588
91testMask(133, 108, 41, 38)0.977023
50testMask(23, 178, 41, 38)0.973121
10testMask(341, 247, 41, 38)0.972344
143testMask(134, 36, 41, 38)0.972047
98testMask(26, 103, 41, 38)0.971718
147testMask(257, 33, 41, 38)0.971200
148testMask(199, 33, 41, 38)0.970992
72testMask(336, 158, 41, 38)0.969302
49testMask(134, 178, 41, 38)0.967385
11testMask(283, 247, 41, 38)0.965638
18testMask(229, 242, 41, 38)0.965391
97testMask(185, 104, 41, 38)0.965069
94testMask(251, 106, 41, 38)0.962599
96testMask(316, 105, 41, 38)0.960158
26testMask(157, 236, 41, 38)0.959044
34testMask(29, 231, 41, 38)0.958695
202testMask(315, 13, 41, 38)0.958470
12testMask(91, 246, 41, 38)0.957132
44testMask(82, 180, 41, 38)0.953978
64testMask(193, 169, 41, 38)0.951312
47testMask(256, 178, 41, 38)0.942586
41testMask(305, 202, 41, 38)0.805478
\n", + "
" + ], + "text/plain": [ + " TemplateName BBox Score\n", + "139 testMask (80, 37, 41, 38) 1.000000\n", + "95 testMask (82, 106, 41, 38) 0.977762\n", + "140 testMask (22, 37, 41, 38) 0.977588\n", + "91 testMask (133, 108, 41, 38) 0.977023\n", + "50 testMask (23, 178, 41, 38) 0.973121\n", + "10 testMask (341, 247, 41, 38) 0.972344\n", + "143 testMask (134, 36, 41, 38) 0.972047\n", + "98 testMask (26, 103, 41, 38) 0.971718\n", + "147 testMask (257, 33, 41, 38) 0.971200\n", + "148 testMask (199, 33, 41, 38) 0.970992\n", + "72 testMask (336, 158, 41, 38) 0.969302\n", + "49 testMask (134, 178, 41, 38) 0.967385\n", + "11 testMask (283, 247, 41, 38) 0.965638\n", + "18 testMask (229, 242, 41, 38) 0.965391\n", + "97 testMask (185, 104, 41, 38) 0.965069\n", + "94 testMask (251, 106, 41, 38) 0.962599\n", + "96 testMask (316, 105, 41, 38) 0.960158\n", + "26 testMask (157, 236, 41, 38) 0.959044\n", + "34 testMask (29, 231, 41, 38) 0.958695\n", + "202 testMask (315, 13, 41, 38) 0.958470\n", + "12 testMask (91, 246, 41, 38) 0.957132\n", + "44 testMask (82, 180, 41, 38) 0.953978\n", + "64 testMask (193, 169, 41, 38) 0.951312\n", + "47 testMask (256, 178, 41, 38) 0.942586\n", + "41 testMask (305, 202, 41, 38) 0.805478" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "listTemplates = [ (\"testMask\", template) ]\n", + "Hits = MTM.matchTemplates(listTemplates, \n", + " image, \n", + " method=cv2.TM_CCORR_NORMED, \n", + " score_threshold=0.8,\n", + " maxOverlap=0)\n", + "Hits" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Overlay = MTM.drawBoxesOnRGB(image, Hits)\n", + "plt.imshow(Overlay)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test with mask\n", + "The syntax of the call is the same except that the tuple for each template can now have a third element which should be the numpy array for the mask. \n", + "It should have the same dimensions than the template. \n", + "Pixel with values equal to 0 in the mask will not be used for the pixel values comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TemplateNameBBoxScore
223testMask(80, 37, 41, 38)1.000000
194testMask(5, 70, 41, 38)0.993747
277testMask(0, 2, 41, 38)0.993601
138testMask(41, 141, 41, 38)0.992317
241testMask(137, 28, 41, 38)0.991843
285testMask(230, 0, 41, 38)0.991840
197testMask(211, 69, 41, 38)0.991050
136testMask(158, 141, 41, 38)0.990475
148testMask(102, 137, 41, 38)0.989654
119testMask(334, 159, 41, 38)0.989594
207testMask(157, 67, 41, 38)0.988673
15testMask(335, 248, 41, 38)0.988098
46testMask(225, 239, 41, 38)0.988020
144testMask(280, 139, 41, 38)0.987787
282testMask(274, 0, 41, 38)0.987659
155testMask(213, 130, 41, 38)0.987501
88testMask(82, 177, 41, 38)0.987032
21testMask(285, 246, 41, 38)0.986936
79testMask(289, 201, 41, 38)0.984147
25testMask(21, 246, 41, 38)0.983211
28testMask(95, 245, 41, 38)0.981964
48testMask(159, 236, 41, 38)0.981019
213testMask(279, 65, 41, 38)0.980552
291testMask(189, 0, 41, 38)0.979939
262testMask(323, 19, 41, 38)0.979126
201testMask(343, 68, 41, 38)0.972038
75testMask(0, 206, 41, 38)0.957259
176testMask(50, 96, 41, 38)0.915173
100testMask(220, 171, 41, 38)0.809961
\n", + "
" + ], + "text/plain": [ + " TemplateName BBox Score\n", + "223 testMask (80, 37, 41, 38) 1.000000\n", + "194 testMask (5, 70, 41, 38) 0.993747\n", + "277 testMask (0, 2, 41, 38) 0.993601\n", + "138 testMask (41, 141, 41, 38) 0.992317\n", + "241 testMask (137, 28, 41, 38) 0.991843\n", + "285 testMask (230, 0, 41, 38) 0.991840\n", + "197 testMask (211, 69, 41, 38) 0.991050\n", + "136 testMask (158, 141, 41, 38) 0.990475\n", + "148 testMask (102, 137, 41, 38) 0.989654\n", + "119 testMask (334, 159, 41, 38) 0.989594\n", + "207 testMask (157, 67, 41, 38) 0.988673\n", + "15 testMask (335, 248, 41, 38) 0.988098\n", + "46 testMask (225, 239, 41, 38) 0.988020\n", + "144 testMask (280, 139, 41, 38) 0.987787\n", + "282 testMask (274, 0, 41, 38) 0.987659\n", + "155 testMask (213, 130, 41, 38) 0.987501\n", + "88 testMask (82, 177, 41, 38) 0.987032\n", + "21 testMask (285, 246, 41, 38) 0.986936\n", + "79 testMask (289, 201, 41, 38) 0.984147\n", + "25 testMask (21, 246, 41, 38) 0.983211\n", + "28 testMask (95, 245, 41, 38) 0.981964\n", + "48 testMask (159, 236, 41, 38) 0.981019\n", + "213 testMask (279, 65, 41, 38) 0.980552\n", + "291 testMask (189, 0, 41, 38) 0.979939\n", + "262 testMask (323, 19, 41, 38) 0.979126\n", + "201 testMask (343, 68, 41, 38) 0.972038\n", + "75 testMask (0, 206, 41, 38) 0.957259\n", + "176 testMask (50, 96, 41, 38) 0.915173\n", + "100 testMask (220, 171, 41, 38) 0.809961" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "listTemplates = [ (\"testMask\", template, mask) ]\n", + "Hits = MTM.matchTemplates(listTemplates, \n", + " image, \n", + " method=cv2.TM_CCORR_NORMED, \n", + " score_threshold=0.8, \n", + " maxOverlap=0)\n", + "Hits" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "Overlay = MTM.drawBoxesOnRGB(image, Hits)\n", + "plt.imshow(Overlay)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you can see, using a mask is not always beneficial, as the background surrounding the object can help increasing the matching score." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}