path: root/src/coins.c

/******************************************************************************
 *	Copyright (C) 2018	Alejandro Colomar Andrés		      *
 *	SPDX-License-Identifier:	GPL-2.0-only			      *
 ******************************************************************************/


/******************************************************************************
 ******* headers **************************************************************
 ******************************************************************************/
#include "coins/coins.h"

#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <time.h>

#include <opencv2/imgproc/types_c.h>

#include "libalx/base/compiler/size.h"
#include "libalx/base/errno/error.h"
#include "libalx/base/stdlib/maximum.h"
#include "libalx/extra/cv/alx.h"
#include "libalx/extra/cv/core.h"
#include "libalx/extra/cv/highgui.h"
#include "libalx/extra/cv/imgproc.h"


/******************************************************************************
 ******* macros ***************************************************************
 ******************************************************************************/
#define COIN_DIAMETER_2E	(25.75)
#define COIN_LIM_2E_50c			(25.00)
#define COIN_DIAMETER_50c	(24.25)
#define COIN_LIM_50c_1E			(23.70)
#define COIN_DIAMETER_1E	(23.25)
#define COIN_LIM_1E_20c			(22.65)
#define COIN_DIAMETER_20c	(22.25) // That's the outer diameter!
#define COIN_LIM_20c_5c			(21.50)
#define COIN_DIAMETER_5c	(21.25)
#define COIN_LIM_5c_10c			(20.50)
#define COIN_DIAMETER_10c	(19.75)
#define COIN_LIM_10c_2c			(19.25)
#define COIN_DIAMETER_2c	(18.75)
#define COIN_LIM_2c_1c			(17.50)
#define COIN_DIAMETER_1c	(16.25)


/******************************************************************************
 ******* enums ****************************************************************
 ******************************************************************************/


/******************************************************************************
 ******* structs / unions *****************************************************
 ******************************************************************************/
struct	Coins {
	ptrdiff_t	x;
	ptrdiff_t	y;
	float		diameter_pix;
	double		diameter_mm;
	double		value;
};


/******************************************************************************
 ******* variables ************************************************************
 ******************************************************************************/


/******************************************************************************
 ******* static functions (prototypes) ****************************************
 ******************************************************************************/
static	int	proc_coins_steps	(const char *restrict fname);
static	int	coins_positions		(img_s *restrict img, ptrdiff_t nmemb,
					 struct Coins
						coins[static restrict nmemb],
					 ptrdiff_t *ncoins);
static	int	coins_diameters_pix	(const img_s *restrict img, ptrdiff_t n,
					 struct Coins coins[static restrict n]);
static	double	calibrate_mm_per_pix	(float max_radius_pix);
static	void	coins_diameters_mm	(double mm_per_pix, ptrdiff_t n,
					 struct Coins coins[static restrict n]);
static	int	coins_values		(ptrdiff_t n,
					 struct Coins coins[static restrict n]);
static	double	coin_value		(double diameter_mm);
static	double	coins_total_value	(ptrdiff_t n,
					 const struct Coins
						coins[static restrict n]);
static	void	report			(ptrdiff_t n,
					 const struct Coins
						coins[static restrict n],
					 double tot);


/******************************************************************************
 ******* global functions *****************************************************
 ******************************************************************************/
int	proc_coins	(const char *restrict fname)
{
	clock_t	time_0;
	clock_t	time_1;
	double	time_tot;

	time_0 = clock();
	if (proc_coins_steps(fname))
		return	-1;
	time_1 = clock();

	time_tot = ((double) time_1 - time_0) / CLOCKS_PER_SEC;
	printf("Total time:	%5.3lf s;\n", time_tot);

	return	0;
}


/******************************************************************************
 ******* static functions (definitions) ***************************************
 ******************************************************************************/
static	int	proc_coins_steps	(const char *restrict fname)
{
	img_s		*img;
	img_s		*img_dt;
	float		max_r_pix;
	struct Coins	coins[BUFSIZ];
	ptrdiff_t	ncoins;
	int		status;
	double		mm_per_pix;
	double		value_total;

	status	= -1;
	if (alx_cv_alloc_img(&img))
		return	-1;
	if (alx_cv_init_img(img, 1, 1))
		goto out_free_img;
	if (alx_cv_imread(img, fname))
		goto out_deinit_img;
	if (alx_cv_alloc_img(&img_dt))
		goto out_deinit_img;
	if (alx_cv_init_img(img_dt, 1, 1))
		goto out_free_dt;

	if (alx_cv_component(img, ALX_CV_CMP_BLUE))
		goto out_deinit_dt;
	if (alx_cv_threshold(img, CV_THRESH_BINARY_INV, ALX_CV_THR_OTSU))
		goto out_deinit_dt;
//	alx_cv_invert(img); /* Only if the source image is inverted */
//	alx_cv_imwrite(img, "/home/alex/Downloads/coins_thr.png");
	if (alx_cv_distance_transform(img))
		goto out_deinit_dt;
	if (alx_cv_maximum_flt(img, &max_r_pix))
		goto out_deinit_dt;
	/* Calibrate with the biggest coin; every img should have a 2 € coin */
	/* TODO: Fix this: should calibrate with a pattern, or else */
	mm_per_pix	= calibrate_mm_per_pix(max_r_pix);
	alx_cv_clone(img_dt, img);
//	alx_cv_imwrite(img_dt, "/home/alex/Downloads/coins_img_dt.png");
	if (alx_cv_threshold(img, CV_THRESH_TOZERO,
				(COIN_DIAMETER_1c / 2.0 - 0.5) / mm_per_pix))
		goto out_deinit_dt;
//	alx_cv_imwrite(img, "/home/alex/Downloads/coins_img_dt_thr.png");
	if (alx_cv_local_max(img))
		goto out_deinit_dt;
	if (alx_cv_dilate(img, 2))
		goto out_deinit_dt;
//	alx_cv_imwrite(img, "/home/alex/Downloads/coins_locmax.png");

	if (coins_positions(img, ARRAY_SIZE(coins), coins, &ncoins))
		goto out_deinit_dt;
//	alx_cv_imwrite(img, "/home/alex/Downloads/coins_contours.png");
	if (coins_diameters_pix(img_dt, ncoins, coins))
		goto out_deinit_dt;
	/* Get coins diameters in mm */
	coins_diameters_mm(mm_per_pix, ncoins, coins);
	/* Get coins values (by their sizes) */
	printf("mm/pix = %lf\n", mm_per_pix);

	if (coins_values(ncoins, coins))
		goto out_deinit_dt;
	/* Add total value */
	value_total	= coins_total_value(ncoins, coins);
	report(ncoins, coins, value_total);
	status	= 0;

out_deinit_dt:
	alx_cv_deinit_img(img_dt);
out_free_dt:
	alx_cv_free_img(img_dt);
out_deinit_img:
	alx_cv_deinit_img(img);
out_free_img:
	alx_cv_free_img(img);
	return	status;
}

