Puzzle type that is a set of adjacent, rectangular puzzle pieces that get put together in a matrix/2D array shape. All rows/columns have same number of pieces. More...

Inheritance diagram for Matrix:

[legend]

Collaboration diagram for Matrix:

[legend]

Public Member Functions
def	__init__ (self, theBoard=[], theParams=CfgMatrix)
	Constructor for the puzzle.builder.adjacent class. More...

def	buildFrom_ImageAndRegions (theImage, theRegions, theParams=CfgMatrix())

def	coord2ind (self, theCoords)
	Uses puzzle shape to convert puzzle piece coordinate to linear index/key. More...

def	explodedPuzzle (self, dx=100, dy=50, bgColor=(0, 0, 0))
	Create an exploded version of the puzzle. More...

def	getCoordinates (self)
	Obtain solution board coordinates for the pieces. More...

def	retile (self, dx=150, dy=150, inOrder=True)
	Organize puzzle pieces according to gridding. More...

def	shuffle (self, numPieces=None, reorient=False)
	Randomly shuffle location of puzzle pieces of the puzzle. More...

def	sub2ind (self, theSubs)
	Uses puzzle shape to convert puzzle piece subscripts to linear index/key. More...

def	swap (self, theswap=None, reorient=False)
	Randomly shuffle location of puzzle pieces of the puzzle. More...

def	swapByCoords (self, swapCoords)
	Specify puzzle piece coordinates that should be swapped. More...

Public Member Functions inherited from Adjacent
def	processAdjacency (self)
	Process the solution board and determine what pieces are adjacent or "close enough." It will determine the adjacency matrix. More...

Public Member Functions inherited from Arrangement
def	corrections (self, pLoc)
	Given an array of locations that correspond to the puzzle board (e.g., in the same order as puzzle board list), provide the correction vector that would move them to the calibrated locations. More...

def	distances (self, pLoc)
	Given an array of locations that correspond to the puzzle board (e.g., in same order as puzzle board list), provide the distances between the locations and the calibrated locations. More...

def	piecesInPlace (self, pLoc, tauDist=None)
	Return boolean array indicating whether the piece is correctly in place or not. More...

def	scoreBoard (self, theBoard)
	Given a puzzle board with in ordered correspondence with the calibrated puzzle board, in the same order as puzzle board list), provide a score for the distance between the puzzle piece locations and the calibrated locations. More...

def	scoreByLocation (self, pLoc)
	Given an array of locations that correspond to the puzzle board (e.g., in same order as puzzle board list), provide a score for the distance between the locations and the calibrated locations. More...

Public Member Functions inherited from Board
def	__init__ (self, *argv)
	Constructor for puzzle board. More...

def	addPiece (self, piece, ORIGINAL_ID=False)
	Add puzzle piece instance to the board. More...

def	addPieceFromImageAndMask (self, theImage, theMask, cLoc=None)
	Given a mask and an image of same base dimensions, use to instantiate a puzzle piece template. More...

def	addPieces (self, pieces)
	Add puzzle piece to board. More...

def	boundingBox (self)
	Iterate through pieces to get tight bounding box. More...

def	clear (self)

def	display_cv (self, theImage=None, fh=None, ID_DISPLAY=False, CONTOUR_DISPLAY=False, BOUNDING_BOX=False, window_name='Puzzle')
	Display the puzzle board as an image using matplot library. More...

def	display_mp (self, theImage=None, ax=None, fh=None, ID_DISPLAY=False, CONTOUR_DISPLAY=False, BOUNDING_BOX=False)
	Display the puzzle board as an image using matplot library. More...

def	extents (self)
	Iterate through puzzle pieces to get tight bounding box extents of the board. More...

def	fromImageAndLabels (self, theImage, theLabels)

Template	getPiece (self, id)
	Get puzzle piece instance based on id. More...

def	markMissing (self, indSetMeasured)
	Given set of indices to measured pieces, mark remaining as unmeasured. More...

def	offset (self, dr)
	Offset the location of the entire puzzle in the board. More...

def	pieceLocations (self, isCenter=False)
	Returns list/array of puzzle piece locations. More...

def	relabel (self, newLabels, idContinue)
	Relabel the puzzle piece IDs in the board using new label reassignments and adjust IDs for those without reassignment. More...

def	rmPiece (self, id)

def	size (self)
	Number of pieces on the board. More...

def	testAdjacent (self, id_A, id_B, tauAdj)
	Check if two puzzle pieces are adjacent or not. More...

def	toImage (self, theImage=None, ID_DISPLAY=False, COLOR=(0, 0, 0), ID_COLOR=(255, 255, 255), CONTOUR_DISPLAY=True, BOUNDING_BOX=True)
	Uses puzzle piece locations to create an image for visualizing them. More...

Static Public Member Functions
def	buildFrom_ImageAndMask (theImage, theMask, theParams=CfgMatrix(), show_grid=False)
	Given an image and an image mask, parse both to recover the puzzle calibration/solution. More...

def	buildFrom_ImageAndSpecs (theImage, theParams)
	Given a fully specific Matrix puzzle and an image, instantiate a Matrix puzzle. More...

def	buildFrom_ImageProcessing (theImage, theProcessor=None, theDetector=None, theParams=None)

def	buildFrom_Sketch (theImage, theMask, theProcessor=None, theDetector=None, theParams=None)

def	buildFromFile_ImageAndMask (fileName, theParams=None)
	Load a saved arrangement calibration/solution stored as an image and a mask. More...

def	buildFromFile_Puzzle (fileName, theParams=None)
	Load a saved arrangement calibration/solution puzzle board. More...

def	buildFromFiles_ImageAndMask (imFile, maskFile, theParams=None)
	Load a saved arrangement calibration/solution stored as separate image and mask files. More...

Static Public Member Functions inherited from Adjacent
def	buildFrom_ImageAndMask (theImage, theMask, theParams=None)
	Given an image and an image mask, process both to recover and instantiate a puzzle calibration/solution. More...

Public Attributes
	gc

	shape

	xcoords

	ycoords

Public Attributes inherited from Adjacent
	adjMat

Public Attributes inherited from Arrangement
	params

Public Attributes inherited from Board
	id_count

	pieces

Detailed Description

Puzzle type that is a set of adjacent, rectangular puzzle pieces that get put together in a matrix/2D array shape. All rows/columns have same number of pieces.

This class is an organized version of the Adjacent class. Since the adjacent pieces lie on a regular grid, we can establish a relative ordering. If needed, it can be used for evaluating or interpreting a puzzle board and its correctness.

It also includes a scoring mechanism to indicate how "close" a current solution would be to the calibrated solution.

Constructor & Destructor Documentation

◆ init()

def __init__	(	self,
		theBoard = `[]`,
		theParams = `CfgMatrix`
	)

Constructor for the puzzle.builder.adjacent class.

Parameters

[in]	theBoard	Input board instance.
[in]	theParams	Matrix puzzle configuration instance.

Reimplemented from Adjacent.

Member Function Documentation

◆ buildFrom_ImageAndMask()

def buildFrom_ImageAndMask	(	theImage,
		theMask,
		theParams = `CfgMatrix()`,
		show_grid = `False`
	)

static

Given an image and an image mask, parse both to recover the puzzle calibration/solution.

Todo:: NOT UPDATED!!!!

Instantiates a puzzle parser that gets applied to the submitted data to create a puzzle board instance. That instance is the calibration/solution.

Parameters

[in]	theImage	Puzzle image data.
[in]	theMask	Puzzle mask data.
[in]	theParams	Matrix configuration instance.

Returns: thePuzzle Matrix puzzle board instance.

◆ buildFrom_ImageAndRegions()

def buildFrom_ImageAndRegions	(	theImage,
		theRegions,
		theParams = `CfgMatrix()`
	)

◆ buildFrom_ImageAndSpecs()

def buildFrom_ImageAndSpecs	(	theImage,
		theParams
	)

static

Given a fully specific Matrix puzzle and an image, instantiate a Matrix puzzle.

The image and the puzzle specification need not agree. The image will be reshaped to the nearest possible size compatible with the Matrix specifications. It may be that the puzzle sizing has to change to match that aspect ratio of the original image, or the image has to be cropped. This routine tries to minimize how much the specifications are adjusted to make a puzzle from the source image.

What is important about the puzzle specification is that the number of columns and rows (width and height) of the puzzle matrix should be given. The target image size should be given too. If not, then the source image will be used for the initial target image size, which may be adjusted or cropped for compatiblity with the puzzle sizing.

Parameters

[in]	theImage	The source image.
[in]	theParams	The Matrix puzzle configuration (should be complete).

Returns: thePuzzle A Matrix puzzle board instance.; theImage The modified source image.

◆ buildFrom_ImageProcessing()

