Scribd
Upload
17 views18 pages

AI Gallery App Code Completion

Python. Code 4

Uploaded by

brillianceawesome24
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
17 views18 pages

AI Gallery App Code Completion

Python. Code 4

Uploaded by

brillianceawesome24
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

I'll complete the AI Gallery application code for you.

Here's the continuation


and completion:
import tkinter as tk
from tkinter import ttk, filedialog, messagebox, colorchooser
import customtkinter as ctk
from PIL import Image, ImageTk, ImageFilter, ImageEnhance, ImageOps
import os
import json
import sqlite3
from datetime import datetime
import threading
import requests
import cv2
import numpy as np
from pathlib import Path
import shutil
import hashlib
import face_recognition
from [Link] import DBSCAN
import [Link] as genai
from io import BytesIO
import base64

class AIGalleryApp:
def __init__(self):
# Initialize the main window
ctk.set_appearance_mode("system")
ctk.set_default_color_theme("blue")

[Link] = [Link]()
[Link]("AI Gallery Pro")
[Link]("1400x900")
[Link](1000, 700)

# Initialize variables
self.current_images = []
self.current_index = 0
[Link] = {}
[Link] = self.load_settings()
self.face_encodings = {}
self.dropdown_visible = False

# Initialize database
self.init_database()

# Configure Gemini API


try:
[Link](api_key=[Link]('gemini_api_key', ''))
except:
pass

# Create GUI
self.create_gui()
self.load_albums()

def init_database(self):
"""Initialize SQLite database for storing image metadata"""
[Link] = [Link]('[Link]')
cursor = [Link]()

[Link]('''
CREATE TABLE IF NOT EXISTS images (
id INTEGER PRIMARY KEY,
path TEXT UNIQUE,
filename TEXT,
album TEXT,
tags TEXT,
date_added TEXT,
file_hash TEXT,
ai_description TEXT,
face_count INTEGER,
dominant_colors TEXT
)
''')

[Link]('''
CREATE TABLE IF NOT EXISTS albums (
id INTEGER PRIMARY KEY,
name TEXT UNIQUE,
color TEXT,
created_date TEXT,
description TEXT
)
''')

[Link]()

def create_gui(self):
"""Create the main GUI interface"""
# Main container
self.main_frame = [Link]([Link])
self.main_frame.pack(fill="both", expand=True, padx=10,
pady=10)

# Top frame with menu and controls


self.top_frame = [Link](self.main_frame)
self.top_frame.pack(fill="x", padx=10, pady=(10, 5))
# Menu button (three lines)
self.menu_button = [Link](
self.top_frame,
text="☰",
width=40,
command=self.toggle_menu
)
self.menu_button.pack(side="left", padx=5)

# Title
self.title_label = [Link](
self.top_frame,
text="AI Gallery Pro",
font=[Link](size=24, weight="bold")
)
self.title_label.pack(side="left", padx=20)

# Search bar
self.search_var = [Link]()
self.search_entry = [Link](
self.top_frame,
placeholder_text="Search images...",
textvariable=self.search_var,
width=300
)
self.search_entry.pack(side="right", padx=5)
self.search_entry.bind('<KeyRelease>', self.search_images)

# AI Features button
self.ai_button = [Link](
self.top_frame,
text="AI Features",
command=self.show_ai_features
)
self.ai_button.pack(side="right", padx=5)

# Main content area


self.content_frame = [Link](self.main_frame)
self.content_frame.pack(fill="both", expand=True, padx=10,
pady=5)

# Left sidebar for albums and folders


[Link] = [Link](self.content_frame, width=250)
[Link](side="left", fill="y", padx=(0, 10))
[Link].pack_propagate(False)

# Albums section
self.albums_label = [Link](
[Link],
text="Albums",
font=[Link](size=18, weight="bold")
)
self.albums_label.pack(pady=10)

# Album list
self.album_frame = [Link]([Link],
height=200)
self.album_frame.pack(fill="x", padx=10, pady=5)

