Drawing Gradient Directions

edit

I have created some code to visually display the average gradient direction in a cell/kernel. My questions are:

• Is my method of calculating the average gradient direction correct? I am aware of a different method (see *) but unsure which is better/more accurate.
• Is my normalisation of a degrees value to a hue value correct? Ie, normalising a value that can be 0-359 to a value between 0-179 by simply dividing by 2?
• Most importantly am I accurately calculating and representing the average gradient direction over a series of cells?

*Alt method to calculate the average gradient direction:

hMean = cv2.mean(sobelX)
vMean = cv2.mean(sobelY)
avg_dir = math.atan2(-vMean[0], hMean[0])

Draw gradient directions:

import cv2
import math
import numpy as np

np.set_printoptions(precision=3, threshold=np.inf, linewidth=np.inf, suppress=True)

def get_roi(src, pt1, pt2):

    col1, col2 = (pt1[0], pt2[0]) if pt1[0] < pt2[0] else (pt2[0], pt1[0])
    row1, row2 = (pt1[1], pt2[1]) if pt1[1] < pt2[1] else (pt2[1], pt1[1])
    return src[row1:row2, col1:col2]

def get_gradient_direction_line(avg_dir, cellUpperLeft, cellW, cellH, scale=0.8):

    halfScale = scale/2;
    centrePt = (int(cellUpperLeft[0] + (cellW/2)), int(cellUpperLeft[1] + (cellH/2)))
    strtPt = (int(centrePt[0] - (cellW * halfScale * math.cos(avg_dir))), int(centrePt[1] - (cellH * halfScale * math.sin(avg_dir))))
    endPt = (int(centrePt[0] + (cellW * halfScale * math.cos(avg_dir))), int(centrePt[1] + (cellH * halfScale * math.sin(avg_dir))))
    return [strtPt, endPt]

def get_gradient_directions_arrows(direction, kernel_w=3, kernel_h=3):

    arrows = np.zeros(direction.shape, dtype=np.uint8)
    n_cols = int(direction.shape[1] / kernel_w)
    n_rows = int(direction.shape[0] / kernel_h)

    for c in range(n_cols):
        # Draw grid lines
        cv2.line(arrows, (c*kernel_w, 0), (c*kernel_w, direction.shape[0]), (255,255,255), 1)
        cv2.line(arrows, (0, c*kernel_h), (direction.shape[1], c*kernel_h), (255,255,255), 1)

        for r in range(n_rows):
            roiUpperleft = (c*kernel_w, r*kernel_h)
            roi = get_roi(direction, roiUpperleft, ((c+1)*kernel_w, (r+1)*kernel_h))
            avg_dir = cv2.mean(roi)[0]
            arrow_pnts = get_gradient_direction_line(avg_dir, roiUpperleft, kernel_w, kernel_h)
            cv2.arrowedLine(arrows, arrow_pnts[0], arrow_pnts[1], (255,255,255), 1)

    return arrows

def get_gradient_directions_colours(direction, kernel_w=3, kernel_h=3):
    # (red=0°; yellow=60°, green=120°, blue=240°...)

    hsv = np.zeros((direction.shape[0], direction.shape[1], 3), dtype=np.uint8)
    hsv = cv2.cvtColor(hsv, cv2.COLOR_BGR2HSV)
    n_cols = int(direction.shape[1] / kernel_w)
    n_rows = int(direction.shape[0] / kernel_h)

    for c in range(n_cols):
        # Draw grid lines
        cv2.line(hsv, (c*kernel_w, 0), (c*kernel_w, direction.shape[0]), (180,255,255), 1)
        cv2.line(hsv, (0, c*kernel_h), (direction.shape[1], c*kernel_h), (180,255,255), 1)

        for r in range(n_rows):
            roiUpperleft = (c*kernel_w, r*kernel_h)
            roi = get_roi(direction, roiUpperleft, ((c+1)*kernel_w, (r+1)*kernel_h))
            avg_dir = cv2.mean(roi)[0]
            # avg_dir will be value between 0-359. HSV hue needs a value between 0-179
            avg_dir /= 2
            arrow_pnts = get_gradient_direction_line(avg_dir, roiUpperleft, kernel_w, kernel_h)
            cv2.rectangle(hsv, roiUpperleft, ((c+1)*kernel_w, (r+1)*kernel_h), (avg_dir, 255,255), -1)

    bgr = cv2.cvtColor(hsv, cv2 ...