def buildFrom_ImageProcessing	(	theImage,
		theProcessor = `None`,
		theDetector = `None`,
		theParams = `None`
	)

static

@todo   NOT UPDATED!!!!

@brief  Given an image with regions clearly separated by some color or threshold,
    parse it to recover the puzzle calibration/solution. Can source alternative
    detector.

Instantiates a puzzle parser that gets applied to the submitted data to create a
puzzle board instance. That instance is the calibration/solution.

@param[in]  theImage: The puzzle image data.
@param[in]  theProcessor: The processing scheme.
@param[in]  theDetector: The detector scheme.
@param[in]  theParams   Matrix configuration instance.

@return   thePuzzle   Matrix puzzle board instance.

Reimplemented from Adjacent.

◆ buildFrom_Sketch()

def buildFrom_Sketch	(	theImage,
		theMask,
		theProcessor = `None`,
		theDetector = `None`,
		theParams = `None`
	)

static

@todo   NOT UPDATED!!!!

@brief  Given an image with regions clearly separated by some color or threshold,
    parse it to recover the puzzle calibration/solution. Can source alternative
    detector.

Instantiates a puzzle parser that gets applied to the submitted data to create a
puzzle board instance. That instance is the calibration/solution.

@param[in]  theImage:       Puzzle image data.
@param[in]  theMask:        Puzzle mask data.
@param[in]  theProcessor    Processing scheme.
@param[in]  theDetector     Detector scheme.
@param[in]  theParams       Matrix configuration instance.

@return     thePuzzle   Matrix puzzle board instance.

Reimplemented from Adjacent.

◆ buildFromFile_ImageAndMask()

def buildFromFile_ImageAndMask	(	fileName,
		theParams = `None`
	)

static

Load a saved arrangement calibration/solution stored as an image and a mask.

Todo:: NOT UPDATED!!!!

The python file contains the puzzle board mask and image source data. It gets processed into an arrangement instance. If a threshold variable tauDist is found, then it is applied to the arrangement instance.

Parameters

[in]	fileName	Python file to load.
[in]	theParams	Matrix configuration instance.

Returns: thePuzzle Matrix puzzle board instance.

Reimplemented from Adjacent.

◆ buildFromFile_Puzzle()

def buildFromFile_Puzzle	(	fileName,
		theParams = `None`
	)

static

Load a saved arrangement calibration/solution puzzle board.

Todo:: NOT UPDATED!!!!

Parameters

[in]	fileName	Python file to load.
[in]	theParams	Matrix configuration instance.

Returns: thePuzzle Matrix puzzle board instance.

Reimplemented from Adjacent.

◆ buildFromFiles_ImageAndMask()

def buildFromFiles_ImageAndMask	(	imFile,
		maskFile,
		theParams = `None`
	)

static

Load a saved arrangement calibration/solution stored as separate image and mask files.

Todo:: NOT UPDATED!!!!

The source file contain the puzzle board image and mask data. It gets processed into an arrangement instance. If a threshold variable tauDist is found, then it is applied to the arrangement instance.

Parameters

[in]	imFile	Image file to load.
[in]	maskFile	Mask file to load.
[in]	theParams	Matrix configuration instance.

Returns: thePuzzle Matrix puzzle board instance.

Reimplemented from Adjacent.

◆ coord2ind()

def coord2ind	(	self,
		theCoords
	)

Uses puzzle shape to convert puzzle piece coordinate to linear index/key.

Assumes that pieces are ordered according to their matrix placement. Normally gc would permit some kind of re-indexing/re-keying, but it doesn't seem to be implemented. Chugging through for now.

Parameters

[in] theCoords Given in (x,y) coordinates.

Todo:: Make sure not impacted by other operations. Right now depends on outer scope to figure that out or to not disturb piece ordering.

◆ explodedPuzzle()

def explodedPuzzle	(	self,
		dx = `100`,
		dy = `50`,
		bgColor = `(0, 0, 0)`
	)

Create an exploded version of the puzzle.

It is an image with no touching pieces.

The value for an exploded puzzle image is that it can be used to generate a simulated puzzle scenario that can be passed to a puzzle solver. It can also be used to define a quasi-puzzle problem, where the objective is to place the pieces in grid ordering like the exploded view (without needing to interlock). Doing see keeps puzzle piece well separated for simple puzzle interpretation algorithms to rapidly parse.

Currently, it is just explode but without changing the order. Otherwise, gc has to be updated too. Both the exploded puzzle image & the exploded puzzle board.

