Winning GuessTheCorrelation.com machine assisted

This method is not suggested as it takes the fun out of guessing in the game.  However it was fun for me to write the R program to guide when you are in the verge of losing :-)

Here is the algorithm:

1. Save the snapshot of image into a PNG file
2. Read the file using R library as a matrix
3. Convert the image to grayscale
4. Flip the image Horizontally
5. Convert into a binary image with threshold 0.99999.
6. Apply thinning algorithm to the matrix
7. Apply R's cor function to get the correlation from the matrix
8. Print it
9. Use it :-)

Here is the program:

	gtcImgRGB <- readPNG("GuessCorrelation/test-1.png")
	#dim(gtcImgRGB)
	gtcImgGray <- RGB2GRAY(gtcImgRGB)
	gtcImgGray1stQuadHorizFlipped <- apply(gtcImgGray, 1, rev)
	gtcBinaryImg <- gtcImgGray1stQuadHorizFlipped <= 0.99999
	#pimage(gtcBinaryImg)
	gtcThinnedImg <- thinImage(gtcBinaryImg)
	#pimage(gtcThinnedImg)
	getCorrCoeff(gtcThinnedImg, 1)

view raw guessCorrelationCoefficientFromImage.R hosted with ❤ by GitHub

Note: I spent 3 hours and learnt some amount of R just for this stint.  So the program might not be efficient.


Here are the custom functions:

	setwd("c:/workspace/R/")
	library(png)
	library(seriation)
	absDiff <- function(matrix1,matrix2)
	{
	r <- nrow(matrix1)
	c <- ncol(matrix1)
	destMatrix <- matrix1
	for(r in 0:r-1)
	{
	for(c in 0:c-1)
	{
	destMatrix[r,c] <- abs(matrix1[r,c]-matrix1[r,c])
	}
	}
	return(destMatrix)
	}
	countNonZero <- function(inputMatrix)
	{
	return(length(inputMatrix[inputMatrix > 0]))
	}
	thinningIteration <- function(imageMatrix, iter)
	{
	imageInput <- imageMatrix
	r <- nrow(imageInput) - 1
	c <- ncol(imageInput) - 1
	for(i in 2:r)
	{
	for(j in 2:c)
	{
	p2 <- imageInput[i-1, j]
	p3 <- imageInput[i-1, j+1]
	p4 <- imageInput[i, j+1]
	p5 <- imageInput[i+1, j+1]
	p6 <- imageInput[i+1, j]
	p7 <- imageInput[i+1, j-1]
	p8 <- imageInput[i, j-1]
	p9 <- imageInput[i-1, j-1]
	A <- (p2 == 0 && p3 == 1) + (p3 == 0 && p4 == 1) +
	(p4 == 0 && p5 == 1) + (p5 == 0 && p6 == 1) +
	(p6 == 0 && p7 == 1) + (p7 == 0 && p8 == 1) +
	(p8 == 0 && p9 == 1) + (p9 == 0 && p2 == 1)
	B <- p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9
	if(iter == 0){
	m1 <- (p2 * p4 * p6)
	m2 <- (p4 * p6 * p8)
	}
	else {
	m1 <- (p2 * p4 * p8)
	m2 <- (p2 * p6 * p8)
	}
	if (A == 1 && (B >= 2 && B <= 6) && m1 == 0 && m2 == 0)
	{
	imageInput[i,j] <- 0
	}
	}
	}
	return(imageInput)
	}
	thinImage <- function(imageMatrix)
	{
	im <- imageMatrix
	prev <- im
	repeat {
	im <- thinningIteration(im, 0)
	im <- thinningIteration(im, 1)
	diff <- absDiff(im, prev)
	prev <- im
	if(countNonZero(diff) <= 0)
	{
	break
	}
	}
	return(im)
	}
	getCorrCoeff <- function(binaryImage, plotPresentValue) {
	height <- dim(binaryImage)[1]
	width <- dim(binaryImage)[2]
	arrayLength <- max(height, width) * 100
	x<-numeric(arrayLength)
	y<-numeric(arrayLength)
	plotItemsFoundCount = 0
	for(row in 1:height) {
	if(plotItemsFoundCount >= arrayLength) {
	print("Got a problem ran into max value with a 100 multiplier")
	break;
	}
	for(col in 1:width) {
	if(binaryImage[row,col] == plotPresentValue) {
	plotItemsFoundCount <- plotItemsFoundCount + 1
	if(plotItemsFoundCount >= arrayLength) {
	print("Got a problem ran into max value with a 10 multiplier")
	break;
	}
	x[plotItemsFoundCount] <- row
	y[plotItemsFoundCount] <- col
	}
	}
	}
	# take out not used elements before finding correlation
	xCorrected <- head(x, plotItemsFoundCount)
	yCorrected <- head(y, plotItemsFoundCount)
	#print(xCorrected)
	#print(yCorrected)
	out <- cor(xCorrected,yCorrected)
	print(paste("Correlation Coeffecient (R)=", out))
	}

view raw getCorrCoeff.R hosted with ❤ by GitHub