puzzle.utils.sideExtractor Namespace Reference

Functions
def	cluster_lines (lines)
def	compute_barycentre (thresh, value=0)
def	compute_inout (class_image, line_params, pts, d_threshold=10)
def	compute_intersections (mean_lines, size)
def	compute_line_params (corners)
def	compute_mean_line (lines, debug=False)
def	compute_minmax_xy (thresh)
def	corner_detection (edges, intersections, pts, rect_size=50, show=False)
def	create_side_images (class_image, inout, corners)
def	create_side_images_simple (class_image, inout, corners)
def	distance_point_line_signed (line_param, pts)
def	distance_point_line_squared (line_param, pts)
def	draw_lines (image, lines, color)
def	get_best_fitting_rect_coords (xy, d_threshold=30, perp_angle_thresh=20, verbose=0)
def	get_binarymask_params ()
def	get_corners (dst, neighborhood_size=5, score_factor=0.2, minmax_factor=0.2)
def	get_default_params ()
def	get_line_through_points (p0, p1)
def	line_intersection (line1, line2)
def	order_corners (corners)
def	plot_side_images (side_images, inout)
def	prune_lines_by_voting (lines, angle_threshold=5)
def	rotate (image, degrees)
def	shape_classification (edges, line_params, d_threshold=500, n_hs=10)
def	sideExtractor (puzzleTemplate, **kwargs)
	Unsure what does. More...

Function Documentation

cluster_lines()

def puzzle.utils.sideExtractor.cluster_lines

(

lines

)

compute_barycentre()

def puzzle.utils.sideExtractor.compute_barycentre	(		thresh,
			value = 0
	)

Given the segmented puzzle piece, compute its barycentre.

compute_inout()

def puzzle.utils.sideExtractor.compute_inout	(		class_image,
			line_params,
			pts,
			d_threshold = 10
	)

Given the full class image, the line parameters and the coordinates of the barycenter,
compute for each side if the curve of the piece goes inside (in) or outside (out).
This is done by computing the mean coordinates for each class and see if the signed distance
from the corners' line has the same sign of the signed distance of the barycenter. If that
true, the two points lie on the same side and we have a in; otherwise we have a out.
To let the points of the curve to contribute more to the mean point calculation, only the
signed distances that are greater than a threshold are used.

compute_intersections()

def puzzle.utils.sideExtractor.compute_intersections	(		mean_lines,
			size
	)

compute_line_params()

def puzzle.utils.sideExtractor.compute_line_params

(

corners

)

compute_mean_line()

def puzzle.utils.sideExtractor.compute_mean_line	(		lines,
			debug = False
	)

compute_minmax_xy()

def puzzle.utils.sideExtractor.compute_minmax_xy

(

thresh

)

Given the thresholded image, compute the minimum and maximum x and y
coordinates of the segmented puzzle piece.

corner_detection()

def puzzle.utils.sideExtractor.corner_detection	(		edges,
			intersections,
			pts,
			rect_size = 50,
			show = False
	)

create_side_images()

def puzzle.utils.sideExtractor.create_side_images	(		class_image,
			inout,
			corners
	)

create_side_images_simple()

def puzzle.utils.sideExtractor.create_side_images_simple	(		class_image,
			inout,
			corners
	)

distance_point_line_signed()

def puzzle.utils.sideExtractor.distance_point_line_signed	(		line_param,
			pts
	)

Computes the signed distance of a 2D point (x0, y0) from a line ax + by + c = 0

distance_point_line_squared()

def puzzle.utils.sideExtractor.distance_point_line_squared	(		line_param,
			pts
	)

Computes the squared distance of a 2D point (x0, y0) from a line ax + by + c = 0

draw_lines()

def puzzle.utils.sideExtractor.draw_lines	(		image,
			lines,
			color
	)

get_best_fitting_rect_coords()

def puzzle.utils.sideExtractor.get_best_fitting_rect_coords	(		xy,
			d_threshold = 30,
			perp_angle_thresh = 20,
			verbose = 0
	)

Since we expect the 4 puzzle corners to be the corners of a rectangle, here we take
all detected Harris corners and we find the best corresponding rectangle.
We perform a recursive search with max depth = 2:
- At depth 0 we take one of the input point as the first corner of the rectangle
- At depth 1 we select another input point (with distance from the first point greater
than d_threshold) as the second point
- At depth 2 and 3 we take the other points. However, the lines 01-12 and 12-23 should be
as perpendicular as possible. If the angle formed by these lines is too much far from the
right angle, we discard the choice.
- At depth 3, if a valid candidate (4 points that form an almost perpendicular rectangle) is found,
we add it to the list of candidates.

Given a list of candidate rectangles, we then select the best one by taking the candidate that maximizes
the function: area * Gaussian(rectangularness)
- area: it is the area of the candidate shape. We expect that the puzzle corners will form the maximum area
- rectangularness: it is the mse of the candidate shape's angles compared to a 90 degree angles. The smaller
        this value, the most the shape is similar toa rectangle.

get_binarymask_params()

def puzzle.utils.sideExtractor.get_binarymask_params

(

)

get_corners()

def puzzle.utils.sideExtractor.get_corners	(		dst,
			neighborhood_size = 5,
			score_factor = 0.2,
			minmax_factor = 0.2
	)

@brief  Given the input Harris image (where in each pixel the Harris function is
        computed), extract discrete corners satisfying detection constraints.

@param[in]  dst
@param[in]  neighborhood_size
@param[in]  score_threshold
@param[in]  minmax_threshold

@param[out] xy ??

get_default_params()

def puzzle.utils.sideExtractor.get_default_params

(

)

get_line_through_points()

def puzzle.utils.sideExtractor.get_line_through_points	(		p0,
			p1
	)

Given two points p0 (x0, y0) and p1 (x1, y1),
compute the coefficients (a, b, c) of the line
that passes through both points.

line_intersection()

def puzzle.utils.sideExtractor.line_intersection	(		line1,
			line2
	)

order_corners()

def puzzle.utils.sideExtractor.order_corners

(

corners

)

plot_side_images()

def puzzle.utils.sideExtractor.plot_side_images	(		side_images,
			inout
	)

prune_lines_by_voting()

def puzzle.utils.sideExtractor.prune_lines_by_voting	(		lines,
			angle_threshold = 5
	)

rotate()

def puzzle.utils.sideExtractor.rotate	(		image,
			degrees
	)

Rotate an image by the amount specified in degrees

shape_classification()

def puzzle.utils.sideExtractor.shape_classification	(		edges,
			line_params,
			d_threshold = 500,
			n_hs = 10
	)

sideExtractor()

def puzzle.utils.sideExtractor.sideExtractor	(		puzzleTemplate,
		**	kwargs
	)

Unsure what does.

No documentation. PAV - 2023/11/13.

Parameters

[in]	puzzleTemplate	Puzzle piece template instance.
[in]	OTHERS.	WHO KNOWS.