Normal

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package steganography;

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import javax.imageio.ImageIO;

/**
 *
 * @author DiePiePaw
 */
public class Normal {

    public void runSteganography(File image, File data, String key) throws IOException {
        int[][] matrix = this.getPixelMatrix(image);
        int[] keyUse = this.generateShuffleIndex(key, matrix.length, matrix.length);
        char[] dataArray = this.getBitData(data);
        int[][] matrixStego = this.insertData(dataArray, matrix, keyUse);
        this.makeImage(this.getImageWidth(image), this.getImageHeight(image), matrixStego);

        int[] extract = this.extractData(keyUse, matrixStego);

        //pre process data
        int getLengthName = extract[0];
        int[] realData = new int[extract.length-2-getLengthName];
        int indexReal=0;
        for(int n=1+getLengthName;n<extract.length-1;n++){
            realData[indexReal] = extract[n];
            indexReal++;
        }
        String name = this.getName(getLengthName, extract);
        this.makeDataFile(realData, "extract.txt");
        Function func = new Function();
        func.calculatePSNR(matrix, matrixStego);
    }

    public boolean isContain(int[] array, int value) {
        if(Arrays.asList(array).contains(value)) {
            return true;
        } else {
            return false;
        }
    }

    public int[] generateShuffleIndex(String key, int length, int max) {
        int seed=0;
        char[] keyChar = key.toCharArray();

        for(int iterate=0; iterate<keyChar.length; iterate++) {
            seed+=keyChar[iterate];
        }

        int[] result = new int[length];
        int iterator = 0;
        Random random = new Random(seed);

        while(iterator<result.length) {
            int tempRandom = random.nextInt((max-0)+0);
            if(!isContain(result,tempRandom)) {
                result[iterator] = tempRandom;
                iterator++;
            }
        }

        return result;
    }

    public int[] getPixel(BufferedImage buffer, int x, int y) {
        int argb = buffer.getRGB(x, y);
        int rgb[] = new int[] {
            (argb >> 16) & 0xff,
            (argb >>  8) & 0xff,
            (argb      ) & 0xff
        };
        return rgb;
    }

    public int[][] getPixelMatrix(File image) throws IOException {
        BufferedImage buffer = ImageIO.read(image);
        int[][] pixelMatrix = new int[buffer.getWidth()*buffer.getHeight()][3];
        int index=0;
        for(int n=0;n<buffer.getHeight();n++) {
            for(int m=0;m<buffer.getWidth();m++) {
                pixelMatrix[index] = this.getPixel(buffer, m, n);
                index++;
            }
        }
        return pixelMatrix;
    }

    public char[] getBitData(File data) throws FileNotFoundException, IOException {
        char[] resultBit;
        String tempStringData = String.format("%8s", Integer.toBinaryString((byte)data.getName().length() & 0xFF)).replace(' ', '0');

        for(int n=0;n<data.getName().length();n++) {
            tempStringData+=String.format("%8s", Integer.toBinaryString((byte)data.getName().charAt(n) & 0xFF)).replace(' ', '0');
        }

        byte[] tempData = new byte[(int)data.length()];
        FileInputStream dataStream = new FileInputStream(data);
        dataStream.read(tempData, 0, tempData.length);

        int index=0;
        while(index<data.length()) {
            tempStringData+=String.format("%8s", Integer.toBinaryString(tempData[index] & 0xFF)).replace(' ', '0');
            index++;
        }
        tempStringData+="00000000";
        resultBit = tempStringData.toCharArray();
        return resultBit;
    }

    public int[][] insertData(char[] resultBit, int[][] matrixImage, int[] indexPixel) {
        int indexData=0;
        int[][] matrix = matrixImage;


        for(int n=0;n<resultBit.length;n++){
            for(int m=0;m<matrix[n].length;m++){
                matrix[indexPixel[n]][m] = changeBit(matrix[indexPixel[n]][m], resultBit[indexData]);
                indexData++;
                if(indexData>=resultBit.length){
                    break;
                }
            }

            if(indexData>=resultBit.length){
                break;
            }
        }

        return matrix;
    }

    public int changeBit(int image, char data) {

        int result=image;
        if(result%2==0){
            if(data=='1'){
                result++;
            } else {

            }
        } else {
            if(data=='0'){
                result--;
            } else {

            }
        }
        return result;
    }

    public int[] extractData(int[] key, int[][] imageMatrix) {
        List<Character> tempChar = new ArrayList<Character>();
        List<Integer> tempIntData = new ArrayList<Integer>();
        boolean repeat=true;
        int idxParse=0;
        int idxKey=0;

        System.out.println("");
        while(repeat){
            for(int n=0;n<imageMatrix[key[idxKey]].length;n++){
                tempChar.add(this.getData(imageMatrix[key[idxKey]][n]));
                idxParse++;

                if(idxParse%8==0) {
                    String tempString = tempChar.get(0).toString();
                    for(int x=1;x<tempChar.size();x++){
                        tempString+=tempChar.get(x).toString();
                    }
                    tempIntData.add(Integer.parseInt(tempString, 2));
                    //System.out.print(Integer.parseInt(tempString, 2)+" ");
                    tempChar.clear();
                    if(tempIntData.contains(0)){
                        repeat=false;
                    }
                    idxParse=0;
                }
            }
            idxKey++;
        }
        //System.out.println("");
        int[] result = new int[tempIntData.size()];
        for(int n=0;n<result.length;n++){
            result[n]=tempIntData.get(n);
            //System.out.print((char)result[n]);
        }


        return result;
    }

    public char getData(int image) {
        if(image%2==0) {
            return '0';
        } else {
            return '1';
        }
    }

    public String getName(int length, int[] data) {
        char[] tempChar = new char[length];
        int idxTemp=0;
        for(int n=1;n<tempChar.length+1;n++){
            tempChar[idxTemp] = (char)data[n];
            idxTemp++;
        }

        return new String(tempChar);
    }

    public void makeImage(int width, int height, int[][] imageByte) throws IOException {

        BufferedImage buffer = new BufferedImage(width, height,BufferedImage.TYPE_INT_RGB);
        int idxImage=0;
        for(int n=0;n<height;n++){
            for(int m=0;m<width;m++){
                Color tempCol = new Color(imageByte[idxImage][0],imageByte[idxImage][1],imageByte[idxImage][2]);
                buffer.setRGB(m, n, tempCol.getRGB());
                idxImage++;
            }
        }

        ImageIO.write(buffer, "bmp", new File("saved.bmp"));

    }

    public int getImageWidth(File image) throws IOException {
        BufferedImage width = ImageIO.read(image);
        return width.getWidth();
    }

    public int getImageHeight(File image) throws IOException {
        BufferedImage height = ImageIO.read(image);
        return height.getHeight();
    }

    public void makeDataFile(int[] streamData, String name) throws FileNotFoundException, IOException {
        byte[] byteData = new byte[streamData.length];
        for(int n=0;n<streamData.length;n++){
            byteData[n] = (byte)streamData[n];
        }
        FileOutputStream stream = new FileOutputStream(name);
        try {
            stream.write(byteData);
        } finally {
            stream.close();
        }
    }

}