static	int	coins_positions		(img_s *restrict img, ptrdiff_t nmemb,
					 struct Coins coins[static restrict nmemb],
					 ptrdiff_t *ncoins)
{
	conts_s		*conts;
	rect_s		*rect;
	cont_s		*cont;
	int		status;
	ptrdiff_t	x, y, w, h;

	status	= -1;

	if (alx_cv_alloc_conts(&conts))
		return	-1;
	alx_cv_init_conts(conts);
	if (alx_cv_alloc_rect(&rect))
		goto out_deinit_conts;

	if (alx_cv_contours(img, conts))
		goto out_free;
	*ncoins = alx_cv_contours_size(conts);
	if (*ncoins > nmemb)
		goto out_free;
	for (ptrdiff_t i = 0; i < *ncoins; i++) {
		if (alx_cv_contours_contour((const cont_s **)&cont, conts, i))
			goto out_free;
		alx_cv_bounding_rect(rect, cont);
alx_cv_draw_rect(img, rect);
		alx_cv_extract_rect(rect, &x, &y, &w, &h);
		coins[i].x	= x + w / 2;
		coins[i].y	= y + h / 2;
	}
	status	= 0;
out_free:
	alx_cv_free_rect(rect);
out_deinit_conts:
	alx_cv_deinit_conts(conts);
	alx_cv_free_conts(conts);
	return	status;
}

static	int	coins_diameters_pix	(const img_s *restrict img, ptrdiff_t n,
					 struct Coins coins[static restrict n])
{
	float	tmp;

	for (ptrdiff_t i = 0; i < n; i++) {
		if (alx_cv_pixel_get_flt(img, &tmp, coins[i].x, coins[i].y))
			return	-1;
		coins[i].diameter_pix	= tmp * 2.0f;
	}
	return	0;
}

static	double	calibrate_mm_per_pix	(float max_radius_pix)
{

	return	25.75 / (max_radius_pix * 2.0);
}

static	void	coins_diameters_mm	(double mm_per_pix, ptrdiff_t n,
					 struct Coins coins[static restrict n])
{

	for (ptrdiff_t i = 0; i < n; i++)
		coins[i].diameter_mm = mm_per_pix * coins[i].diameter_pix;
}

static	int	coins_values		(ptrdiff_t n,
					 struct Coins coins[static restrict n])
{

	for (ptrdiff_t i = 0; i < n; i++) {
		coins[i].value	= coin_value(coins[i].diameter_mm);
		if (coins[i].value < 0)
			return	-1;
	}

	return	0;
}

static	double	coin_value		(double diameter_mm)
{

	if (diameter_mm > (COIN_DIAMETER_2E + 1.5))
		return	-1;
	if (diameter_mm > COIN_LIM_2E_50c)
		return	2.00;
	if (diameter_mm > COIN_LIM_50c_1E)
		return	0.50;
	if (diameter_mm > COIN_LIM_1E_20c)
		return	1.00;
	if (diameter_mm > COIN_LIM_20c_5c)
		return	0.20;
	if (diameter_mm > COIN_LIM_5c_10c)
		return	0.05;
	if (diameter_mm > COIN_LIM_10c_2c)
		return	0.10;
	if (diameter_mm > COIN_LIM_2c_1c)
		return	0.02;
	if (diameter_mm > (COIN_DIAMETER_1c - 1.5))
		return	0.01;
	return	-1;
}

static	double	coins_total_value	(ptrdiff_t n,
					 const struct Coins
						coins[static restrict n])
{
	double	tot;

	tot	= 0.00;
	for (ptrdiff_t i = 0; i < n; i++)
		tot += coins[i].value;

	return	tot;
}

static	void	report			(ptrdiff_t n,
					 const struct Coins
						coins[static restrict n],
					 double tot)
{

	for (ptrdiff_t i = 0; i < n; i++) {
		printf("Coin[%ti]:\n", i);
		printf("	pos	= (%4ti, %4ti);\n",
				coins[i].x, coins[i].y);
		printf("	d	= %3.1f pix = %5.2lf mm;\n",
				coins[i].diameter_pix, coins[i].diameter_mm);
		printf("	val	= %5.2lf EUR;\n", coins[i].value);
	}
	printf("Total value:	%5.2lf EUR;\n", tot);
}


/******************************************************************************
 ******* end of file **********************************************************
 ******************************************************************************/