I'll create an awesome AI Gallery with 20 AI features using CustomTkinter

and Gemini API. Here's a comprehensive implementation:

import customtkinter as ctk
from PIL import Image, ImageTk, ImageFilter, ImageEnhance, ImageOps
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
import os
import json
import threading
import requests
import io
import base64
import numpy as np
import cv2
from datetime import datetime
import google.generativeai as genai

# Configure CustomTkinter
ctk.set_appearance_mode("dark")
ctk.set_default_color_theme("blue")

class AIGallery:
def __init__(self):
self.root = ctk.CTk()
self.root.title("🎨 Awesome AI Gallery")
self.root.geometry("1400x900")
self.root.minsize(1200, 800)

# Configure Gemini API (Replace with your API key)

self.gemini_api_key = "YOUR_GEMINI_API_KEY_HERE"
try:
genai.configure(api_key=self.gemini_api_key)
self.gemini_model = genai.GenerativeModel('gemini-pro-
vision')
except:
print("Gemini API not configured. Some features may not
work.")

# Initialize variables
self.current_image = None
self.original_image = None
self.image_history = []
self.current_folder = None
self.image_files = []
self.current_index = 0
self.zoom_factor = 1.0

# Color schemes for different features

 self.color_schemes = {
"enhance": "#FF6B6B",
"filter": "#4ECDC4",
"artistic": "#45B7D1",
"ai_edit": "#96CEB4",
"transform": "#FFEAA7",
"analysis": "#DDA0DD",
"generation": "#98D8C8",
"restoration": "#F7DC6F"
}

self.setup_ui()
self.load_sample_images()

def setup_ui(self):
# Main container
self.main_frame = ctk.CTkFrame(self.root)
self.main_frame.pack(fill="both", expand=True, padx=10,
pady=10)

# Top toolbar
self.create_toolbar()

# Main content area

self.content_frame = ctk.CTkFrame(self.main_frame)
self.content_frame.pack(fill="both", expand=True, pady=(10,
0))

# Left sidebar - AI Features

self.create_sidebar()

# Center - Image display

self.create_image_display()

# Right panel - Controls and info

self.create_right_panel()

# Bottom status bar

self.create_status_bar()

def create_toolbar(self):
toolbar = ctk.CTkFrame(self.main_frame, height=60)
toolbar.pack(fill="x", pady=(0, 10))

# File operations
file_frame = ctk.CTkFrame(toolbar)
file_frame.pack(side="left", padx=10, pady=10)

ctk.CTkButton(file_frame, text="📁 Open",

command=self.open_file,
 width=80, height=35).pack(side="left", padx=5)
ctk.CTkButton(file_frame, text="📂 Folder",
command=self.open_folder,
width=80, height=35).pack(side="left", padx=5)
ctk.CTkButton(file_frame, text="💾 Save",
command=self.save_image,
width=80, height=35).pack(side="left", padx=5)

# Navigation
nav_frame = ctk.CTkFrame(toolbar)
nav_frame.pack(side="left", padx=10, pady=10)

ctk.CTkButton(nav_frame, text="⬅️
", command=self.prev_image,
width=40, height=35).pack(side="left", padx=2)
ctk.CTkButton(nav_frame, text="➡️
", command=self.next_image,
width=40, height=35).pack(side="left", padx=2)

# Zoom controls
zoom_frame = ctk.CTkFrame(toolbar)
zoom_frame.pack(side="left", padx=10, pady=10)

ctk.CTkButton(zoom_frame, text="🔍+", command=self.zoom_in,

width=40, height=35).pack(side="left", padx=2)
ctk.CTkButton(zoom_frame, text="🔍-", command=self.zoom_out,
width=40, height=35).pack(side="left", padx=2)
ctk.CTkButton(zoom_frame, text="🔄", command=self.reset_zoom,
width=40, height=35).pack(side="left", padx=2)

# Undo/Redo
history_frame = ctk.CTkFrame(toolbar)
history_frame.pack(side="right", padx=10, pady=10)

ctk.CTkButton(history_frame, text="↶ Undo", command=self.undo,

width=70, height=35).pack(side="left", padx=2)
ctk.CTkButton(history_frame, text="↷ Redo",
command=self.reset_image,
width=70, height=35).pack(side="left", padx=2)

def create_sidebar(self):
# Scrollable sidebar for AI features
self.sidebar = ctk.CTkScrollableFrame(self.content_frame,
width=300)
self.sidebar.pack(side="left", fill="y", padx=(0, 10))

# AI Features sections
self.create_ai_features()

def create_ai_features(self):
# Enhancement Features
self.create_feature_section("🎨 Enhancement", "enhance", [
 ("✨ Auto Enhance", self.auto_enhance),
("🌟 Brightness", self.adjust_brightness),
("🎭 Contrast", self.adjust_contrast),
("🌈 Saturation", self.adjust_saturation),
("🔆 Gamma Correction", self.gamma_correction)
])

# Filter Features
self.create_feature_section("🎪 Filters", "filter", [
("🌊 Blur", self.apply_blur),
("⚡ Sharpen", self.apply_sharpen),
("🎯 Edge Detection", self.edge_detection),
("🌙 Emboss", self.apply_emboss),
("💎 Crystallize", self.crystallize_effect)
])

# Artistic Features
self.create_feature_section("🎨 Artistic", "artistic", [
(" Oil Painting", self.oil_painting_effect),
("✏️Pencil Sketch", self.pencil_sketch),
("🌈 Cartoon Effect", self.cartoon_effect),
("🎭 Pop Art", self.pop_art_effect),
("🌟 Vintage", self.vintage_effect)
])

# AI Generation
self.create_feature_section("🤖 AI Generation", "generation", [
("🎨 Generate Image", self.generate_image),
("🔄 Style Transfer", self.style_transfer),
("🎪 Background Change", self.change_background),
("👤 Portrait Enhancement", self.enhance_portrait),
("🌅 Upscale Image", self.upscale_image)
])

def create_feature_section(self, title, color_key, features):

# Section header
header = ctk.CTkFrame(self.sidebar)
header.pack(fill="x", pady=(10, 5))

color = self.color_schemes.get(color_key, "#4ECDC4")

title_label = ctk.CTkLabel(header, text=title, font=("Arial",

16, "bold"))
title_label.pack(pady=10)

# Feature buttons
for feature_name, feature_func in features:
btn = ctk.CTkButton(
self.sidebar,
text=feature_name,
 command=feature_func,
height=40,
fg_color=color,
hover_color=self.darken_color(color)
)
btn.pack(fill="x", pady=2, padx=5)

def create_image_display(self):
# Image display area
self.image_frame = ctk.CTkFrame(self.content_frame)
self.image_frame.pack(side="left", fill="both", expand=True)

# Image canvas with scrollbars

canvas_frame = ctk.CTkFrame(self.image_frame)
canvas_frame.pack(fill="both", expand=True, padx=10, pady=10)

self.canvas = tk.Canvas(canvas_frame, bg="#2b2b2b",

highlightthickness=0)

# Scrollbars
v_scrollbar = tk.Scrollbar(canvas_frame, orient="vertical",
command=self.canvas.yview)
h_scrollbar = tk.Scrollbar(canvas_frame, orient="horizontal",
command=self.canvas.xview)

self.canvas.configure(yscrollcommand=v_scrollbar.set,
xscrollcommand=h_scrollbar.set)

# Pack scrollbars and canvas

v_scrollbar.pack(side="right", fill="y")
h_scrollbar.pack(side="bottom", fill="x")
self.canvas.pack(side="left", fill="both", expand=True)

# Bind mouse events

self.canvas.bind("<Button-1>", self.on_canvas_click)
self.canvas.bind("<B1-Motion>", self.on_canvas_drag)
self.canvas.bind("<MouseWheel>", self.on_mouse_wheel)

def create_right_panel(self):
# Right control panel
self.right_panel = ctk.CTkFrame(self.content_frame, width=250)
self.right_panel.pack(side="right", fill="y")

# Image info section

info_frame = ctk.CTkFrame(self.right_panel)
info_frame.pack(fill="x", padx=10, pady=10)

ctk.CTkLabel(info_frame, text="📊 Image Info", font=("Arial",

14, "bold")).pack(pady=5)
 self.info_text = ctk.CTkTextbox(info_frame, height=100)
self.info_text.pack(fill="x", padx=5, pady=5)

# Quick adjustments
adjust_frame = ctk.CTkFrame(self.right_panel)
adjust_frame.pack(fill="x", padx=10, pady=10)

ctk.CTkLabel(adjust_frame, text="⚙️Quick Adjust",

font=("Arial", 14, "bold")).pack(pady=5)

# Sliders for quick adjustments

self.create_adjustment_sliders(adjust_frame)

# AI Analysis section
analysis_frame = ctk.CTkFrame(self.right_panel)
analysis_frame.pack(fill="both", expand=True, padx=10,
pady=10)

ctk.CTkLabel(analysis_frame, text="🤖 AI Analysis",

font=("Arial", 14, "bold")).pack(pady=5)

ctk.CTkButton(analysis_frame, text="🔍 Analyze Image",

command=self.analyze_image).pack(pady=5)

self.analysis_text = ctk.CTkTextbox(analysis_frame,
height=200)
self.analysis_text.pack(fill="both", expand=True, padx=5,
pady=5)

def create_adjustment_sliders(self, parent):

# Brightness slider
ctk.CTkLabel(parent, text="Brightness").pack(anchor="w",
padx=5)
self.brightness_slider = ctk.CTkSlider(parent, from_=-100,
to=100,

command=self.on_brightness_change)
self.brightness_slider.set(0)
self.brightness_slider.pack(fill="x", padx=5, pady=2)

# Contrast slider
ctk.CTkLabel(parent, text="Contrast").pack(anchor="w", padx=5)
self.contrast_slider = ctk.CTkSlider(parent, from_=-100,
to=100,

command=self.on_contrast_change)
self.contrast_slider.set(0)
self.contrast_slider.pack(fill="x", padx=5, pady=2)

# Saturation slider
 ctk.CTkLabel(parent, text="Saturation").pack(anchor="w",
padx=5)
self.saturation_slider = ctk.CTkSlider(parent, from_=-100,
to=100,

command=self.on_saturation_change)
self.saturation_slider.set(0)
self.saturation_slider.pack(fill="x", padx=5, pady=2)

def create_status_bar(self):
self.status_bar = ctk.CTkFrame(self.main_frame, height=30)
self.status_bar.pack(fill="x", pady=(10, 0))

self.status_label = ctk.CTkLabel(self.status_bar,
text="Ready")
self.status_label.pack(side="left", padx=10, pady=5)

self.progress_bar = ctk.CTkProgressBar(self.status_bar)
self.progress_bar.pack(side="right", padx=10, pady=5)
self.progress_bar.set(0)

# File Operations
def open_file(self):
file_path = filedialog.askopenfilename(
title="Select Image",
filetypes=[("Image files", "*.jpg *.jpeg *.png *.bmp *.gif
*.tiff")]
)
if file_path:
self.load_image(file_path)

def open_folder(self):
folder_path = filedialog.askdirectory(title="Select Image
Folder")
if folder_path:
self.load_folder(folder_path)

def load_image(self, file_path):

try:
self.original_image = Image.open(file_path)
self.current_image = self.original_image.copy()
self.display_image()
self.update_image_info()
self.status_label.configure(text=f"Loaded:
{os.path.basename(file_path)}")
except Exception as e:
messagebox.showerror("Error", f"Failed to load image:
{str(e)}")

def load_folder(self, folder_path):

 self.current_folder = folder_path
self.image_files = []

for file in os.listdir(folder_path):

if file.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp',
'.gif', '.tiff')):
self.image_files.append(os.path.join(folder_path,
file))

if self.image_files:
self.current_index = 0
self.load_image(self.image_files[0])
else:
messagebox.showinfo("Info", "No image files found in the
selected folder.")

def save_image(self):
if self.current_image:
file_path = filedialog.asksaveasfilename(
title="Save Image",
defaultextension=".png",
filetypes=[("PNG files", "*.png"), ("JPEG files",
"*.jpg"), ("All files", "*.*")]
)
if file_path:
self.current_image.save(file_path)
self.status_label.configure(text=f"Saved:
{os.path.basename(file_path)}")

# Navigation
def prev_image(self):
if self.image_files and self.current_index > 0:
self.current_index -= 1
self.load_image(self.image_files[self.current_index])

def next_image(self):
if self.image_files and self.current_index <
len(self.image_files) - 1:
self.current_index += 1
self.load_image(self.image_files[self.current_index])

# Display Functions
def display_image(self):
if self.current_image:
# Calculate display size
canvas_width = self.canvas.winfo_width()
canvas_height = self.canvas.winfo_height()

if canvas_width <= 1 or canvas_height <= 1:

self.root.after(100, self.display_image)
 return

img_width, img_height = self.current_image.size

# Apply zoom
display_width = int(img_width * self.zoom_factor)
display_height = int(img_height * self.zoom_factor)

# Resize image for display

display_image = self.current_image.resize((display_width,
display_height), Image.Resampling.LANCZOS)

# Convert to PhotoImage
self.photo = ImageTk.PhotoImage(display_image)

# Clear canvas and display image

self.canvas.delete("all")
self.canvas.create_image(display_width//2,
display_height//2, image=self.photo)

# Update scroll region

self.canvas.configure(scrollregion=self.canvas.bbox("all"))

def update_image_info(self):
if self.current_image:
width, height = self.current_image.size
mode = self.current_image.mode
format_info = getattr(self.current_image, 'format',
'Unknown')

info_text = f"Size: {width} x {height}\n"

info_text += f"Mode: {mode}\n"
info_text += f"Format: {format_info}\n"
info_text += f"Zoom: {self.zoom_factor:.1f}x"

self.info_text.delete("1.0", "end")
self.info_text.insert("1.0", info_text)

# Zoom Functions
def zoom_in(self):
self.zoom_factor = min(self.zoom_factor * 1.2, 5.0)
self.display_image()
self.update_image_info()

def zoom_out(self):
self.zoom_factor = max(self.zoom_factor / 1.2, 0.1)
self.display_image()
self.update_image_info()
 def reset_zoom(self):
self.zoom_factor = 1.0
self.display_image()
self.update_image_info()

# History Functions
def add_to_history(self):
if self.current_image:
self.image_history.append(self.current_image.copy())
if len(self.image_history) > 10: # Limit history
self.image_history.pop(0)

def undo(self):
if self.image_history:
self.current_image = self.image_history.pop()
self.display_image()

def reset_image(self):
if self.original_image:
self.current_image = self.original_image.copy()
self.display_image()
self.reset_sliders()

def reset_sliders(self):
self.brightness_slider.set(0)
self.contrast_slider.set(0)
self.saturation_slider.set(0)

# Enhancement Features
def auto_enhance(self):
if not self.current_image:
return

self.add_to_history()
self.show_progress("Auto enhancing...")

def enhance():
try:
# Auto contrast
enhanced = ImageOps.autocontrast(self.current_image)
# Auto color balance
enhanced = ImageOps.equalize(enhanced)
# Slight sharpening
enhancer = ImageEnhance.Sharpness(enhanced)
enhanced = enhancer.enhance(1.2)

self.current_image = enhanced
self.root.after(0, self.display_image)
self.root.after(0, lambda:
self.status_label.configure(text="Auto enhancement complete"))
 except Exception as e:
self.root.after(0, lambda:
messagebox.showerror("Error", str(e)))
finally:
self.root.after(0, self.hide_progress)

threading.Thread(target=enhance, daemon=True).start()

def adjust_brightness(self):
if not self.current_image:
return
self.show_adjustment_dialog("Brightness",
self.apply_brightness_adjustment)

def adjust_contrast(self):
if not self.current_image:
return
self.show_adjustment_dialog("Contrast",
self.apply_contrast_adjustment)

def adjust_saturation(self):
if not self.current_image:
return
self.show_adjustment_dialog("Saturation",
self.apply_saturation_adjustment)

def gamma_correction(self):
if not self.current_image:
return
self.show_adjustment_dialog("Gamma",
self.apply_gamma_correction, default=1.0, range_=(0.1, 3.0))

# Filter Features
def apply_blur(self):
if not self.current_image:
return
self.add_to_history()
self.current_image =
self.current_image.filter(ImageFilter.GaussianBlur(radius=2))
self.display_image()

def apply_sharpen(self):
if not self.current_image:
return
self.add_to_history()
self.current_image =
self.current_image.filter(ImageFilter.SHARPEN)
self.display_image()

def edge_detection(self):
 if not self.current_image:
return
self.add_to_history()
self.current_image =
self.current_image.filter(ImageFilter.FIND_EDGES)
self.display_image()

def apply_emboss(self):
if not self.current_image:
return
self.add_to_history()
self.current_image =
self.current_image.filter(ImageFilter.EMBOSS)
self.display_image()

def crystallize_effect(self):
if not self.current_image:
return
self.add_to_history()

# Convert to numpy array for advanced processing

img_array = np.array(self.current_image)

# Apply crystallize effect using morphological operations

kernel = np.ones((5,5), np.uint8)
crystallized = cv2.morphologyEx(img_array, cv2.MORPH_CLOSE,
kernel)

self.current_image = Image.fromarray(crystallized)
self.display_image()

# Artistic Features
def oil_painting_effect(self):
if not self.current_image:
return
self.add_to_history()
self.show_progress("Applying oil painting effect...")

def apply_effect():
try:
# Convert to OpenCV format
img_array = np.array(self.current_image)
img_cv = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)

# Apply oil painting effect

oil_painting = cv2.xphoto.oilPainting(img_cv, 7, 1)

# Convert back to PIL

oil_painting_rgb = cv2.cvtColor(oil_painting,
cv2.COLOR_BGR2RGB)
 self.current_image = Image.fromarray(oil_painting_rgb)

self.root.after(0, self.display_image)
self.root.after(0, lambda:
self.status_label.configure(text="Oil painting effect applied"))
except Exception as e:
# Fallback to simple filter if OpenCV extra modules
not available
enhancer = ImageEnhance.Color(self.current_image)
enhanced = enhancer.enhance(1.5)
self.current_image =
enhanced.filter(ImageFilter.SMOOTH_MORE)
self.root.after(0, self.display_image)
finally:
self.root.after(0, self.hide_progress)

threading.Thread(target=apply_effect, daemon=True).start()

def pencil_sketch(self):
if not self.current_image:
return
self.add_to_history()

# Convert to grayscale
gray = self.current_image.convert('L')

# Invert the image

inverted = ImageOps.invert(gray)

# Apply Gaussian blur

blurred = inverted.filter(ImageFilter.GaussianBlur(radius=5))

# Blend with original using color dodge

sketch = Image.blend(gray, blurred, 0.5)

self.current_image = sketch.convert('RGB')
self.display_image()

def cartoon_effect(self):
if not self.current_image:
return
self.add_to_history()
self.show_progress("Creating cartoon effect...")

def apply_cartoon():
try:
img_array = np.array(self.current_image)
img_cv = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)

# Reduce colors
 data = np.float32(img_cv).reshape((-1, 3))
criteria = (cv2.TERM_CRITERIA_EPS +
cv2.TERM_CRITERIA_MAX_ITER, 20, 1.0)
_, labels, centers = cv2.kmeans(data, 8, None,
criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
centers = np.uint8(centers)
cartoon =
centers[labels.flatten()].reshape(img_cv.shape)

# Add edge lines

gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
edges = cv2.adaptiveThreshold(gray, 255,
cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 9)
edges = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)

# Combine
cartoon = cv2.bitwise_and(cartoon, edges)

cartoon_rgb = cv2.cvtColor(cartoon, cv2.COLOR_BGR2RGB)

self.current_image = Image.fromarray(cartoon_rgb)

self.root.after(0, self.display_image)
self.root.after(0, lambda:
self.status_label.configure(text="Cartoon effect applied"))
except Exception as e:
# Fallback effect
posterized = ImageOps.posterize(self.current_image, 4)
self.current_image = posterized
self.root.after(0, self.display_image)
finally:
self.root.after(0, self.hide_progress)

threading.Thread(target=apply_cartoon, daemon=True).start()

def pop_art_effect(self):
if not self.current_image:
return
self.add_to_history()

# Posterize for pop art effect

posterized = ImageOps.posterize(self.current_image, 3)

# Enhance colors
enhancer = ImageEnhance.Color(posterized)
enhanced = enhancer.enhance(2.0)

# Increase contrast
enhancer = ImageEnhance.Contrast(enhanced)
self.current_image = enhancer.enhance(1.5)
 self.display_image()

def vintage_effect(self):
if not self.current_image:
return
self.add_to_history()

# Reduce saturation
enhancer = ImageEnhance.Color(self.current_image)
vintage = enhancer.enhance(0.7)

# Add sepia tone

sepia_filter = (
0.393, 0.769, 0.189, 0,
0.349, 0.686, 0.168, 0,
0.272, 0.534, 0.131, 0
)
vintage = vintage.convert('RGB', sepia_filter)

# Reduce brightness slightly

enhancer = ImageEnhance.Brightness(vintage)
self.current_image = enhancer.enhance(0.9)

self.display_image()

# AI Generation Features (Placeholder implementations)

def generate_image(self):
self.show_text_input_dialog("Generate Image", "Enter
description:", self.generate_image_from_text)

def generate_image_from_text(self, prompt):

self.show_progress("Generating image...")

def generate():
try:
# This would integrate with Gemini's image generation
# For now, create a placeholder
placeholder = Image.new('RGB', (512, 512),
color='lightblue')
self.current_image = placeholder
self.original_image = placeholder.copy()

self.root.after(0, self.display_image)
self.root.after(0, lambda:
self.status_label.configure(text="Image generated (placeholder)"))
except Exception as e:
self.root.after(0, lambda:
messagebox.showerror("Error", str(e)))
finally:
self.root.after(0, self.hide_progress)
 threading.Thread(target=generate, daemon=True).start()

def style_transfer(self):
messagebox.showinfo("Style Transfer", "Select a style image to
transfer to current image")

def change_background(self):
if not self.current_image:
return
messagebox.showinfo("Background Change", "AI background
removal and replacement coming soon!")

def enhance_portrait(self):
if not self.current_image:
return
self.add_to_history()

# Simple portrait enhancement

enhancer = ImageEnhance.Sharpness(self.current_image)
enhanced = enhancer.enhance(1.2)

enhancer = ImageEnhance.Color(enhanced)
self.current_image = enhancer.enhance(1.1)

self.display_image()

def upscale_image(self):
if not self.current_image:
return
self.add_to_history()

# Simple upscaling (2x)

width, height = self.current_image.size
self.current