9. cvičení

package cv9;
 
import java.util.Scanner;
 
public class Priklad1 {
 
    public static void main(String[] args) {
        //Pole s textem jednotlivych polozek menu
        String[] menu = {"Konec", "Volba A", "Volba B", "Volba C", "Volba D"};
 
        int volba;
 
        //Hlavni cyklus pro komunikaci s uzivatelem
        do {
            switch (volba = zvol(menu)) {
                case -1:
                    System.out.println("Neslo nic zvolit!");
                    break;
                default:
                    System.out.println("Platna volba " + volba + ".\n");
            }
        } while (volba != 0);
 
    }
 
    //Metoda pro komunikaci s uzivatelem
    private static int zvol(String[] menu) {
 
        //Kontrola vstupu
        if (menu == null || menu.length < 1) {
            return -1;
        }
 
        Scanner vstup = new Scanner(System.in);
        int volba;
 
        //Smycka pro zadani platne volby
        do {
            System.out.println("MENU\n----");
            for (int i = 0; i < menu.length; i++) {
                System.out.println(i + ": " + menu[i]);
            }
            System.out.print("Zadej cislo volby (0 - " + (menu.length - 1) + "): ");
            volba = vstup.nextInt();
        } while (volba < 0 || volba >= menu.length);
 
        //Potvrzeni volby
        System.out.println("Bylo zvoleno: " + menu[volba]);
 
        return volba;
    }
}

package cv9;
 
import java.util.Arrays;
 
public class Priklad2 {
 
    public static void main(String[] args) {
 
        //Rozdeleni retezce podle regexu
        String[] pole = "aaa,1 bbb. ccc".split("[^\\w]+");
        System.out.println(Arrays.toString(pole));
    }
}

package cv9;
 
public class Priklad4 {
 
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        vypis(a);
        System.out.println("Determinant matice je:" + determinant(a));
    }
 
    public static void vypis(int[][] x) {
        //Osetreni argumentu metody
        if (x == null) {
            System.err.println("Chybny argument!");
            return;
        }
 
        for (int r = 0; r < x.length; r++) {
            for (int s = 0; s < x[0].length; s++) {
                System.out.print(x[r][s] + "\t");
            }
            System.out.println();
        }
    }
 
    //Vypocet determinantu matice 3x3
    public static int determinant(int[][] x) {
        //Osetreni argumentu metody
        if (x == null) {
            System.err.println("Chybny argument!");
            return 0;
        }
 
        //vypocet pomoci Sarrusova pravidla
        int pom1 = 0, pom2, pom3;
        for (int s = 0; s < x[0].length; s++) {
            pom2 = 1;
            pom3 = 1;
            for (int r = 0; r < x.length; r++) {
                pom2 *= x[r][(s + r) % x[0].length];
                pom3 *= x[r][(s - r + x[0].length) % x[0].length];
            }
            pom1 += pom2 - pom3;
        }
 
        return pom1;
    }
}

package cv10;
 
import java.util.Arrays;
 
public class Priklad8 {
 
    private static boolean jeObdelnikova;
 
    public static void main(String[] args) {
        double[][] m = {{-2, 2, -3}, {-1, 1, 3}, {2, 0, -1}};
        System.out.println("Puvodni matice:");
        vypis(m);
        double[][] mT = transponuj(m);
        System.out.println("Transponovana matice:");
        vypis(mT);
    }
 
    //metoda pro formatovany vypis matice
    public static void vypis(double[][] m) {
        if (m == null) {
            return;
        }
        for (int r = 0; r < m.length; r++) {
            if (m[r] != null) {
                System.out.println(Arrays.toString(m[r]));
            }
        }
    }
 
    public static double[][] transponuj(double[][] m) {
        //kontrola, zda pole je obdelnikove
        if (!jeObdelnikova(m)) {
            System.err.println("Vstupni pole neni obdelnikove!");
            return null;
        }
 
        //vytvorime nove pole spravne velikosti pro transponovanou matici
        double[][] mT = new double[m[0].length][m.length];
 
        //vyplnime prislusnymi hodnotami
        for (int r = 0; r < mT.length; r++) {
            for (int s = 0; s < mT[0].length; s++) {
                mT[r][s] = m[s][r];
            }
        }
 
        //vratime odkaz na transponovanou matici
        return mT;
    }
 
    //pomocna metoda pro zjisteni obdelnikovosti pole
    private static boolean jeObdelnikova(double[][] m) {
        //existuje m?
        if (m == null) {
            return false;
        }
 
        //existuji vsechny radky a jsou stejne dlouhe?
        for (int r = 0; r < m.length; r++) {
            if (m[r] == null || m[0].length != m[r].length) {
                return false;
            }
        }
 
        //kdyz jsme dosli az sem, musi byt m obdelnikova
        return true;
    }
}

package cv10;
 
import java.util.Arrays;
 
public class Priklad7 {
 
    public static void main(String[] args) {
        double[][] m = {{-2, 2, -3}, {-1, 1, 3}, {2, 0, -1}};
        vypis(m);
        System.out.println("Determinant je " + determinant(m));
    }
 
