Modos2.java

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.imageio.stream.ImageInputStream;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;

public class Modos {
    public static int N=3;
    public static Image image;
    public static BufferedImage bi;
    public static Graphics gr;

///////////////     ECB     ///////////////////////

    public int[][] ECB_RGB(File input) throws IOException
    {
        image= new ImageIcon(input.getAbsolutePath()).getImage();
        bi = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
        gr = bi.getGraphics();
        gr.drawImage(image, 0, 0, null);

        Color c;
        int r, g, b;

        int tam = bi.getHeight() * bi.getWidth();
        int p=0;
        int[][] MatPixel = new int[tam][3];
        while(p<tam){
            for(int y=0; y < bi.getHeight(); y++)
            {
                for(int x=0; x< bi.getWidth(); x++)
                {
                    c = new Color(bi.getRGB(x, y));
                    r = c.getRed();
                    g = c.getGreen();
                    b = c.getBlue();
                    MatPixel[p][0] = r;
                    MatPixel[p][1] = g;
                    MatPixel[p][2] = b;
                    p++;
                }
            }
        }
        return MatPixel;
}

    public int[][] Multiplicacion(int MatPix[][],int Key[][])
    {
        System.out.println(MatPix.length);
        int Multiplicacion[][]= new int [MatPix.length][3];
        for(int k=0; k<MatPix.length ; k++)
        {
            for(int j=0; j<N; j++)
            {
                for(int i=0; i<N; i++)
                {
                    Multiplicacion[k][j]+= MatPix[k][i]*Key[i][j];
                    Multiplicacion[k][j]=ObtenerMod(Multiplicacion[k][j]);
                }
            }
        }
        return Multiplicacion;
}

    public void ModificarRGB(JPanel Panel,int result[][]) throws IOException
    {
            bi = new BufferedImage( image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
            gr = bi.getGraphics();
            gr.drawImage(image, 0, 0, null);
            System.out.println("desde modificar RGB");

            Color c;
            int p=0, r, g, b;
            while(p<bi.getHeight())
            {
                for(int y=0; y < bi.getHeight(); y++)
                {
                    for(int x=0; x< bi.getWidth(); x++)
                    {
                            //c = new Color(bi.getRGB(x, y));
                            r = (int)result[p][0];
                            g = (int)result[p][1];
                            b = (int)result[p][2];
                            c = new Color(r, g, b);
                            bi.setRGB(x, y, c.getRGB());
                            p++;
                        }
                    }
            }
            //Mostramos Imgen

            //JFrame frame = new JFrame("Resultado");
            //frame.setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
            Panel.add(new Panel(bi, Panel.getSize()));
            Panel.setVisible(true);
            Panel.repaint();
            GuardarIma(bi);
//            JLabel label = new JLabel(new ImageIcon(bi));
//            frame.getContentPane().add(label);
//            frame.pack();
//            frame.setVisible(true);
//            System.out.println("Ya sali");
//            return bi;
        }


    public int[] ProductoPix(int []Pix, int Key[][])
    {
        int producto[]= new int[Pix.length];
        for(int i=0; i<Pix.length; i++)
        {
            for(int j=0; j<Pix.length; j++)
            {
                producto[i]+= Pix[j]*Key[j][i];
                producto[i]= ObtenerMod(producto[i]);
            }
        }
        return producto;
    }


    //////////////      Metodos Gnerales     /////////////////////////

    public int ObtenerInverso(int det){
        int i;
        int inverso = 0;
        int modulo;
        int Z= 256;
        for(i=0; i<Z; i++){
                modulo = (det*i)%Z;
               if(modulo == 1)
               {
                   inverso = i;
               }
        }
        return inverso;
    }

    public void Imprimir(int [][]aux){
        int i,j;
        for(i=0; i<aux.length; i++)
        {
            for(j=0; j<aux.length; j++)
            {
                System.out.printf("%3d \t",aux[i][j]);
            }
            System.out.print("\n");
        }
    }

    public int ObtenerMod(int num){
        if(num<0)
        {
            while(num<0)
            {
                num = num + 256;
            }
        }
        else
        {
            num = num %256;
        }
        return num;
    }

    public int ObtenerDeter(int aux[][])
    {
        int deter = 0;
        if(aux.length==2)
        {
            deter = (aux[0][0]*aux[1][1])-(aux[1][0]*aux[0][1]);
        }
        else if(aux.length==3)
        {
         deter=( aux[0][0]*( (aux[1][1]*aux[2][2]) - (aux[2][1]*aux[1][2]) ) -
                 aux[0][1]*( (aux[1][0]*aux[2][2]) - (aux[2][0]*aux[1][2]) ) +
                 aux[0][2]*( (aux[1][0]*aux[2][1]) - (aux[2][0]*aux[1][1]) ) );
        }
         return deter;
    }

    public int[][] matrizCofactores(int [][]inversa)
    {
        int [][]aux= new int[inversa.length][inversa.length];
        for(int i= 0; i<inversa.length; i++){
            for(int j=0; j<inversa.length; j++)
            {
                int[][] det = new int[inversa.length-1][inversa.length-1];
                int detValor;
                for(int k=0; k<inversa.length; k++)
                {
                    if(k!=i)
                    {
                        for(int l=0; l<inversa.length; l++)
                        {
                            if(l!=j)
                            {
                                int indice1 = k<i ? k : k-1;
                                int indice2 = l<j ? l : l-1;
                                det[indice1][indice2]=inversa[k][l];
                            }
                        }
                    }
                }
            detValor = ObtenerDeter(det);
            aux[i][j]= (int) (detValor * Math.pow(-1,i+j+2));
            }
        }
        return aux;
    }

    public int[][] transpuesta(int x[][]){
        int resp[][]=new int[1][1];
    try {
            resp=new int[N][N];
            for(int i=0; i<N; i++) {
                for(int j=0; j<N; j++){
                    resp[i][j]=x[j][i];
        }
            }
            } catch (NegativeArraySizeException e) {
                    System.out.println("\tERROR: TAMANO DEL VECTOR NEGATIVO");
            }
    return resp;
    }

    public int [][] inversa(int matriz[][], int determinate)
    {
        int[][] inversa = new int[matriz.length][matriz.length];
            for(int i=0; i<matriz.length; i++)
            {
                for(int j=0; j<matriz.length; j++)
                {
                    inversa[i][j] = ObtenerMod(matriz[i][j]*determinate);
                }
            }
            return inversa;
    }

    public int [][] generadordematrices()
    {
        int matriz[][]=new int[3][3];
        for(int i=0; i<matriz.length; i++)
        {
            for(int j=0; j<matriz.length; j++)
            {
                //en construccion
                matriz[i][j] = (int) Math.floor(Math.random()*(1-100)+99);
            }
        }
        return matriz;
    }

    public void GuardarIma(BufferedImage bi) throws IOException
    {
        JFileChooser fc = new JFileChooser();
        fc.addChoosableFileFilter(new FileNameExtensionFilter("todos los archivos *.png", "png", "PNG"));
        int elegido = fc.showSaveDialog(null);

        try{
            if(elegido == JFileChooser.APPROVE_OPTION)
            {
                File output = fc.getSelectedFile();
                String ubicacion = output.getAbsolutePath();
                if(!(ubicacion.endsWith(".png")))
                {
                    File g = new File(ubicacion+".png");
                    output.renameTo(g);
                    System.out.println(output.getAbsolutePath());
                    ImageIO.write(bi, "png", new File(ubicacion));
                }

            }
        }
        catch(Exception e)
        {
            System.out.println("no se guardo");
        }
    }
}