Parameters

[in]	dx	Horizontal offset when exploding.
[in]	dy	Vertical offset when exploding.
[in]	bgColor	Background color to use in new regions.
[out]	epImage	Image of exploded puzzle.
[out]	epBoard	Board instance with exploded puzzle pieces.

◆ getCoordinates()

def getCoordinates ( self )

Obtain solution board coordinates for the pieces.

Parameters

[out] gc Grid coordinates assigned to each pieces, (2, N_pieces).

◆ retile()

def retile	(	self,
		dx = `150`,
		dy = `150`,
		inOrder = `True`
	)

Organize puzzle pieces according to gridding.

Takes the puzzle pieces as ordered in the list and attaches them to a gridding respecting the puzzle shape. If there are not enough puzzle pieces, then it will stop at last one. If there are too many, then these will be dumped below the gridding with extra vertical offset.

Parameters

[in]	dx	Horizontal step increment of grid.
[in]	dy	Vertical step increment of grid.
[in]	inOrder	Sort by puzzle piece ID.

◆ shuffle()

def shuffle	(	self,
		numPieces = `None`,
		reorient = `False`
	)

Randomly shuffle location of puzzle pieces of the puzzle.

Basically takes random mapping of puzzle pieces to each other, then swaps locations and IDs. That should shuffle everything up.

@todo The numPieces argument does nothing as of now. Should address.

@todo Rotation should just be 90 degree increments (0,90,180,270).

Parameters

[in]	numPieces	Number of pieces to shuffle (default: None = All pieces).
[in]	reorient	Also apply random rotation (default: False).
[out]	idMap	The ground truth shuffling as a dict [oldId -> newId]

◆ sub2ind()

def sub2ind	(	self,
		theSubs
	)

Uses puzzle shape to convert puzzle piece subscripts to linear index/key.

Assumes that pieces are ordered according to their matrix placement. Normally gc would permit some kind of re-indexing/re-keying, but it doesn't seem to be implemented. Chugging through for now.

Parameters

[in] theSubs Given in (i,j) subscripting coordinates.

Todo:: Make sure not impacted by other operations. Right now depends on outer scope to figure that out or to not disturb piece ordering.

◆ swap()

def swap	(	self,
		theswap = `None`,
		reorient = `False`
	)

Randomly shuffle location of puzzle pieces of the puzzle.

Basically takes random mapping of puzzle pieces to each other, then swaps locations and IDs. That should shuffle everything up.

@todo The numPieces argument does nothing as of now. Should address.

@todo Rotation should just be 90 degree increments (0,90,180,270).

Parameters

[in]	theswap	Array of swaps (row-wise) as from to (col-wise). None = no swap.
[in]	reorient	Also apply random (0,90,180,270) rotation (default: False).
[out]	idMap	The ground truth swap as a dict [oldId -> newId]

◆ swapByCoords()

def swapByCoords	(	self,
		swapCoords
	)

Specify puzzle piece coordinates that should be swapped.

Given a list of coordinate pairs, apply the swap. Each list entry consists of a tuple of swap coordinates. Invalid coordinates with result in no swap.

Parameters

[in]	swapCoords	List of swap tuples.
[out]	idMap	The ground truth swap as a dict [oldId -> newId]

Member Data Documentation

◆ gc

gc

◆ shape

shape

◆ xcoords

xcoords

◆ ycoords

ycoords

The documentation for this class was generated from the following file:

/home/pvela/python/puzzle_solver/puzzle/builder/matrix.py

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ buildFrom_ImageAndMask()

◆ buildFrom_ImageAndRegions()

◆ buildFrom_ImageAndSpecs()

◆ buildFrom_ImageProcessing()

◆ buildFrom_Sketch()

◆ buildFromFile_ImageAndMask()

◆ buildFromFile_Puzzle()

◆ buildFromFiles_ImageAndMask()

◆ coord2ind()

◆ explodedPuzzle()

◆ getCoordinates()

◆ retile()

◆ shuffle()

@todo The numPieces argument does nothing as of now. Should address.

@todo Rotation should just be 90 degree increments (0,90,180,270).

◆ sub2ind()

◆ swap()

@todo The numPieces argument does nothing as of now. Should address.

@todo Rotation should just be 90 degree increments (0,90,180,270).

◆ swapByCoords()

Member Data Documentation

◆ gc

◆ shape

◆ xcoords

◆ ycoords

◆ init()