    //"obalova" metoda pro vypocet determinantu - kontroluje ctvercovost matice
    public static double determinant(double[][] m) {
        if (jeCtvercova(m)) {
            return det(m);
        } else {
            System.err.println("Determinant nelze vypocitat!");
            return Double.NaN;
        }
 
    }
 
    private static boolean jeCtvercova(double[][] m) {
        //existuje m?
        if(m == null) return false;
 
        //existuji vsechny radky a jsou stejne dlouhe jako je pocet radku?
        for (int r = 0; r < m.length; r++) {
            if (m[r] == null || m.length != m[r].length) {
                return false;
            }
        }
 
        //kdyz jsme dosli az sem, musi byt m ctvercova
        return true;
    }
 
    //metoda pro vlastni vypocet determinantu
    private static double det(double[][] m) {
        double det = 0;
 
        //podle radu matice rozvetvime vypocet
        if (m.length > 2) {
            for (int i = 0; i < m.length; i++) {
                //pro treti a vyssi rad pocitame rozvoj podle prvniho radku
                det += m[0][i] * det(subMatice(m, 0, i)) * Math.pow(-1, i);
            }
        } else if (m.length == 2) {
            //pro druhy rad spocteme determinant rovnou 
            det = m[0][0] * m[1][1] - m[0][1] * m[1][0];
        } else {
            //pro rad jedna vratime hodnotu jedineho prvku
            det = m[0][0];
        }
        return det;
    }
 
    //pomocna metoda pro vytvareni submatic eliminovanim radku a sloupce
    private static double[][] subMatice(double[][] m, int elimR, int elimS) {
        double[][] v = new double[m.length - 1][m[0].length - 1];
        int k = 0, l = 0;
        for (int r = 0; r < m.length; r++) {
            if (r != elimR) {
                for (int s = 0; s < m[0].length; s++) {
                    if (s != elimS) {
                        v[k][l++] = m[r][s];
                    }
                }
                l = 0;
                k++;
            }
        }
        return v;
    }
 
    //metoda pro formatovany vypis matice
    public static void vypis(double[][] m) {
        for (int r = 0; r < m.length; r++) {
            System.out.println(Arrays.toString(m[r]));
        }
    }
}

package obrazek;
 
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
 
public class Priklad1 {
 
    public static void main(String[] args) throws IOException {
 
        //nacteni obrazku ze souboru - pri spusteni z NB musi byt obrazek v adresari projektu
        BufferedImage obr;
        obr = ImageIO.read(new File("new_york.jpg"));
 
        int[][] pole1, pole2, pole3;
        pole1 = nactiPole(obr);
        pole2 = vytvorBWObraz(pole1);
        pole3 = prevratObraz(pole2);
        zapisPole(obr, pole3);
 
        //zapsani obrazku do souboru
        ImageIO.write(obr, "jpg", new File("new_new_york.jpg"));
    }
 
    //precte obrazove body z obrazku a vrati je v poli int jako RGB (po osmi bitech na zacatku vyplneno 0xFF000000)
    public static int[][] nactiPole(BufferedImage obr) {
        int sirka = obr.getWidth();
        int vyska = obr.getHeight();
 
        int[][] pole = new int[sirka][vyska];
 
        for (int x = 0; x < sirka; x++) {
            for (int y = 0; y < vyska; y++) {
                pole[x][y] = obr.getRGB(x, y);
            }
        }
 
        return pole;
    }
 
    //uprava obrazu - zatim predpokladan obrazek v odstinech sede
    public static int[][] vytvorBWObraz(int[][] vstupniPole) {
        //konstanty
        final int MASKA_B = 0x000000FF, VYPLN = 0xFF000000;
        final int PRAH = 126, MAX = 255, MIN = 0;
 
        int sirka = vstupniPole.length;
        int vyska = vstupniPole[0].length;
        int[][] vystupniPole = new int[sirka][vyska];
 
        int pixel;
 
        for (int x = 0; x < sirka; x++) {
            for (int y = 0; y < vyska; y++) {
                pixel = MASKA_B & vstupniPole[x][y];
                pixel = pixel > PRAH ? MAX : MIN;
                vystupniPole[x][y] = VYPLN | (pixel | pixel << 8 | pixel << 16);
            }
        }
 
        return vystupniPole;
    }
 
    //zapise pole do obrazku
    public static void zapisPole(BufferedImage obr, int[][] pole) {
        for (int x = 0; x < pole.length; x++) {
            for (int y = 0; y < pole[0].length; y++) {
                obr.setRGB(x, y, pole[x][y]);
            }
        }
    }
 
    //prevraci obraz stranove
    public static int[][] prevratObraz(int[][] vstupniPole) {
        int sirka = vstupniPole.length;
        int vyska = vstupniPole[0].length;
        int[][] vystupniPole = new int[sirka][vyska];
 
        for (int x = 0; x < sirka; x++) {
            for (int y = 0; y < vyska; y++) {
                vystupniPole[x][y] = vstupniPole[sirka - x - 1][y];
            }
        }
 
        return vystupniPole;
    }
}

Testovací obrázek:

Výstupní obrázek: