diff --git a/.idea/.gitignore b/.idea/.gitignore
deleted file mode 100644
index 26d33521a..000000000
--- a/.idea/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
diff --git a/game/.idea/.gitignore b/game/.idea/.gitignore
new file mode 100644
index 000000000..13566b81b
--- /dev/null
+++ b/game/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/game/.idea/misc.xml b/game/.idea/misc.xml
new file mode 100644
index 000000000..53624c9e1
--- /dev/null
+++ b/game/.idea/misc.xml
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/game/.idea/vcs.xml b/game/.idea/vcs.xml
new file mode 100644
index 000000000..6c0b86358
--- /dev/null
+++ b/game/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/game/Makefile b/game/Makefile
new file mode 100644
index 000000000..7caafa08f
--- /dev/null
+++ b/game/Makefile
@@ -0,0 +1,18 @@
+# Makefile
+
+CC = gcc
+CFLAGS = `pkg-config --cflags gtk+-3.0` -Wall -O3
+LDLIBS = `pkg-config --libs gtk+-3.0`
+
+EXE = main
+
+all: $(EXE)
+
+$(foreach f, $(EXE), $(eval $(f):))
+
+.PHONY: clean
+
+clean:
+ ${RM} $(EXE)
+
+# END
\ No newline at end of file
diff --git a/game/main b/game/main
new file mode 100755
index 000000000..f9ea29ef3
Binary files /dev/null and b/game/main differ
diff --git a/game/main.c b/game/main.c
new file mode 100644
index 000000000..2b9f75438
--- /dev/null
+++ b/game/main.c
@@ -0,0 +1,327 @@
+#include
+#include
+#include
+
+gulong timer_id;
+gint64 start_time;
+
+int isValidSudoku(int sudoku[9][9]) {
+ int usedRow[9][9] = { };
+ int usedColumn[9][9] = { };
+ int usedBox[3][3][9] = { };
+
+ for (int row = 0; row < 9; row++) {
+ for (int col = 0; col < 9; col++) {
+ int digit = sudoku[row][col];
+ if (digit != 0) {
+ if (usedRow[row][digit - 1] || usedColumn[col][digit - 1] || usedBox[row / 3][col / 3][digit - 1]) {
+ return 0; // Duplicate digit found
+ }
+
+ usedRow[row][digit - 1] = 1;
+ usedColumn[col][digit - 1] = 1;
+ usedBox[row / 3][col / 3][digit - 1] = 1;
+ }
+ }
+ }
+
+ return 1; // Grid is valid
+}
+
+int isSafe(int sudoku[9][9], int row, int col, int num) {
+ // Check row
+ for (int i = 0; i < 9; i++) {
+ if (sudoku[row][i] == num) {
+ return 0;
+ }
+ }
+
+ // Check column
+ for (int i = 0; i < 9; i++) {
+ if (sudoku[i][col] == num) {
+ return 0;
+ }
+ }
+
+ // Check box
+ int startRow = (row / 3) * 3;
+ int startCol = (col / 3) * 3;
+
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 3; j++) {
+ if (sudoku[startRow + i][startCol + j] == num) {
+ return 0;
+ }
+ }
+ }
+
+ return 1;
+}
+
+int solveSudoku(int sudoku[9][9]) {
+ for (int row = 0; row < 9; row++) {
+ for (int col = 0; col < 9; col++) {
+ if (sudoku[row][col] == 0) {
+ for (int num = 1; num <= 9; num++) {
+ if (isSafe(sudoku, row, col, num)) {
+ sudoku[row][col] = num;
+
+ if (solveSudoku(sudoku)) {
+ return 1;
+ }
+
+ sudoku[row][col] = 0;
+ }
+ }
+ return 0;
+ }
+ }
+ }
+ return 1;
+}
+
+void generate_sudoku(int sudoku[9][9]) {
+ // Seed the random number generator
+ srand(time(NULL));
+
+ // Initialize the sudoku grid with zeros
+ for (int i = 0; i < 9; i++) {
+ for (int j = 0; j < 9; j++) {
+ sudoku[i][j] = 0;
+ }
+ }
+
+ // Generate the complete sudoku grid
+ while(!solveSudoku(sudoku));
+
+ // Remove some digits to create a playable sudoku
+ for (int i = 0; i < 9; i++) {
+ for (int j = 0; j < 9; j++) {
+ // Randomly remove digits
+ if (rand() % 2 == 0 || rand() % 2 == 0) {
+ sudoku[i][j] = 0;
+ }
+ }
+ }
+}
+
+// Function to update the label text with the elapsed time
+gboolean updateElapsedTime(GtkLabel* label) {
+ gint64 current_time = g_get_monotonic_time();
+ gint64 elapsed_time = current_time - start_time;
+
+ // Convert the elapsed time to seconds
+ gint64 elapsed_seconds = elapsed_time / G_USEC_PER_SEC;
+
+ // Calculate minutes and seconds
+ gint minutes = elapsed_seconds / 60;
+ gint seconds = elapsed_seconds % 60;
+
+ gchar *elapsed_string = g_strdup_printf("%02d : %02d", minutes, seconds);
+ gtk_label_set_text(label, elapsed_string);
+ g_free(elapsed_string);
+
+ // Continue updating the elapsed time
+ return G_SOURCE_CONTINUE;
+}
+
+void clear_board(GtkBuilder* builder)
+{
+ for (int i = 0; i < 9; i++)
+ {
+ for (int j = 0; j < 9; j++)
+ {
+ gchar *buffer = g_strdup_printf("%i%i", i, j);
+ GtkEntry* entry = GTK_ENTRY(gtk_builder_get_object(builder, buffer));
+ if (gtk_widget_get_sensitive(GTK_WIDGET(entry)))
+ gtk_entry_set_text(entry, "");
+ }
+ }
+}
+
+void on_play(GtkButton* button, gpointer user_data)
+{
+ // Gets the builder.
+ GtkBuilder* builder = (GtkBuilder*) user_data;
+ GtkLabel* label = (GtkLabel*) gtk_builder_get_object(builder, "time");
+ GtkButton* play_button = (GtkButton*) gtk_builder_get_object(builder, "play_button");
+
+ if (timer_id == 0)
+ {
+ start_time = g_get_monotonic_time();
+ updateElapsedTime(label);
+
+ // Start the timer to update the elapsed time every second
+ timer_id = g_timeout_add_seconds(1, (GSourceFunc)updateElapsedTime, label);
+
+ gtk_button_set_label(play_button, "Stop");
+ }
+ else
+ {
+ g_source_remove(timer_id);
+ timer_id = 0;
+
+ clear_board(builder);
+ gtk_label_set_text(label, "00 : 00");
+ gtk_button_set_label(play_button, "Play");
+ }
+}
+
+void on_clear(GtkButton* button, gpointer user_data)
+{
+ GtkBuilder* builder = (GtkBuilder*) user_data;
+ clear_board(builder);
+}
+
+void printAndDisappear(const gchar *text, const gchar *color, GtkLabel* label)
+{
+ gtk_label_set_text(GTK_LABEL(label), text);
+
+ gtk_widget_show(GTK_WIDGET(label));
+ g_timeout_add_seconds(5, (GSourceFunc)gtk_widget_hide, label);
+}
+
+void on_validate(GtkButton* button, gpointer user_data)
+{
+ GtkBuilder* builder = (GtkBuilder*) user_data;
+
+ int sudoku[9][9] = {};
+
+ for (int i = 0; i < 9; i++)
+ {
+ for (int j = 0; j < 9; j++)
+ {
+ // Gets entry.
+ gchar *buffer = g_strdup_printf("%i%i", i, j);
+ GtkEntry *entry = GTK_ENTRY(gtk_builder_get_object(builder, buffer));
+ const gchar *text = gtk_entry_get_text(entry);
+ char charValue = *text;
+ int intValue = charValue - '0';
+ sudoku[i][j] = intValue;
+ }
+ }
+
+ GtkLabel* result_label = (GtkLabel*) gtk_builder_get_object(builder, "result_label");
+
+ if (isValidSudoku(sudoku))
+ {
+ printAndDisappear("Success!", "#32A852", result_label);
+ }
+ else
+ {
+ printAndDisappear("You failed!", "#A84432", result_label);
+ }
+}
+
+void on_new(GtkButton* button, gpointer user_data)
+{
+ GtkBuilder* builder = (GtkBuilder*) user_data;
+
+ if (timer_id != 0)
+ {
+ g_source_remove(timer_id);
+ timer_id = 0;
+
+ clear_board(builder);
+ GtkButton* play_button = (GtkButton*) gtk_builder_get_object(builder, "play_button");
+ GtkLabel* label = (GtkLabel*) gtk_builder_get_object(builder, "time");
+ gtk_label_set_text(label, "00 : 00");
+ gtk_button_set_label(play_button, "Play");
+ }
+
+ int sudoku[9][9] = {};
+ generate_sudoku(sudoku);
+ upload_grid(sudoku, builder);
+}
+
+void upload_grid(int sudoku[9][9], GtkBuilder* builder)
+{
+ // Set not editable cases.
+ for (int i = 0; i < 9; i++)
+ {
+ for (int j = 0; j < 9; j++)
+ {
+ // Gets entry.
+ gchar *buffer = g_strdup_printf("%i%i", i, j);
+ GtkEntry* entry = GTK_ENTRY(gtk_builder_get_object(builder, buffer));
+
+ // Avoid empty cells.
+ if (sudoku[i][j] != 0)
+ {
+ gchar *value = g_strdup_printf("%i", sudoku[i][j]);
+ gtk_widget_set_sensitive(GTK_WIDGET(entry), FALSE);
+ gtk_entry_set_text(entry, value);
+
+ // Apply CSS style to make the text bold and set label color
+ const char *css = "* { font-weight: bold; color: red; }";
+ GtkCssProvider *provider = gtk_css_provider_new();
+ gtk_css_provider_load_from_data(provider, css, -1, NULL);
+ GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(entry));
+ gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
+ }
+ else
+ {
+ gtk_widget_set_sensitive(GTK_WIDGET(entry), TRUE);
+ gtk_entry_set_text(entry, "");
+
+ const char *css = "* { font-weight: bold; color: inherit; }";
+ GtkCssProvider *provider = gtk_css_provider_new();
+ gtk_css_provider_load_from_data(provider, css, -1, NULL);
+ GtkStyleContext *context = gtk_widget_get_style_context(GTK_WIDGET(entry));
+ gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
+
+ }
+
+ gtk_entry_set_alignment(entry, 0.5);
+ gtk_entry_set_max_length(entry, 1);
+
+ }
+}
+
+// Main function.
+int main (int argc, char *argv[])
+{
+ // Initializes GTK.
+ gtk_init(NULL, NULL);
+
+ // Loads the UI description and build the UI. Exits if an error occurs.
+ GtkBuilder* builder = gtk_builder_new();
+ GError* error = NULL;
+ if (gtk_builder_add_from_file(builder, "sudo.glade", &error) == 0)
+ {
+ g_printerr("Error loading file: %s\n", error->message);
+ g_clear_error(&error);
+ return 1;
+ }
+
+ // Widgets.
+ GtkWindow* window = GTK_WINDOW(gtk_builder_get_object(builder, "main_window"));
+ GtkButton* play_button = GTK_BUTTON(gtk_builder_get_object(builder, "play_button"));
+ GtkButton* clear_button = GTK_BUTTON(gtk_builder_get_object(builder, "clear_button"));
+ GtkButton* new_button = GTK_BUTTON(gtk_builder_get_object(builder, "new_button"));
+ GtkButton* validate_button = GTK_BUTTON(gtk_builder_get_object(builder, "validate_button"));
+
+ // Connects signal.
+ g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
+ g_signal_connect(play_button, "clicked", G_CALLBACK(on_play), builder);
+ g_signal_connect(clear_button, "clicked", G_CALLBACK(on_clear), builder);
+ g_signal_connect(new_button, "clicked", G_CALLBACK(on_new), builder);
+ g_signal_connect(validate_button, "clicked", G_CALLBACK(on_validate), builder);
+
+ // -- Generates a new grid. -- //
+ on_new(new_button, builder);
+
+ // --- OR use an existing grid. --- //
+ // int sudoku[9][9];
+ // upload_grid(sudoku, builder);
+
+ // Runs the main loop.
+ gtk_main();
+
+ // Clean up resources
+ g_source_remove(timer_id);
+
+ // Exits.
+ return 0;
+
+}
diff --git a/game/sudo.glade b/game/sudo.glade
new file mode 100644
index 000000000..97c884678
--- /dev/null
+++ b/game/sudo.glade
@@ -0,0 +1,6300 @@
+
+
+
+
+
+
diff --git a/game/sudo.glade~ b/game/sudo.glade~
new file mode 100644
index 000000000..97c884678
--- /dev/null
+++ b/game/sudo.glade~
@@ -0,0 +1,6300 @@
+
+
+
+
+
+
diff --git a/grid_processing/contour_manager.c b/grid_processing/contour_manager.c
index 84dea3918..327b5b979 100644
--- a/grid_processing/contour_manager.c
+++ b/grid_processing/contour_manager.c
@@ -1,5 +1,4 @@
#include "contour_manager.h"
-#include
/// @brief Gets the polygon area from a set of points.
///
@@ -233,7 +232,7 @@ void get_points_max_shape(int width, int height, int *pixels, struct list** save
/// @param dest_x Destination set of the x coordinates of the points.
/// @param dest_y Destination set of the x coordinates of the points.
/// @param size Size of arrays
-void find_corners_of_rectangle(double* arr_x, double* arr_y, double *dest_x, double *dest_y, double size)
+void find_corners_of_rectangle2(double* arr_x, double* arr_y, double *dest_x, double *dest_y, double size)
{
// Inits the corners.
double top_left_x = 0;
@@ -327,6 +326,67 @@ void find_corners_of_rectangle(double* arr_x, double* arr_y, double *dest_x, dou
dest_y[3] = bottom_left_y;
}
+void find_corners_of_rectangle(double* arr_x, double* arr_y, double* dest_x, double* dest_y, double size) {
+
+ // Find the index of the closest point to the top-left corner of the image
+ int top_left_index = 0;
+ double min_distance = arr_x[0] + arr_y[0];
+
+ for (int i = 1; i < size; i++) {
+ double distance = arr_x[i] + arr_y[i];
+ if (distance < min_distance) {
+ min_distance = distance;
+ top_left_index = i;
+ }
+ }
+
+ // Find the index of the closest point to the top-right corner of the image
+ int top_right_index = 0;
+ min_distance = -arr_x[0] + arr_y[0];
+
+ for (int i = 1; i < size; i++) {
+ double distance = -arr_x[i] + arr_y[i];
+ if (distance < min_distance) {
+ min_distance = distance;
+ top_right_index = i;
+ }
+ }
+
+ // Find the index of the closest point to the bottom-right corner of the image
+ int bottom_right_index = 0;
+ min_distance = -arr_x[0] - arr_y[0];
+
+ for (int i = 1; i < size; i++) {
+ double distance = -arr_x[i] - arr_y[i];
+ if (distance < min_distance) {
+ min_distance = distance;
+ bottom_right_index = i;
+ }
+ }
+
+ // Find the index of the closest point to the bottom-left corner of the image
+ int bottom_left_index = 0;
+ min_distance = arr_x[0] - arr_y[0];
+
+ for (int i = 1; i < size; i++) {
+ double distance = arr_x[i] - arr_y[i];
+ if (distance < min_distance) {
+ min_distance = distance;
+ bottom_left_index = i;
+ }
+ }
+
+ // Assign the corner coordinates to the dest_x and dest_y arrays
+ dest_x[0] = arr_x[top_left_index];
+ dest_y[0] = arr_y[top_left_index];
+ dest_x[1] = arr_x[top_right_index];
+ dest_y[1] = arr_y[top_right_index];
+ dest_x[2] = arr_x[bottom_right_index];
+ dest_y[2] = arr_y[bottom_right_index];
+ dest_x[3] = arr_x[bottom_left_index];
+ dest_y[3] = arr_y[bottom_left_index];
+}
+
// tmp
@@ -402,11 +462,63 @@ void TMP_extremes_lines_and_cell_extraction(SDL_Surface* surf, double corners_x[
list_destroy(coordinates_x);
}
+double calculate_area(Point p1, Point p2, Point p3, Point p4) {
+ double area = 0.5 * fabs(p1.x * p2.y - p2.x * p1.y +
+ p2.x * p3.y - p3.x * p2.y +
+ p3.x * p4.y - p4.x * p3.y +
+ p4.x * p1.y - p1.x * p4.y);
+ return area;
+}
+
+void find_largest_shape(Point arr[], int size, Point* largest_points) {
+ double max_area = 0.0;
+
+ for (int i = 0; i < size - 3; i++) {
+ for (int j = i + 1; j < size - 2; j++) {
+ for (int k = j + 1; k < size - 1; k++) {
+ for (int l = k + 1; l < size; l++) {
+
+ double curr_area = calculate_area(arr[i], arr[j], arr[k], arr[l]);
+
+ if (curr_area > max_area) {
+ max_area = curr_area;
+ largest_points[0] = arr[i];
+ largest_points[1] = arr[j];
+ largest_points[2] = arr[k];
+ largest_points[3] = arr[l];
+ }
+ }
+ }
+ }
+ }
+}
+
+void four_points(double arr_x[], double arr_y[], double dest_x[], double dest_y[], int size) {
+ // Create an array of Points from the input coordinates
+ Point arr[size];
+ for (int i = 0; i < size; i++)
+ {
+ arr[i].x = arr_x[i];
+ arr[i].y = arr_y[i];
+ }
+
+ // Find the four points forming the largest shape
+ Point largest_points[4]; // = {{1, 2}, {1, 2}, {1, 2}, {1, 2}};
+ find_largest_shape(arr, size, largest_points);
+
+ // Copy the largest points' coordinates to the destination arrays
+ for (int i = 0; i < 4; i++)
+ {
+ dest_x[i] = largest_points[i].x;
+ dest_y[i] = largest_points[i].y;
+ }
+}
+
//
//
//
//
-void four_points(double arr_x[], double arr_y[], double dest_x[], double dest_y[], int size)
+void four_points2(double arr_x[], double arr_y[], double dest_x[], double dest_y[], int size)
{
// Compute the convex hull using the Graham scan algorithm
// and store the result in the arr_x and arr_y arrays
@@ -492,7 +604,8 @@ void get_max_points_rect(SDL_Surface* surf, double *corners_x, double *corners_y
// Gets parameters of surface.
int width = surf->w;
int height = surf->h;
- int arr_pixels[width * height];
+ int *arr_pixels = calloc(width * height, sizeof(int));
+
get_array_of_pixels(surf, arr_pixels);
// double diag = sqrt(width * width + height * height);
@@ -522,10 +635,10 @@ void get_max_points_rect(SDL_Surface* surf, double *corners_x, double *corners_y
/*
for (int i = 0; i < 4; i++)
{
- printf("%f,%f\n", dest_x[i], dest_y[i]);
+ printf("%f,%f\n", corners_x[i], corners_y[i]);
}
- */
- /*
+
+
struct list* point_x = list_new();
struct list* point_y = list_new();
point_x = list_insert_head(point_x, dest_x[0]);
@@ -539,7 +652,7 @@ void get_max_points_rect(SDL_Surface* surf, double *corners_x, double *corners_y
draw_points_on_window(point_x, point_y, surf);
*/
// TMP - Cell extraction
- TMP_extremes_lines_and_cell_extraction(surf, corners_x, corners_y);
+ // TMP_extremes_lines_and_cell_extraction(surf, corners_x, corners_y);
// DEBUG
/*
@@ -557,6 +670,7 @@ void get_max_points_rect(SDL_Surface* surf, double *corners_x, double *corners_y
*/
// Frees memory.
+ free(arr_pixels);
list_destroy(shape_point_x);
list_destroy(shape_point_y);
}
\ No newline at end of file
diff --git a/grid_processing/contour_manager.h b/grid_processing/contour_manager.h
index 323d42da5..6195f0098 100644
--- a/grid_processing/contour_manager.h
+++ b/grid_processing/contour_manager.h
@@ -21,15 +21,29 @@
#define ANSI_COLOR_RESET "\x1b[0m"
// ========================
+#include
+#include
+
+typedef struct {
+ double x;
+ double y;
+} Point;
+
void convex_hull(struct list* point_x, struct list* point_y, struct list** dest_x, struct list** dest_y);
double get_polygon_area(struct list* point_x, struct list* point_y);
void get_points_max_shape(int width, int height, int *pixels, struct list** save_point_x, struct list** save_point_y);
+
+void find_corners_of_rectangle2(double* arr_x, double* arr_y, double *dest_x, double *dest_y, double size);
void find_corners_of_rectangle(double* arr_x, double* arr_y, double *dest_x, double *dest_y, double size);
// tmp
void TMP_extremes_lines_and_cell_extraction(SDL_Surface* surf, double corners_x[], double corners_y[]);
+double calculate_area(Point p1, Point p2, Point p3, Point p4);
+void find_largest_shape(Point arr[], int size, Point* largest_points);
void four_points(double arr_x[], double arr_y[], double dest_x[], double dest_y[], int size);
+
+void four_points2(double arr_x[], double arr_y[], double dest_x[], double dest_y[], int size);
void get_max_points_rect(SDL_Surface* surf, double *corners_x, double *corners_y);
diff --git a/grid_processing/grid.png b/grid_processing/grid.png
deleted file mode 100644
index db9f01b18..000000000
Binary files a/grid_processing/grid.png and /dev/null differ
diff --git a/grid_processing/grid_detection.c b/grid_processing/grid_detection.c
index b7c1c1da4..a79508272 100644
--- a/grid_processing/grid_detection.c
+++ b/grid_processing/grid_detection.c
@@ -291,22 +291,22 @@ void get_intersections(double w, double h, double diag, struct list* list_rho,
/// @param width Width of surface.
/// @param height Height of surface.
/// @return nothing.
-void get_good_points(struct list* point_x, struct list* point_y, struct list** dest_x, struct list** dest_y, double width, double height)
+void get_good_points(struct list* point_x, struct list* point_y, struct list** dest_x, struct list** dest_y, double width, double height, int NB_CELLS)
{
- double hypo_width_cell = width / 9;
- double hypo_height_cell = height / 9;
+ double hypo_width_cell = width / NB_CELLS;
+ double hypo_height_cell = height / NB_CELLS;
double threshold = hypo_width_cell / 3;
- double hypo_grid_x[9];
- double hypo_grid_y[9];
+ double hypo_grid_x[NB_CELLS];
+ double hypo_grid_y[NB_CELLS];
- for (int j = 0; j < 9; j++)
+ for (int j = 0; j < NB_CELLS; j++)
{
hypo_grid_x[j] = j * hypo_width_cell;
}
- for (int i = 0; i < 9; i++)
+ for (int i = 0; i < NB_CELLS; i++)
{
hypo_grid_y[i] = i * hypo_height_cell;
}
@@ -316,9 +316,9 @@ void get_good_points(struct list* point_x, struct list* point_y, struct list** d
double *real_grid_x = list_to_array(point_x);
double *real_grid_y = list_to_array(point_y);
- for (int y = 0; y < 9; y++)
+ for (int y = 0; y < NB_CELLS; y++)
{
- for (int x = 0; x < 9; x++)
+ for (int x = 0; x < NB_CELLS; x++)
{
double hypo_x = hypo_grid_x[x];
double hypo_y = hypo_grid_y[y];
@@ -347,38 +347,67 @@ void get_good_points(struct list* point_x, struct list* point_y, struct list** d
}
}
+/// @brief Convert small squared surface to a 24x24 pixels surface
+///
+/// \param surf The surface to convert.
+/// \param dst_width The width of the destination image.
+/// \param dst_height The height of the destination image.
+/// \return The resized surface.
+SDL_Surface *convert_surface(SDL_Surface* surf, int dst_width, int dst_height)
+{
+ // Removes the contours on the image.
+ //SDL_Surface* surf_contour = SDL_CreateRGBSurfaceWithFormat(0, surf->w, surf->h, 32, SDL_PIXELFORMAT_RGBA32);
+ //upgrade_exploitation(surf, &surf_contour);
+
+ // Resizes image to a new surface.
+ SDL_Surface* resized_surf = SDL_CreateRGBSurfaceWithFormat(0, dst_width, dst_height, 32, SDL_PIXELFORMAT_RGBA32);
+ SDL_BlitScaled(surf, NULL, resized_surf, NULL);
+ //SDL_FreeSurface(surf_contour);
+
+ // Returns a new created surface.
+ return resized_surf;
+}
+
/// @brief Extracts cells and put them in files.
///
/// @param list_x List of x coordinates (81 x coordinates).
/// @param list_y List of y coordinates (81 y coordinates).
/// @param surf Initial surface.
/// @return nothing.
-void cell_extraction(struct list* list_x, struct list* list_y, SDL_Surface* surf)
+void cell_extraction(struct list* list_x, struct list* list_y, SDL_Surface* surf, int NB_CELLS, SDL_Surface** ocr_eleven)
{
- double width = surf->w / 9;
- double height = surf->h / 9;
+ double width = surf->w / NB_CELLS;
+ double height = surf->h / NB_CELLS;
double *arr_x = list_to_array(list_x);
double *arr_y = list_to_array(list_y);
- for (int y = 0; y < 9; y++)
+ for (int y = 0; y < NB_CELLS; y++)
{
- for (int x = 0; x < 9; x++)
+ for (int x = 0; x < NB_CELLS; x++)
{
SDL_Rect rect;
rect.h = height;
rect.w = width;
- rect.x = arr_x[x + 9 * y];
- rect.y = arr_y[x + 9 * y];
+ rect.x = arr_x[x + NB_CELLS * y];
+ rect.y = arr_y[x + NB_CELLS * y];
+
+ SDL_Surface* square = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32, SDL_PIXELFORMAT_RGBA32);
+ SDL_BlitSurface(surf, &rect, square, NULL);
- SDL_Surface* new_surf = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32, SDL_PIXELFORMAT_RGBA32);
- SDL_BlitSurface(surf, &rect, new_surf, NULL);
+ // RESIZE IMAGES TO 24X24 AND REMOVES CONTOURS
+ // ==========================================
+ SDL_Surface* resized_square = convert_surface(square, 24, 24);
+ // ===========================================
- char filepath[100];
- snprintf(filepath, sizeof(filepath), "img/%i_%i.png", 8 - y, 8 - x);
- // IMG_SavePNG(new_surf, filepath);
+ // char filepath[100];
+ // snprintf(filepath, sizeof(filepath), "img/%i_%i.png", (NB_CELLS - 1) - y, (NB_CELLS - 1) - x);
+ // IMG_SavePNG(resized_square, filepath);
- SDL_FreeSurface(new_surf);
+ ocr_eleven[NB_CELLS * ((NB_CELLS - 1) - y) + ((NB_CELLS - 1) - x)] = resized_square;
+
+ // SDL_FreeSurface(square);
+ SDL_FreeSurface(resized_square);
}
}
}
@@ -389,7 +418,7 @@ void cell_extraction(struct list* list_x, struct list* list_y, SDL_Surface* surf
/// @param list_theta Initial list of thetas.
/// @param surf_sudoku Surface from the image
/// @return nothing.
-void grid_detection(struct list* list_rho, struct list* list_theta, SDL_Surface* surf_sudoku)
+void grid_detection(struct list* list_rho, struct list* list_theta, SDL_Surface* surf_sudoku, int NB_CELLS, SDL_Surface** ocr_eleven)
{
// Parameters.
double width = surf_sudoku->w;
@@ -416,16 +445,15 @@ void grid_detection(struct list* list_rho, struct list* list_theta, SDL_Surface*
// ==========================================
struct list* final_grid_x = list_new();
struct list* final_grid_y = list_new();
- get_good_points(list_point_x, list_point_y, &final_grid_x, &final_grid_y, width, height);
+ get_good_points(list_point_x, list_point_y, &final_grid_x, &final_grid_y, width, height, NB_CELLS);
// ==========================================
// EXTRACTS CELLS - THE END
// ==========================================
- cell_extraction(final_grid_x, final_grid_y, surf_sudoku);
+ cell_extraction(final_grid_x, final_grid_y, surf_sudoku, NB_CELLS, ocr_eleven);
// ==========================================
-
// Frees memory.
list_destroy(list_rho_av);
list_destroy(list_theta_av);
diff --git a/grid_processing/grid_detection.h b/grid_processing/grid_detection.h
index 643eaf3ca..069e8dc4e 100644
--- a/grid_processing/grid_detection.h
+++ b/grid_processing/grid_detection.h
@@ -3,6 +3,7 @@
// Files.
// =====
+#include "img_upgrade.h"
#include "doubles_lists.h"
#include "basic_utilities.h"
#include "SDL_utilities.h"
@@ -20,9 +21,9 @@ void point_intersection(double surf_diag,
double rho1,double theta1, double rho2, double theta2, double* x, double* y);
void get_intersections(double w, double h, double diag, struct list* list_rho,
struct list* list_theta, struct list** list_point_x, struct list** list_point_y);
-void get_good_points(struct list* point_x, struct list* point_y,
- struct list** dest_x, struct list** dest_y, double width, double height);
-void cell_extraction(struct list* list_x, struct list* list_y, SDL_Surface* surf);
-void grid_detection(struct list* list_rho, struct list* list_theta, SDL_Surface* surf_sudoku);
+void get_good_points(struct list* point_x, struct list* point_y, struct list** dest_x, struct list** dest_y, double width, double height, int NB_CELLS);
+SDL_Surface *convert_surface(SDL_Surface* surf, int dst_width, int dst_height);
+void cell_extraction(struct list* list_x, struct list* list_y, SDL_Surface* surf, int NB_CELLS, SDL_Surface** ocr_eleven);
+void grid_detection(struct list* list_rho, struct list* list_theta, SDL_Surface* surf_sudoku, int NB_CELLS, SDL_Surface** ocr_eleven);
#endif
\ No newline at end of file
diff --git a/grid_processing/hex.jpg b/grid_processing/hex.jpg
new file mode 100644
index 000000000..d9bf75eb6
Binary files /dev/null and b/grid_processing/hex.jpg differ
diff --git a/grid_processing/hough_transform.c b/grid_processing/hough_transform.c
index ec634b2e3..4f76d054e 100644
--- a/grid_processing/hough_transform.c
+++ b/grid_processing/hough_transform.c
@@ -17,7 +17,7 @@ void hough_transform(SDL_Surface* surf, struct list** list_theta, struct list**
// Initializes a new matrix of bits (0 or 1).
// And gets array of 0 and 1 from a surface.
- int pixel_array[width * height];
+ int *pixel_array = calloc(width * height, sizeof(int));
// Gets the array of pixels from the surface.
get_array_of_pixels(surf, pixel_array);
@@ -115,4 +115,5 @@ void hough_transform(SDL_Surface* surf, struct list** list_theta, struct list**
// Frees memory.
free(accumulator);
+ free(pixel_array);
}
\ No newline at end of file
diff --git a/grid_processing/img/black_grid.png b/grid_processing/img/black_grid.png
deleted file mode 100644
index 089757875..000000000
Binary files a/grid_processing/img/black_grid.png and /dev/null differ
diff --git a/grid_processing/img/grid_test1.png b/grid_processing/img/grid_test1.png
deleted file mode 100644
index b3e9e7195..000000000
Binary files a/grid_processing/img/grid_test1.png and /dev/null differ
diff --git a/grid_processing/img_upgrade.c b/grid_processing/img_upgrade.c
index cf6346e80..89d745e2b 100644
--- a/grid_processing/img_upgrade.c
+++ b/grid_processing/img_upgrade.c
@@ -154,7 +154,7 @@ int fill_top(int width, int height, int* pixels)
//
//
//
-int fill_bottom(int width, int height, int* pixels)
+void fill_bottom(int width, int height, int* pixels)
{
// Inits constants.
int min_zone = width / 3;
@@ -164,8 +164,6 @@ int fill_bottom(int width, int height, int* pixels)
// Saves the last line that has been detected.
int last_line = height - 1;
- int cpt = 0;
-
// For only the third part.
for (int i = height - 1; i > 2 * height / 3; i--)
{
@@ -187,8 +185,8 @@ int fill_bottom(int width, int height, int* pixels)
{
for (int j_tmp = 0; j_tmp < width; j_tmp++)
{
+ // printf("%i, %i, %i\n", j_tmp + width * i_tmp, width, height * width);
pixels[j_tmp + width * i_tmp] = 0;
- cpt++;
}
}
@@ -196,11 +194,8 @@ int fill_bottom(int width, int height, int* pixels)
last_line = i;
}
}
-
- return cpt;
}
-
// Main function to upgrade image.
//
// surf: initial surface.
@@ -211,7 +206,9 @@ void upgrade_exploitation(SDL_Surface* surf, SDL_Surface** dest)
// Init.
int width = surf->w;
int height = surf->h;
- int pixels[width * height];
+ int* pixels = malloc(width * height * sizeof(int));
+ if (pixels == NULL)
+ return;
// Converts surface into array.
get_array_of_pixels(surf, pixels);
@@ -233,4 +230,6 @@ void upgrade_exploitation(SDL_Surface* surf, SDL_Surface** dest)
// Saves surface.
*dest = array_to_surface(width, height, pixels);
+
+ free(pixels);
}
\ No newline at end of file
diff --git a/grid_processing/img_upgrade.h b/grid_processing/img_upgrade.h
index 32b34a9af..a953871cd 100644
--- a/grid_processing/img_upgrade.h
+++ b/grid_processing/img_upgrade.h
@@ -23,7 +23,7 @@
int fill_left(int width, int height, int* pixels);
int fill_right(int width, int height, int* pixels);
int fill_top(int width, int height, int* pixels);
-int fill_bottom(int width, int height, int* pixels);
+void fill_bottom(int width, int height, int* pixels);
void upgrade_exploitation(SDL_Surface* surf, SDL_Surface** dest);
#endif
\ No newline at end of file
diff --git a/grid_processing/main.c b/grid_processing/main.c
index 2a2e931c5..794e95ec7 100644
--- a/grid_processing/main.c
+++ b/grid_processing/main.c
@@ -11,11 +11,11 @@ int main(int argc, char** argv)
if (argc != 2)
errx(EXIT_FAILURE, "Usage: image-path");
-
// INIT - GET IMAGE
// ====================================================
// Creates a new surface from the image in parameter.
SDL_Surface* surf_img = load_image(argv[1]);
+
// Checks if there is any error with the image.
if (surf_img == NULL)
errx(EXIT_FAILURE, "%s", SDL_GetError());
@@ -25,7 +25,6 @@ int main(int argc, char** argv)
SDL_FreeSurface(surf_img);
// ====================================================
-
// UPGRADE IMAGE - REMOVE PARASITES
// ====================================================
SDL_Surface* surf = SDL_CreateRGBSurfaceWithFormat(0, surf_wait->w, surf_wait->h, 32, SDL_PIXELFORMAT_RGBA32);
@@ -46,11 +45,9 @@ int main(int argc, char** argv)
double corners_x[4];
double corners_y[4];
// Gets the coordinates of the four corners of sudoku.
- get_max_points_rect(surf_wait, corners_x, corners_y);
- // ====================================================
+ get_max_points_rect(surf, corners_x, corners_y);
- // tmp
- return 0;
+ // ====================================================
// ROTATION AND NEW SQUARED SURFACE WITH ONLY SUDOKU
// ONLY FOR ORIENTED SUDOKU
@@ -60,7 +57,6 @@ int main(int argc, char** argv)
// ..
// ====================================================
-
// HOUGH TRANSFORM - LINES DETECTION
// ====================================================
struct list* list_rho = list_new();
@@ -69,18 +65,26 @@ int main(int argc, char** argv)
hough_transform(surf, &list_theta, &list_rho, 2.1);
// ====================================================
-
// MAXIMUM DETECTION - MATRIX PERSPECTIVE TRANSFORM - CELLS EXTRACTION
// ====================================================
- grid_detection(list_rho, list_theta, surf);
+ int NB_CELLS = 9;
+ SDL_Surface** ocr_eleven = calloc(NB_CELLS * NB_CELLS, sizeof(SDL_Surface*));
+ grid_detection(list_rho, list_theta, surf, NB_CELLS, ocr_eleven);
// ====================================================
-
// Frees memory.
SDL_FreeSurface(surf);
list_destroy(list_rho);
list_destroy(list_theta);
+ for (int i = 0; i < NB_CELLS * NB_CELLS; i++)
+ {
+ // printf("%p\n", ocr_eleven[i]);
+ SDL_FreeSurface(ocr_eleven[i]);
+ }
+
+ free(ocr_eleven);
+
// End.
return EXIT_SUCCESS;
}
\ No newline at end of file
diff --git a/grid_processing/sudoku_grid.png b/grid_processing/sudoku_grid.png
deleted file mode 100644
index 1304449b3..000000000
Binary files a/grid_processing/sudoku_grid.png and /dev/null differ