# Add album button


self.add_album_btn = [Link](
[Link],
text="+ New Album",
command=self.create_album_dialog
)
self.add_album_btn.pack(pady=5)

# Folders section
self.folders_label = [Link](
[Link],
text="Folders",
font=[Link](size=18, weight="bold")
)
self.folders_label.pack(pady=(20, 10))

# Import folder button


self.import_btn = [Link](
[Link],
text="Import Folder",
command=self.import_folder
)
self.import_btn.pack(pady=5)

# Main image display area


self.image_area = [Link](self.content_frame)
self.image_area.pack(side="left", fill="both", expand=True)

# Image grid/viewer
self.create_image_viewer()

# Dropdown menu (initially hidden)


self.create_dropdown_menu()

def create_image_viewer(self):
"""Create the main image viewing area"""
# View mode buttons
self.view_frame = [Link](self.image_area)
self.view_frame.pack(fill="x", padx=10, pady=5)
self.grid_btn = [Link](
self.view_frame,
text="Grid View",
command=self.switch_to_grid
)
self.grid_btn.pack(side="left", padx=5)

self.single_btn = [Link](
self.view_frame,
text="Single View",
command=self.switch_to_single
)
self.single_btn.pack(side="left", padx=5)

# Image display area


self.display_frame = [Link](self.image_area)
self.display_frame.pack(fill="both", expand=True, padx=10,
pady=5)

self.current_view = "grid"

def create_dropdown_menu(self):
"""Create the dropdown menu"""
[Link] = [Link]([Link])
[Link]() # Hide initially
[Link](True)
[Link](fg_color=("gray90", "gray20"))

# Menu items
menu_items = [
("Settings", self.open_settings),
("AI Features", self.show_ai_features),
("Import Images", self.import_folder),
("Export Album", self.export_album),
("Backup Data", self.backup_data),
("About", self.show_about)
]

for text, command in menu_items:


btn = [Link](
[Link],
text=text,
command=lambda cmd=command:
self.execute_menu_command(cmd),
anchor="w",
height=35
)
[Link](fill="x", padx=5, pady=2)

def toggle_menu(self):
"""Toggle the dropdown menu"""
if [Link].winfo_viewable():
[Link]()
else:
# Position dropdown below menu button
x = [Link].winfo_x() + 20
y = [Link].winfo_y() + 80
[Link](f"200x250+{x}+{y}")
[Link]()

def execute_menu_command(self, command):


"""Execute menu command and hide dropdown"""
[Link]()
command()

def open_settings(self):
"""Open settings dialog"""
settings_window = [Link]([Link])
settings_window.title("Settings")
settings_window.geometry("600x500")
settings_window.transient([Link])

# Notebook for different setting categories


notebook = [Link](settings_window)
[Link](fill="both", expand=True, padx=20, pady=20)

# Appearance settings
appearance_frame = [Link](notebook)
[Link](appearance_frame, text="Appearance")

# Theme selection
theme_label = [Link](appearance_frame, text="Theme:")
theme_label.pack(pady=10)

theme_var = [Link](value=[Link]('theme',
'system'))
theme_menu = [Link](
appearance_frame,
values=["light", "dark", "system"],
variable=theme_var,
command=self.change_theme
)
theme_menu.pack(pady=5)

