Neural Network Image Generator

This repository contains a neural network that generates and adjusts images based on color activations. The application combines computer vision, deep learning, and GUI elements to provide an interactive environment for image processing.

---

Features

Image Processing with Neural Networks

• Nodes and connections model activations and weights.
• Adjust brightness and contrast based on activations.

Interactive Image Adjustment

• Extract main colors of an image.
• Colors influence node activations.
• Dynamically generate new images.

New Image Instead of Scaling

• The generated image is completely rebuilt pixel by pixel.
• Enlarging to 4K or higher resolutions does not involve upscaling, as in traditional editors. Instead, a completely new image is generated based on the original data, ensuring unchanged image quality, regardless of target resolution.

User-Friendly GUI

• Load, edit, and save images directly via a graphical interface.
• Configure brightness, contrast, and image resolution.

Advanced Image Processing

• Parallel processing with multiprocessing.
• Sharpening and histogram adjustment for enhanced image quality.

---

Prerequisites

Make sure you have the following installed:

• Python 3.8+
• customtkinter
• Pillow
• torch
• numpy
• opencv-python

Install dependencies using:

pip install customtkinter pillow torch numpy opencv-python

---

Usage

Start the GUI:

python main.py

Load an Image:

1. Go to File > Load Image and select an image.

Adjust Parameters:

• Configure brightness, contrast, and resolution using the sliders.

Generate an Image:

1. Go to File > Generate Image.
2. The generated image will be saved as kunst.png.

---

Functionality

Neural Network

Each node represents a color (e.g., red, green, blue). Activations are based on color brightness and influence image processing.

Code Snippet:

class Node:
    def __init__(self, label):
        self.label = label
        self.connections = []
        self.activation = 0.0

    def add_connection(self, target_node, weight=None):
        self.connections.append(Connection(target_node, weight))

    def propagate_signal(self, input_signal):
        self.activation = max(0, input_signal)  # ReLU activation
        for connection in self.connections:
            connection.target_node.activation += self.activation * connection.weight

---

Image Generation

1. Extract Main Colors: Prioritize colors with high brightness.
2. Create Network: Connect nodes with random weights.
3. Pixel Adjustment: Use parallel processing to dynamically modify brightness and contrast.
4. Rebuild Image: Each pixel is recalculated to ensure maximum quality.

Code Snippet:

def extract_main_colors(image):
    image_array = np.array(image)
    colors = {}
    for i in range(image_array.shape[0]):
        for j in range(image_array.shape[1]):
            color = tuple(image_array[i, j])
            if sum(color) > 30:  # Ignore very dark colors
                colors[color] = colors.get(color, 0) + 1
    sorted_colors = sorted(colors.items(), key=lambda item: item[1], reverse=True)
    return [color for color, _ in sorted_colors[:6]]  # Top 6 colors

---

Examples

Original Image:

https://github.com/kruemmel-python/Neural-Network-Image-Generator/blob/main/analyse/bild4.jpg

Generated Image:

https://github.com/kruemmel-python/Neural-Network-Image-Generator/blob/main/analyse/kunst.png

Developer Notes

Extension Possibilities

• Add more colors for specific adjustments.
• Implement a tool to graphically visualize activations and weights.
• Optimize performance for real-time processing.

Code Snippet (Parallel Processing for Pixel Adjustment):

def process_chunk(args):
    image_tensor, start_row, chunk_size, category_nodes, brightness_factor, contrast_factor = args
    modified_chunk = image_tensor[:, start_row:start_row + chunk_size, :].clone()
    for x in range(modified_chunk.shape[1]):
        for y in range(modified_chunk.shape[2]):
            pixel = modified_chunk[:, x, y]
            brightness = float(brightness_factor)
            contrast = float(contrast_factor)
            for node in category_nodes:
                brightness += node.activation * 0.1
                contrast += node.activation * 0.1
            pixel = torch.clamp((pixel - 0.5) * contrast + 0.5 + brightness, 0, 1)
            modified_chunk[:, x, y] = pixel
    return start_row, modified_chunk

---

Debugging

• Monitor activation values and weights during image generation using debug logs.

---

License

This project is licensed under the MIT License. See LICENSE for details.

---

Authors

Developed by [Ralf Krümmel].