Avatar
Tomhaus
Člen
Avatar
Tomhaus:

Ahojky lidi, mam jeden problém s 2D polem. Píše mi to že indexuju mimo pole, ale podle mě ty čísla sedí přesně.
Asi hodinu sem na to koukal a pořád sem na to nepřišel.

package Matrix;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import javax.swing.JPanel;

public class Screen extends JPanel {
        private static final long serialVersionUID = 1L;

        private static final int WIDTH = 630, HEIGHT = 320;

        private Font font1, font2;

        private int Ubits;
        private int ContChar;
        private int GWidth = ContChar + Ubits;

        private final ArrayList<GNumbers> values = new ArrayList<GNumbers>();
        private GNumbers[][] coors;

        private Color colorBack = new Color(0x919191);
        private Color colorVBorder = new Color(0x61FF61);
        private Color colorUBorder = new Color(0x5656FF);
        //private Color colorGBorder = new Color(0xFF4040);

        public Screen(){
                setFocusable(true);
                setPreferredSize(new Dimension(WIDTH, HEIGHT));



        }

        public void setUbits(int Ubits){
                this.Ubits = Ubits;
        }

        public void setContChar(int ContChar){
                this.ContChar = ContChar;
        }

        public void del(){
                values.clear();
        }

        public void fill(){
                coors = new GNumbers[Ubits][Ubits];
                System.out.println(Ubits);

                for(int i = 0; i <= Ubits; i++){
                        for(int j = 0; j <= Ubits; j++){
                                values.add(new GNumbers(100 + i * 20, 100 + j * 20, 0));
                        }
                }


                int index = 0;
                for(int x = 0; x <= Ubits; x++){
                        for(int y = 0; y <= Ubits; y++){
                                        coors[x][y] = values.get(index);
                                        int value = coors[x][y].getValue();
                                        int xPos = coors[x][y].getxCoor();
                                        int yPos = coors[x][y].getyCoor();
                                        System.out.println("Na index: [" + x + "][" + y + "] vkládám: " + xPos + " " + yPos + " " + value);

                                        index++;
                        }
                        if(index == values.size()){
                                break;
                        }
                }
        }