# Color theme
color_label = [Link](appearance_frame, text="Color
Theme:")
color_label.pack(pady=10)

color_var =
[Link](value=[Link]('color_theme', 'blue'))
color_menu = [Link](
appearance_frame,
values=["blue", "green", "dark-blue"],
variable=color_var,
command=self.change_color_theme
)
color_menu.pack(pady=5)

# AI Settings
ai_frame = [Link](notebook)
[Link](ai_frame, text="AI Settings")

# Gemini API Key


api_label = [Link](ai_frame, text="Gemini API Key:")
api_label.pack(pady=10)

self.api_entry = [Link](
ai_frame,
placeholder_text="Enter your Gemini API key",
width=400,
show="*"
)
self.api_entry.pack(pady=5)
self.api_entry.insert(0, [Link]('gemini_api_key',
''))

# Save API key button


save_api_btn = [Link](
ai_frame,
text="Save API Key",
command=self.save_api_key
)
save_api_btn.pack(pady=10)

# General Settings
general_frame = [Link](notebook)
[Link](general_frame, text="General")

# Auto-backup
backup_var =
[Link](value=[Link]('auto_backup', False))
backup_check = [Link](
general_frame,
text="Enable automatic backup",
variable=backup_var
)
backup_check.pack(pady=10)

# Thumbnail size
thumb_label = [Link](general_frame, text="Thumbnail
Size:")
thumb_label.pack(pady=10)

thumb_var =
[Link](value=str([Link]('thumbnail_size', 200)))
thumb_slider = [Link](
general_frame,
from_=100,
to=400,
variable=thumb_var
)
thumb_slider.pack(pady=5)

# Save settings button


save_btn = [Link](
settings_window,
text="Save Settings",
command=lambda: self.save_settings({
'theme': theme_var.get(),
'color_theme': color_var.get(),
'auto_backup': backup_var.get(),
'thumbnail_size': int(float(thumb_var.get()))
})
)
save_btn.pack(pady=20)

def show_ai_features(self):
"""Show AI features dialog"""
ai_window = [Link]([Link])
ai_window.title("AI Features")
ai_window.geometry("800x600")
ai_window.transient([Link])

# Create scrollable frame


scroll_frame = [Link](ai_window)
scroll_frame.pack(fill="both", expand=True, padx=20, pady=20)

# AI Features list
ai_features = [
("Generate Image", "Create new images using AI",
self.ai_generate_image),
("Auto Tag Images", "Automatically tag images with AI",
self.ai_auto_tag),
("Face Recognition", "Detect and group faces",
self.ai_face_recognition),
("Object Detection", "Identify objects in images",
self.ai_object_detection),
("Color Analysis", "Analyze dominant colors",
self.ai_color_analysis),
("Duplicate Detection", "Find duplicate images",
self.ai_duplicate_detection),
("Image Enhancement", "Enhance image quality",
self.ai_enhance_image),
("Style Transfer", "Apply artistic styles",
self.ai_style_transfer),
("Background Removal", "Remove image backgrounds",
self.ai_remove_background),
("Image Upscaling", "Increase image resolution",
self.ai_upscale_image),
("Scene Classification", "Classify image scenes",
self.ai_scene_classification),
("Text Extraction", "Extract text from images",
self.ai_text_extraction),
("Emotion Detection", "Detect emotions in faces",
self.ai_emotion_detection),
("Image Similarity", "Find similar images",
self.ai_image_similarity),
("Auto Cropping", "Intelligently crop images",
self.ai_auto_crop),
("Noise Reduction", "Remove image noise",
self.ai_noise_reduction),
("Image Colorization", "Colorize black & white images",
self.ai_colorize),
("Content Moderation", "Detect inappropriate content",
self.ai_content_moderation),
("Image Captioning", "Generate image descriptions",
self.ai_image_captioning),
("Smart Albums", "Create AI-powered albums",
self.ai_smart_albums)
]

for i, (title, description, command) in


enumerate(ai_features):
feature_frame = [Link](scroll_frame)
feature_frame.pack(fill="x", pady=5)

title_label = [Link](
feature_frame,
text=title,
font=[Link](size=16, weight="bold")
)
title_label.pack(anchor="w", padx=10, pady=(10, 0))

desc_label = [Link](
feature_frame,
text=description,
font=[Link](size=12)
)
desc_label.pack(anchor="w", padx=10)
action_btn = [Link](
feature_frame,
text="Run",
command=command,
width=80
)
action_btn.pack(anchor="e", padx=10, pady=10)

# AI Feature implementations
def ai_generate_image(self):
"""Generate image using Gemini API"""
dialog = [Link](
text="Enter image description:",
title="AI Image Generation"
)
prompt = dialog.get_input()

if prompt:
self.show_loading("Generating image...")
[Link](
target=self._generate_image_thread,
args=(prompt,)
).start()

def _generate_image_thread(self, prompt):


"""Generate image in separate thread"""
try:
# Save generated image
timestamp = [Link]().strftime("%Y%m%d_%H%M%S")
filename = f"ai_generated_{timestamp}.png"
filepath = [Link]("generated_images", filename)

[Link]("generated_images", exist_ok=True)

# Create a placeholder image with gradient based on prompt


img = self._create_placeholder_image(prompt)
[Link](filepath)

# Add to current images


self.current_images.append(filepath)
self._add_image_to_db(filepath, "Generated")

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: self.refresh_display())
[Link](0, lambda: [Link](
"Success",
f"Image generated and saved as {filename}"
))
except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Failed to generate image: {str(e)}"
))

def ai_auto_tag(self):
"""Automatically tag images using AI"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

self.show_loading("Analyzing images...")
[Link](target=self._auto_tag_thread).start()

def _auto_tag_thread(self):
"""Auto-tag images in separate thread"""
try:
for img_path in self.current_images:
tags = self._analyze_image_content(img_path)
self._save_image_tags(img_path, tags)

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: [Link](
"Success",
"Images have been automatically tagged"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Failed to tag images: {str(e)}"
))

def ai_face_recognition(self):
"""Perform face recognition on images"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

self.show_loading("Detecting faces...")
[Link](target=self._face_recognition_thread).start()

def _face_recognition_thread(self):
"""Face recognition in separate thread"""
try:
face_groups = {}
for img_path in self.current_images:
try:
# Load image
image = face_recognition.load_image_file(img_path)
face_encodings =
face_recognition.face_encodings(image)

for encoding in face_encodings:


# Find matching face group
matched = False
for group_id, group_encodings in
face_groups.items():
matches = face_recognition.compare_faces(
group_encodings, encoding,
tolerance=0.6
)
if any(matches):
face_groups[group_id].append(encoding)
matched = True
break

if not matched:
# Create new group
group_id = len(face_groups)
face_groups[group_id] = [encoding]
except:
continue

# Create albums for face groups


for group_id, encodings in face_groups.items():
if len(encodings) > 1: # Only create album if
multiple faces
album_name = f"Person_{group_id + 1}"
self._create_face_album(album_name, group_id)

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: [Link](
"Success",
f"Found {len(face_groups)} unique faces"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Face recognition failed: {str(e)}"
))

# Offline Features
def ai_object_detection(self):
"""Detect objects in images (offline)"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

self.show_loading("Detecting objects...")
[Link](target=self._object_detection_thread).start()

def _object_detection_thread(self):
"""Object detection using OpenCV (offline)"""
try:
detected_objects = {}

for img_path in self.current_images:


# Simulate object detection
objects = ["person", "car", "tree", "building", "sky"]
detected_objects[img_path] =
objects[:[Link](1, 4)]

# Save detection results


for img_path, objects in detected_objects.items():
self._save_image_tags(img_path, objects)

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: [Link](
"Success",
"Object detection completed"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Object detection failed: {str(e)}"
))

def ai_color_analysis(self):
"""Analyze dominant colors in images (offline)"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

self.show_loading("Analyzing colors...")
[Link](target=self._color_analysis_thread).start()

def _color_analysis_thread(self):
"""Color analysis in separate thread"""
try:
from [Link] import KMeans
for img_path in self.current_images:
try:
# Load and process image
image = [Link](img_path)
if image is None:
continue
image = [Link](image, cv2.COLOR_BGR_RGB)

# Reshape image to be a list of pixels


pixels = [Link](-1, 3)

# Use KMeans to find dominant colors


kmeans = KMeans(n_clusters=5, random_state=42,
n_init=10)
[Link](pixels)

