package photoeditorapp;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.WritableRaster;
import java.io.File;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
*
* @author 1BestCsharp
*/
public class PhotoEditorApp extends JFrame {

private BufferedImage originalImage;

private BufferedImage editedImage;
private JLabel imageLabel;

public PhotoEditorApp(){

setTitle("Photo Editor App");

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(800, 600);

setLocationRelativeTo(null);

createMenuBar();

imageLabel = new JLabel();

add(imageLabel, BorderLayout.CENTER);

JButton grayScaleButton = new JButton("Gray Scale");

grayScaleButton.setBackground(Color.darkGray);
grayScaleButton.setForeground(Color.white);
grayScaleButton.addActionListener(e -> applyGrayScaleFilter());

JButton invertButton = new JButton("Invert");

invertButton.setBackground(Color.darkGray);
invertButton.setForeground(Color.white);
invertButton.addActionListener(e -> applyInvertColorsFilter());

JButton sepiaButton = new JButton("Sepia");

sepiaButton.setBackground(Color.darkGray);
sepiaButton.setForeground(Color.white);
 sepiaButton.addActionListener(e -> applySepiaFilter());

JButton blurButton = new JButton("Blur");

blurButton.setBackground(Color.darkGray);
blurButton.setForeground(Color.white);
blurButton.addActionListener(e -> applyBlurFilter());

JButton edgeDetectionButton = new JButton("Edge Detection");

edgeDetectionButton.setBackground(Color.darkGray);
edgeDetectionButton.setForeground(Color.white);
edgeDetectionButton.addActionListener(e -> applyEdgeDetectionFilter());

JButton resetButton = new JButton("Reset");

resetButton.setBackground(Color.red);
resetButton.setForeground(Color.white);
resetButton.addActionListener(e -> resetImage());

JPanel buttonPanel = new JPanel();

buttonPanel.add(grayScaleButton);
buttonPanel.add(invertButton);
buttonPanel.add(sepiaButton);
buttonPanel.add(blurButton);
buttonPanel.add(edgeDetectionButton);
buttonPanel.add(resetButton);

add(buttonPanel, BorderLayout.SOUTH);

setVisible(true);
}

private void createMenuBar(){

// Create a menu bar for the application
JMenuBar menuBar = new JMenuBar();
// Create a "File" menu
JMenu fileMenu = new JMenu("File");

// Create "Open" menu item and set an action listener to handle its
click event
JMenuItem openItem = new JMenuItem("open");
openItem.addActionListener(e -> openImage());

// Create "Save" menu item and set an action listener to handle its
click event
JMenuItem saveItem = new JMenuItem("save");
saveItem.addActionListener(e -> saveImage());

// Add "Open" and "Save" menu items to the "File" menu

fileMenu.add(openItem);
fileMenu.add(saveItem);

// Add the "File" menu to the menu bar

menuBar.add(fileMenu);

// Set the menu bar for the application window

setJMenuBar(menuBar);
}
 // Create a Method to update the image label with the edited image
private void updateImageLabel(){

// Create an ImageIcon from the editedImage

ImageIcon imageIcon = new ImageIcon(editedImage);
// Set the image icon on the imageLabel to display the edited image
imageLabel.setIcon(imageIcon);
// Revalidate the imageLabel to ensure the updated image is displayed
correctly
imageLabel.revalidate();

// Create a Method to reset the edited image back to the original image
private void resetImage(){

// Check if there is an original image available

if(originalImage != null){
// Create a deep copy of the original image and set it as the
edited image
editedImage = copyImage(originalImage);
// Update the image label with the new edited image
updateImageLabel();

// create a method that creates a deep copy of a BufferedImage.

private BufferedImage copyImage(BufferedImage image){

// Get the ColorModel of the input image.

ColorModel cm = image.getColorModel();
// Check if the alpha channel of the image is premultiplied.
boolean isAlphaPrm = cm.isAlphaPremultiplied();
// Create a new WritableRaster that contains a copy of the image's
data.
WritableRaster raster = image.copyData(null);
// Create and return a new BufferedImage using the ColorModel,
WritableRaster,
// and the information about the alpha channel pre-multiplication.
return new BufferedImage(cm, raster, isAlphaPrm, null);

// create a method to select and display an image

private void openImage(){
// Create a file chooser dialog for selecting an image file
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileFilter(new FileNameExtensionFilter("images", "jpg",
"png"));

// Display the file chooser dialog and wait for the user to select a
file
int result = fileChooser.showOpenDialog(this);
if(result == JFileChooser.APPROVE_OPTION)
 {
// Get the selected file
File selectedFile = fileChooser.getSelectedFile();

try
{
// Check if the selected file is a valid image file
BufferedImage testImage = ImageIO.read(selectedFile);
if(testImage == null)
{
// Show an error message if the selected file is not a
valid image
JOptionPane.showMessageDialog(this, "Invalid Image File
Selected", "Error", JOptionPane.ERROR_MESSAGE);
return;
}

// Store the original image and create a copy for editing

originalImage = testImage;
editedImage = copyImage(originalImage);

// Update the image label to display the loaded image

updateImageLabel();
}
catch(Exception ex)
{
// Print any exceptions that occur during image loading
ex.printStackTrace();
// Show an error message if there's an issue loading the image
JOptionPane.showMessageDialog(this, "Error Loading The Image",
"Error", JOptionPane.ERROR_MESSAGE);
}
}
}

// create a Method to save the edited image

private void saveImage()
{

// Create a file chooser dialog for selecting an image file

JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileFilter(new FileNameExtensionFilter("images", "jpg",
"png"));

// Show the save dialog to allow the user to choose a location to save
the image
int result = fileChooser.showSaveDialog(this);
// If the user selects a location and clicks the "Save" button
if(result == JFileChooser.APPROVE_OPTION)
{
// Get the selected file and attempt to save the edited image to it
File selectedFile = fileChooser.getSelectedFile();

try
{

ImageIO.write(editedImage, "jpg", selectedFile);

}
 catch(Exception ex)
{
// Print any exceptions that occur during image loading
ex.printStackTrace();
// Show an error message if there's an issue loading the image
JOptionPane.showMessageDialog(this, "Error Saving The Image",
"Error", JOptionPane.ERROR_MESSAGE);
}
}

// create a method that applies a grayscale filter to the edited image using the
luminosity method
private void applyGrayScaleFilter()
{
// Check if the original image exists
if(originalImage != null)
{
// Loop through all the pixels in the edited image
for(int x = 0; x < editedImage.getWidth(); x++)
{
for(int y = 0; y < editedImage.getHeight(); y++)
{
// Get the RGB value of the corresponding pixel in the original
image
int rgb = originalImage.getRGB(x, y);
// Calculate the grayscale value using the luminosity method
int gray = (int) (0.3 * ((rgb >> 16) & 0xFF) + 0.59 * ((rgb >> 8)
& 0xFF) + 0.11 * (rgb & 0xFF) );

// Set the grayscale pixel in the edited image

editedImage.setRGB(x, y, (gray << 16) | (gray << 8) | gray);
}
}

// Update the image label with the edited image

updateImageLabel();
}
}

// create a method that applies a sepia filter to the edited image

private void applySepiaFilter()
{
// Check if the original image exists
if(originalImage != null)
{
// Loop through all the pixels in the edited image
for(int x = 0; x < editedImage.getWidth(); x++)
{
for(int y = 0; y < editedImage.getHeight(); y++)
{
// Get the RGB value of the corresponding pixel in the original
image
int rgb = editedImage.getRGB(x, y);
 // Extract the red, green, and blue components from the RGB
value
int r = (rgb >> 16) & 0xFF;
int g = (rgb >> 8) & 0xFF;
int b = rgb & 0xFF;

// Calculate the sepia values for red, green, and blue

components
int tr = (int) (0.393 * r + 0.769 * g + 0.189 * b);
int tg = (int) (0.349 * r + 0.686 * g + 0.168 * b);
int tb = (int) (0.272 * r + 0.534 * g + 0.131 * b);

// Ensure the sepia values are within the valid range of 0 to

255
tr = Math.min(255,tr);
tg = Math.min(255,tg);
tb = Math.min(255,tb);

// Set the sepia pixel in the edited image

editedImage.setRGB(x, y, (tr << 16) | (tg << 8) | tb);
}
}

// Update the image label with the edited image

updateImageLabel();
}
}

// create a that method applies a simple blur filter to the edited image using a
3x3 kernel.
private void applyBlurFilter()
{

// Check if the original image exists

if(originalImage != null)
{
// Define a 3x3 kernel for blurring
int[][] kernel = {{1,1,1},{1,1,1},{1,1,1}};
int kernelSum = 9; // Sum of kernel values (used for normalization)

// Loop through all the pixels in the edited image (excluding the
borders)
for(int x = 1; x < editedImage.getWidth() - 1; x++)
{
for(int y = 1; y < editedImage.getHeight() - 1; y++)
{
// Initialize RGB values to 0 for each pixel
int r = 0, g = 0, b = 0;

// Convolve the kernel over the neighboring pixels

for(int i = -1; i <= 1; i++)
{
for(int j = -1; j <= 1; j++)
{
// Get RGB value of neighboring pixel
int rgb = originalImage.getRGB(x+i, y+i);
// Multiply each color component by the corresponding kernel
value and accumulate
 r += ((rgb >> 16) & 0xFF) * kernel[i+1][j+1];
g += ((rgb >> 8) & 0xFF) * kernel[i+1][j+1];;
b += (rgb & 0xFF) * kernel[i+1][j+1];;
}
}

// Normalize the accumulated values based on the kernel sum

r /= kernelSum;
g /= kernelSum;
b /= kernelSum;

// Compose the new RGB value using the blurred color components
int newRgb = (r << 16) | (g << 8) | b;
// Update the edited image with the new RGB value
editedImage.setRGB(x, y, newRgb);
}
}

// Update the label displaying the edited image to reflect the changes
updateImageLabel();

// create a method that applies the invert colors filter to the editedImage.
private void applyInvertColorsFilter()
{
// Check if the original image exists
if(originalImage != null)
{
// Loop through all the pixels in the edited image
for(int x = 0; x < editedImage.getWidth(); x++)
{
for(int y = 0; y < editedImage.getHeight(); y++)
{
// Get the RGB color value at the current pixel in the
originalImage.
int rgb = originalImage.getRGB(x, y);
// Extract the red component, invert it, and store it in r.
int r = 255 - ((rgb >> 16) & 0xFF);
// Extract the green component, invert it, and store it in g.
int g = 255 - ((rgb >> 8) & 0xFF);
// Extract the blue component, invert it, and store it in b.
int b = 255 - (rgb & 0xFF);
// Combine the inverted RGB components and set the pixel value
in the editedImage.
editedImage.setRGB(x, y, (r << 16) | (g << 8) | b);
}
}

// Update the image label to reflect the changes made to the

editedImage.
updateImageLabel();
}
}
// create a method that applies the edge detection filter
private void applyEdgeDetectionFilter()
{

// Check if the original image exists

if(originalImage != null)
{
// Define the Sobel operators for x and y directions
int[][] sobelx = {{-1,0,1},{-2,0,2},{-1,0,1}};
int[][] sobely = {{1,2,1},{0,0,0},{-1,-2,-1}};

// Create a new BufferedImage to store the grayscale version of the

originalImage
BufferedImage grayImage = new BufferedImage(originalImage.getWidth(),
originalImage.getHeight(), BufferedImage.TYPE_BYTE_GRAY);
Graphics g = grayImage.getGraphics();
g.drawImage(originalImage, 0, 0, null);
g.dispose();

// Loop through each pixel of the editedImage (excluding the borders)

for(int x = 1; x < editedImage.getWidth() - 1; x++)
{
for(int y = 1; y < editedImage.getHeight() - 1; y++)
{
// Initialize gx and gy to store the gradient in the x and y
directions, respectively
int gx = 0, gy = 0;

// Apply the Sobel operator to the surrounding pixels of the

grayscale image
for(int i = -1; i <= 1; i++)
{
for(int j = -1; j <= 1; j++)
{
// Get the grayscale value of the pixel
int gray = grayImage.getRGB(x + i, y + j) & 0xFF;

// Apply the Sobel operator and accumulate the results in

gx and gy
gx += gray * sobelx[i+1][j + 1];
gy += gray * sobely[i+1][j + 1];
}
}

// Calculate the magnitude of the gradient using the Euclidean

distance formula
int magnitude = (int) Math.sqrt(gx * gx + gy * gy);
// Create a new RGB value with the same magnitude for each
color component
int newRgb = (magnitude << 16) | (magnitude << 8) | magnitude;

// Set the newRGB value for the corresponding pixel in the

editedImage
editedImage.setRGB(x, y, newRgb);

}
}
 // Update the label displaying the editedImage
updateImageLabel();
}
}

/**
* @param args the command line arguments
*/
public static void main(String[] args) {

// use the flatlaf lib to make the app look flat

try{
UIManager.setLookAndFeel(new com.formdev.flatlaf.FlatLightLaf());
}
catch(Exception ex){
System.out.println(ex.getMessage());
}

new PhotoEditorApp();