        public void paint(Graphics g){
                //základní tabulka pro 4x1 (4-bit) matici U a 6x4 matici G => 6x1 matice V
                //šířka a výška rámenčku (políčka matice) 30px
                //mezera mezi maticemi 10px

                g.setColor(colorBack);
                g.fillRect(0, 0, WIDTH, HEIGHT);

                font1 = new Font("Arial", Font.PLAIN, 24);
                font2 = new Font("Adobe Arabic", Font.PLAIN, 18);

                //m = posun matice U kvůli zvětšující se velikosti matice V
                int m = GWidth;
                if(GWidth >= 6){
                        m++;
                }else if(GWidth < 6){
                        m = GWidth + 1;
                }

                g.setFont(font2);
                g.setColor(Color.BLUE);
                g.drawString("G", 495 - (GWidth - 6) * 15, 118 - (Ubits - 4) * 30);
                g.drawString("U", (335 - (Ubits - 4) * 15) - (m - 7) * 30, 310);
                g.drawString("V", 495 - (GWidth - 6) * 15, 310);


                g.setColor(Color.BLACK);

                g.setFont(font1);
                /*
                // 1 -> G
                for(int i = 0; i <= 3; i++){
                        g.drawString("1", 424 + i * 30, 149 + i * 30);
                }
                // 0 -> G
                for(int i = 0; i <= 3; i++){
                        for(int j = 0; j <= 3; j++){
                                if(i != j){
                                        //(i != 0 || j != 0) && (i != 1 || j != 1) && (i != 2 || j != 2) && (i != 3 || j != 3)
                                        g.drawString("0", 424 + i * 30, 149 + j * 30);
                                }
                        }
                }
                */


                for(int i = 0; i <= Ubits; i++){
                        for(int j = 0; j <= Ubits; j++){
                                try {
                                        g.drawString(Integer.toString(coors[i][j].getValue()), coors[i][j].getxCoor(), coors[i][j].getyCoor());
                                } catch (Exception e) {
                                        PrintWriter pw = null;
                                        try {
                                                pw = new PrintWriter(new FileOutputStream("Log"));
                                        } catch (FileNotFoundException e1) {
                                                // TODO Auto-generated catch block
                                                e1.printStackTrace();
                                        }
                                    e.printStackTrace(pw);
                                }
                        }
                }

                if(Ubits > GWidth - ContChar){
                        GWidth++;
                }
                if(Ubits < GWidth - ContChar){
                        GWidth--;
                }


                //matice V
                for(int l = 0; l <= GWidth; l++){
                        //svisle V
                        for(int i = 0; i <= l; i++){
                                g.drawLine((415 + i *30) - (l - 6) * 30, 255, (415 + i * 30) - (l - 6) * 30, 285);
                        }
                        //vodorovně V
                        for(int i = 255; i <= 285; i += 30){
                                g.drawLine(415 - (l - 6) * 30, i, 595, i);
                        }
                }


                //matice U
                for(int k = 0; k <= Ubits; k++){
                        //svisle U
                        for(int i = 0; i <= k; i++){
                                g.drawLine(((285 + i * 30) - (k - 4) * 30) - (m - 7) * 30, 255, ((285 + i * 30) - (k - 4) * 30) - (m - 7) * 30, 285);
                        }
                        //vodorovně U
                        for(int i = 0; i <= 1; i++){
                                g.drawLine((285 - (k - 4) * 30) - (m - 7) * 30, 255 + i * 30, 405 - (m - 7) * 30, 255 + i * 30);
                        }
                }


                //matice G
                for(int k = 0; k <= Ubits; k++){
                        for(int l = 0; l <= GWidth; l++){
                                //svisle G
                                for(int i = 0; i <= l; i++){
                                        g.drawLine((415 + i * 30) - (l - 6) * 30, 125 - (k - 4) * 30, (415 + i * 30) - (l - 6) * 30, 245);
                                }
                                //vodorovně G
                                for(int i = 0; i <= k; i++){
                                        g.drawLine(415 - (l - 6) * 30, (125 + i * 30) - (k - 4) * 30, 595, (125 + i * 30) - (k - 4) * 30);
                                }
                        }
                }


                //rámeček V
                g.setColor(colorVBorder);
                g.drawRect(414 - (GWidth - 6) * 30, 254, 182 + (GWidth - 6) * 30, 32);

                //rámeček U
                g.setColor(colorUBorder);
                g.drawRect((284 - (Ubits - 4) * 30) - (m - 7) * 30, 254, 122 + (Ubits - 4) * 30, 32);
                /*
                if(ContChar != 0){
                        //rámeček G
                        g.setColor(colorGBorder);
                        //g.drawRect(414, 124, 182, 122);
                        g.drawRect(564 - (ContChar - 1) * 30, 184 - (Ubits - 2) * 30, 32 + (ContChar - 1) * 30, 62 + (Ubits - 2) * 30);
                }
                */
                repaint();
        }
}

Když k tomu poli coors přidam k té proměnné + 1 (k oběma rozměrům), tak to tu chybu nevykazuje, ale já nechci mít to pole větší o 1 než tu proměnnou.
Kde je teda ta chyba?

Editováno 15.12.2014 20:58
Odpovědět 15.12.2014 20:55
Být lepší a chytřejší je důležité, ale někdy se musíme spokojit s tím, co máme.
Avatar
tomisoka
Redaktor
Avatar
Odpovídá na Tomhaus
tomisoka:
for(int x = 0; x <= Ubits; x++){

tento cyklus ti dá největší x = Ubits. Zatímco pole coors má největší index = Ubits-1.

 
Nahoru Odpovědět 15.12.2014 21:01
Avatar
Tomhaus
Člen
Avatar
Odpovídá na Tomhaus
Tomhaus:

tak nic přišel sem na to sám, stačilo smazat ty = u těch for loopů :)

Nahoru Odpovědět 15.12.2014 21:11
Být lepší a chytřejší je důležité, ale někdy se musíme spokojit s tím, co máme.
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 3 zpráv z 3.