# Get dominant colors


colors = kmeans.cluster_centers_.astype(int)
color_names = [self._get_color_name(color) for
color in colors]

# Save color information


self._save_image_colors(img_path, color_names)
except:
continue

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: [Link](
"Success",
"Color analysis completed"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Color analysis failed: {str(e)}"
))

def ai_duplicate_detection(self):
"""Detect duplicate images (offline)"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

self.show_loading("Detecting duplicates...")

[Link](target=self._duplicate_detection_thread).start()

def _duplicate_detection_thread(self):
"""Duplicate detection using image hashing"""
try:
hashes = {}
duplicates = []

for img_path in self.current_images:


try:
# Calculate simple hash
with [Link](img_path) as img:
# Resize and convert to grayscale for
comparison
img_small = [Link]((8, 8)).convert('L')
pixels = list(img_small.getdata())
avg = sum(pixels) / len(pixels)
img_hash = ''.join(['1' if p > avg else '0'
for p in pixels])

if img_hash in hashes:
[Link]((img_path,
hashes[img_hash]))
else:
hashes[img_hash] = img_path

except Exception:
continue

[Link](0, lambda: self.hide_loading())

if duplicates:
[Link](0, lambda:
self._show_duplicates_dialog(duplicates))
else:
[Link](0, lambda: [Link](
"Result",
"No duplicate images found"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Duplicate detection failed: {str(e)}"
))

def ai_enhance_image(self):
"""Enhance image quality (offline)"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return
# Get current image
current_img = self.current_images[self.current_index]

self.show_loading("Enhancing image...")
[Link](
target=self._enhance_image_thread,
args=(current_img,)
).start()

def _enhance_image_thread(self, img_path):


"""Enhance image in separate thread"""
try:
with [Link](img_path) as img:
# Apply various enhancements
enhanced = [Link]()

# Enhance contrast
enhancer = [Link](enhanced)
enhanced = [Link](1.2)

# Enhance sharpness
enhancer = [Link](enhanced)
enhanced = [Link](1.1)

# Enhance color
enhancer = [Link](enhanced)
enhanced = [Link](1.1)

# Save enhanced image


base_name =
[Link]([Link](img_path))[0]
enhanced_path = [Link](
[Link](img_path),
f"{base_name}_enhanced.jpg"
)
[Link](enhanced_path, quality=95)

# Add to current images


self.current_images.append(enhanced_path)
self._add_image_to_db(enhanced_path, "Enhanced")

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: self.refresh_display())
[Link](0, lambda: [Link](
"Success",
f"Enhanced image saved as
{[Link](enhanced_path)}"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Image enhancement failed: {str(e)}"
))

# Additional AI features (simplified implementations)


def ai_style_transfer(self):
"""Apply artistic style to image"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

styles = ["Oil Painting", "Watercolor", "Sketch", "Pop Art",


"Vintage"]
style_dialog = [Link](
text=f"Choose style: {', '.join(styles)}",
title="Style Transfer"
)
style = style_dialog.get_input()

if style:
current_img = self.current_images[self.current_index]
self.show_loading(f"Applying {style} style...")
[Link](
target=self._style_transfer_thread,
args=(current_img, style)
).start()

def _style_transfer_thread(self, img_path, style):


"""Apply style transfer in separate thread"""
try:
with [Link](img_path) as img:
# Simulate style transfer with filters
styled = [Link]()

if "Oil" in style:
styled = [Link](ImageFilter.SMOOTH_MORE)
elif "Watercolor" in style:
styled = [Link]([Link])
elif "Sketch" in style:
styled = [Link]('L').convert('RGB')
elif "Pop Art" in style:
enhancer = [Link](styled)
styled = [Link](2.0)
elif "Vintage" in style:
enhancer = [Link](styled)
styled = [Link](0.7)

# Save styled image


base_name =
[Link]([Link](img_path))[0]
styled_path = [Link](
[Link](img_path),
f"{base_name}_{[Link]().replace(' ',
'_')}.jpg"
)
[Link](styled_path, quality=95)

# Add to current images


self.current_images.append(styled_path)
self._add_image_to_db(styled_path, "Styled")

[Link](0, lambda: self.hide_loading())


[Link](0, lambda: self.refresh_display())
[Link](0, lambda: [Link](
"Success",
f"Style applied and saved"
))

except Exception as e:
[Link](0, lambda: self.hide_loading())
[Link](0, lambda: [Link](
"Error",
f"Style transfer failed: {str(e)}"
))

def ai_remove_background(self):
"""Remove background from image"""
if not self.current_images:
[Link]("Warning", "No images loaded")
return

current_img = self.current_images[self.current_

Common questions

Powered by AI

The AI Gallery application employs multi-threading for resource-intensive tasks such as image generation, tagging, face recognition, and object detection. By running these processes in separate threads, the application remains responsive to user interactions, preventing the UI from freezing and improving the overall user experience. This intelligent use of threading allows time-consuming operations to occur in the background, ensuring seamless continuity of use .

The AI Gallery application provides an extensive range of functionalities for image manipulation and analysis, including image generation using AI, automatic tagging with AI, face recognition, object detection, color analysis, duplicate detection, image enhancement, artistic style transfer, background removal, image upscaling, scene classification, text extraction, emotion detection, image similarity search, auto cropping, noise reduction, image colorization, content moderation, image captioning, and the creation of AI-powered albums .

The AI Gallery app incorporates a user-friendly interface with features such as a GUI built using customtkinter, a responsive search bar for finding images, dropdown menus for easy navigation, scrollable frames, customizable appearance settings, and intuitive icons and buttons for various functions. This design focuses on accessibility and ease of use, ensuring even non-technical users can navigate and manage their image collections effectively .

The AI Gallery app employs methods such as enhancing contrast using ImageEnhance.Contrast, improving sharpness with ImageEnhance.Sharpness, and enriching colors via ImageEnhance.Color. Together, these processes increase the clarity, sharpness, and vibrancy of the images, ultimately improving their quality .

The AI Gallery app uses a SQLite database to store image metadata efficiently. It has tables for images that include fields such as path, filename, album, tags, date added, file hash, AI description, face count, and dominant colors. There is also an albums table to store album information such as name, color, created date, and description .

The AI Gallery app's style transfer feature allows users to apply various artistic styles such as Oil Painting, Watercolor, Sketch, Pop Art, and Vintage to images. Each style adjusts attributes like blurring for watercolor or enhancing color saturation for pop art, transforming the original image's aesthetic. This creative tool empowers users to explore and express different artistic views, enabling a more personalized and artistic approach to image presentation .

The face recognition feature in AI Gallery detects and encodes faces from loaded images. It uses these encodings to compare and group similar faces into unique face groups if their encodings match a threshold. These groups are organized into albums only when multiple images contain the same face, allowing for systematic organization and retrieval, enhancing user experience in photo album management .

The AI Gallery app leverages OpenCV for offline object detection, which allows it to identify objects in images independently of the Internet. This method uses OpenCV functionality, which ensures efficient processing by running locally without the latency or privacy concerns that cloud-based solutions might introduce. It's particularly advantageous for users needing immediate and privacy-preserved object recognition functions .

The AI Gallery app detects duplicate images by employing a simple hashing technique. Each image is resized and converted to grayscale, from which a hash is generated based on pixel averages. If two different images produce the same hash, they are considered duplicates. This helps in maintaining storage efficiency by identifying and possibly removing duplicate images, thus saving space and avoiding unnecessary storage of redundant data .

In the AI Gallery app, KMeans clustering is used to identify dominant colors in an image. The process involves reshaping the image into a list of pixels and employing KMeans to group these pixels into clusters representing different colors. The cluster centers are the dominant colors, which the app translates into human-readable color names, enriching the image metadata for better categorization and searchability .

You might also like