jasu's blog

AScodeViewer 1.0 Beta

개인적으로 플래시 코드를 웹상에 올릴 때 하이라이트를 적용하여 편하게 보기 위해서 만들었다. 만들다 보니 플래시 코드뿐만 아니라 다른 코드의 경우도 xml 파일을 수정하는 것으로 적용할 수 있다.

기능적인 요소
기능적인 요소로는 swf에 외부 변수값(코드파일url, 라이라이트 xml, 스타일 xml, selectable) 값을 전달하여 불러들인 xml과 코드, 그리고 코드를 선택 및 복사가 가능하도록 할 것인지를 지정하는 sable 값을 전달하게 된다. 이로서 AScodeViewer.swf 파일에서 코드 하이라이트 및 스타일이 적용된 AScodeViewer를 볼 수 있다.

외부 변수 값을 전달할 때 주의할 점은 크로스도메인 정책에 따라 도메인이 다른 url 경로에 있는 코드나 xml를 불러올 수 없다는 것이다. AScodeViewer.swf 파일이 있는 위치와 같은 도메인 상에 있는 파일을 불러들여야 한다.

사용성에 따른 기능적인 요소로는 오른쪽 하단에 보면 FullScreen mode로 전환할 수 있는 버튼이 있다. 클릭을 할 경우 전체 풀사이즈 화면으로 코드를 볼 수 있는 기능이다.

사용 방법
AScodeViewer을 사용하는 방법은 아래 제공하는 파일을 다운 받아서 사용하고자 하는 계정에 업로드를 하고 아래와 같이 코드를 웹페이지 html상에 넣어주면 된다.

<object width="700" height="400" >
<param name="bgcolor" value="#242424" />
<param name="allowFullScreen" value="true" />
<param name="FlashVars" value="code=TintColor.as&format=as3.xml&style=style_dark.xml&sable=true" />
<param name="movie" value="AScodeViewer.swf" />
<embed src=" AScodeViewer.swf"  flashvars="code=TintColor.as&format=as3.xml&style=style_dark.xml&sable=true" type="application/x-shockwave-flash" allowFullScreen="true" width="700" height="400" bgcolor="#242424" /></embed>
</object>

위에서 보이는 바와 같이 FlashVar에 해당하는 부분의 변수들에 각각의 파일 및 설정 값을 넣어주면 된다. 위 코드의 경우는 swf파일이 있는 같은 폴더 안에 code, format, style 에 해당하는 파일들이 있는 것으로 가정한 것이다.

하이라이트 및 스킨 적용 방법
코드 하이라이트는 플래시 스크립트 에디터로 많이 사용하고 있는 FlashDevelop 프로그램의 language폴더에 있는 xml 데이터를 그대로 사용하였다. FlashDevelop 프로그램을 사용하는 분은 아래 경로에서 사용하고 있는 하이라이트 xml 파일을 취득할 수 있다.

C:\Program Files\FlashDevelop\FirstRun\Settings\Languages

위 경로에서 보면 AS3.xml, AS2.xml, Jscript.xml 등을 볼 수 있는데 AScodeViewer 1.0 Beta에서 지원하는 xml 형태는 AS3.xml, AS2.xml, Jscript.xml, HaXe.xml 이다. 다른 C++ 이나 Java 등의 코드 하이라이트를 사용할 경우에는 위 4개의 파일 중에 아무 파일이나 열어서 해당 언어에서 사용하는 하이라이트 단어들을 등록하고 다른 이름으로 저장하여 사용하면 된다.

AScodeViewer의 스킨 적용은 제공하는 Style_dark.xml 파일이나 style_light.xml 파일을 열어서 해당 부분의 RGB 색상을 변경하여 스킨을 바꿀 수 있다. 아래 이미지를 보면 style.xml 파일에서 지정할 수 있는 부분들을 표시해 놓았다.

아래는 파일로 제공하는 두 가지 스킨을 적용한 예이다. Style_dark.xml 이나 style_light.xml 파일을 수정하여 원하는 색상을 만들어 낼 수 있기 때문에 적용하는 페이지상의 디자인에 맞게 수정하여 사용하면 된다.
왼쪽은 style_dark.xml을 적용한 예이고 오른쪽은 style_light.xml을 적용한 예이다. 왼쪽의 경우 코드 선택이 안되도록 sable = false 값을 적용하였다.

아래 파일을 다운로드 하여 위에서 설명한 대로 원하는 페이지에 적용하면 된다. 블로그 서비스에서는 “외부 멀티미디”어 등에서 youtube 동영상을 임베드 하는 형태로 적용하면 된다. 주의할 점은 위에서 언급한 바와 같이 AScodeViewer.swf 파일이 있는 곳과 불러오는 파일들의 도메인이 같아야 한다는 것이다(같은 도메인 내의 폴더 구분은 상관없다.)

앞으로 버전업의 경우도 FlashDevelop의 기능을 적용할 생각이다. 시간이 허락하는 대로 업데이트 버전을 올려 놓도록 하겠다. 사용하다가 문제점이 있거나 버그 발견 시에는 아래에 댓글로 남겨주시면 많은 도움이 될 것 같다.

AScodeViewer1_0Beta.zip

Collide 이벤트를 가지고 형광등을 표현해 봤다. 형광등의 진공 유리관에도 collide 이벤트를 적용하려고 했었는데 SpringConstraint에서 이벤트 반응을 하지 않는다. 구조상으로는 SpringConstraint -> AbstractConstraint -> AbstractItem -> EventDispatcher 와 같은 상속관계를 갖고 있음에도 이벤트에 반응하지 않는 것이 좀 이상하다.

일단은 진공관에 대한 이벤트 반응과 collidable을 false로 해 놓았다.

기존에 만들었던 APE의 UML에서 Association 표기가 없었던 것을 추가하고 기존에 잘못 되었던 부분을 수정했다. 클래스 소스를 기준으로 작성된 class diagram이므로 정확하지 않을 수 있지만 대체적으로 package를 분석하는데 도움이 될 것 같다.

아래 풀사이즈 jpg이미지와 플래시로 만들어 놓은 파일을 올려놓는다.  

UIClab.zip

Flickr의 Open API를 이용한 사진 검색 어플리케이션 'FlickrSearcher'
version 1.8

http://dicaland.cafe24.com/flickr/FlickrSearcher1_8.swf
====================================================================================================

FlickrSearcher1_8.exe

이 구조를 넣으면서 여러가지 문제점이 생겼는데 문제점들은 아래와 같다.

1. 자바스크립트에서 플래시로 값을 넘겨주기 위해서는 플래시에서 ExternalInterface 클래스를 사용하게 된다. 이 클래스를 이용하면 html에 삽입된 javascript와 플래시간 상호 지정한 function을 호출할 수 있으며 return값도 전달 할 수 있다.
하지만 배경 화면에 해당하는 플래시에서 티스토리 스킨에 제공하고 있는 skin.html안에 삽입된 자바스크립트를 호출하는 것은 가능하나 그 자바스크립트에서 플래시로 값을 넘겨주지 못하는 문제점이 있다. 아마도 크로스 도메인 문제인 듯 싶다.

하루정도 고민 하다가 결국은 우회하기로 결정했다. 일단 하단에 있는 메뉴플래시에서 infinite 버튼을 클릭할 시에 상위에 있는 레이어를 display = block을 적용하고 플래시의 LocalConnection을 이용하여 레이어 안에 있는 플래시와 통신을 하는 방법이다.
여기도 또다시 문제점이 발생했는데 하위 플래시에서 레이어를 살리는 동시에 상위 플래시와 통신을 할 경우에는 기존에 있던 플래시가 포함된 레이어가 작동을 정지하면서 제대로 호출해주지 않는 문제가 발생했다. Display를 대신해 visibility을 이용해 보았지만 마찮가지였다.

상위 레이어가 살아났을 때 플래시에 레이어가 나타났다는 메시지를 전달함으로써 infinite의 초기 시작 모션을 적용해야 하는데 그 문제가 해결되지 않아서 발생하는 문제점이다.

익스플로러와 파이어폭스 두 브라우저에서 테스트해본 결과 두 브라우저 간의 약간의 차이가 발생했다.

그래서 LocalConnection으로 플래시간 통신을 하되 약간은 딜레이 타임을 적용하기로 하고 레이어를 살리고 초기 시작 모션들 들어가기 전에 0.5초간 로딩바를 보여주는 형태로 LocalConnection의 문제점을 해결했다. 사실 해결이라기보다는 궁여지책이다.

W3C에서 권장하는 표준형은 document.getElementById("ID").style.display 이러한 형태로 접근하는 것이다.

3. 세번째 문제는 티스토리에 로그인한 상태에서 블로그에 접근했을 때는 오른쪽 상단에 티스토리 툴바가 보이게 된다.  테스트 과정에서 레이어의 index값을 아무리 올려도 상위에 있는 레이어보다 티스토리 툴바가 상위에 떠있는 것이다. 그래서 블로그 소스를 뒤져보니 상위에 뜨는 툴바의 index값이 무려 1000000라는 사실… 그래서 상위에 뜨는 레이어의 index 값을 1000001로 잡아서 해결했다.

4. 네번째는 문제라기 보다는 레이어를 올리는 과정에서 생겨난 부가적인 노동이다. 블로그에서 음악이 흘러나오도록 play를 시켜놓은 상태에서 infinite 페이지로 들어갔을 때는 끄고, play되고 있던 사용자라면 다시 나올 때 play를 시켜주는 것이다. 그리고 음악을 듣지 않고 있던 사용자라면 그대로 음악이 흘러나오지 않는 기능을 추가해야 했다. 그리고 블로그의 배경에서 랜덤으로 생겨나는 나비의 움직임이 infinite 페이지를 접근했을 때에 불필요하게 CPU의 낭비를 가져오고 있어서 infinite메뉴로 들어갔을 때는 나비들이 생성하지 않도록 interval을 clear시켜주고 다시 블로그로 나갔을 때는 생성하도록 설정해 놓았다.

Infinite메뉴를 추가하면서 가장 큰 문제는 자바스크립트에서 플래시로 통신하기가 어렵다는 것이 가장 큰 문제였던 것 같다. 일단 지금은 LocalConnection을 이용하여 플래시 간에 주거니 받거니 하고 있으니 나중에 알게 되면 수정해야 겠다.

invalid-file

프로젝트 프리젠테이션

invalid-file

게임 인스톨 파일

SOURCE CODE <- click
less..
  
 import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.swing.*;
import javax.swing.border.*;
import sun.audio.*;
import java.io.*;
import java.util.*;
import java.applet.*;
public final class ImagePuzzle extends Frame implements ItemListener{
        ImagePuzzle imagepuzzle;
        JPanel p_main,p_board;
        jpanel p[];
        JPanel p_center;
        P_up p_up;
        File file;
        File dir;
        ImageSam_1 image_rect;
        P_down p_down;
        P_west p_west;
        P_east p_east;
        final String col[]={"Rank","Name","Score"};
        String data[][];
        String user_name;
        Best_Record br;
        Tab_3 tab3;
        Tab_5 tab5;
        Tab_7 tab7;
        Tab_9 tab9;
        Remove_Check remove_check;
        Image_state button_set1_image;
        int point_count;
        Image_Setting open;
        int i_font=1;
        java.awt.List list1,list2;
        String file_name;
        String file_name_ready;
        String item;
        String list[];
        String list_list[];
        int list_count;
        TextField file_textfield;
        Color cc142;
        JButton start_button;
        JButton next_button;
        jpanel pp;
        boolean box;
        String str;
        String path_root;
        static CheckboxMenuItem sound_check;
        static CheckboxMenuItem number_check;

        Choice root_choice,dir_choice;
        User user_view;
        InputStream in_back;
        InputStream in_replay;
        InputStream in_start;
        JTextField display_file;				//오른쪽 위에 나오는 그림 이미지 파일 이름 표시
        About about;

        AudioStream sound_back;
        AudioStream sound_replay;
        AudioStream sound_start;

        static boolean num_check;
        Image state_back_ground;
        ImageSam image_sam;    				//비교할 이미지 샘플사진 판넬

        Image sample;
        JLabel Title;
        state p_state;
        Image image_state;

        Color color=new Color(204,204,204);
        int check[];
        static int block_check=9;Color c;
        int intcheck=0,isize=0,jsize=0;

        actionhandler ahandler;
        BevelBorder bevelborder;
        EtchedBorder etchborder;
        Key_handler key_event;
        ImagePuzzle(String name,CheckboxMenuItem sound_check,String file_name,int list_count,String path_root,String user_name){
                super(name);

                this.file_name=file_name;
                this.list_count=list_count;
                this.path_root=path_root;
                data=new String[9][3];
                for(int i=1;i<=9;i++)
                data[i-1][0]="No "+i;
                this.user_name=user_name;
                user_view=new User("User name");
                point_count=0;

                tab3=new Tab_3();

                image_state=Toolkit.getDefaultToolkit().getImage(file_name);
                key_event=new Key_handler();
                addKeyListener(key_event);

                cc142=new Color(142,142,142);

                list1 = new java.awt.List(2, false);
                list2 = new java.awt.List(2, false);

                sound_set();

                read("score/tab3.ser");
                tab3.tab3_proc();
                start_button=new JButton("Start");
                next_button=new JButton("Next");
                next_button.addActionListener(new actionhandler_button());
                start_button.addActionListener(new actionhandler_button());

                start_button.setVisible(true);

                num_check=false;
                image_sam=new ImageSam();

                image_sam.setSize(250,250);
                bevelborder=new BevelBorder(BevelBorder.RAISED);
                etchborder=new EtchedBorder(EtchedBorder.RAISED);
                ahandler=new actionhandler();
                Title=new JLabel("=====================");
                Title.setBackground(new Color(204,204,204));
                MenuBar mb=new MenuBar();

                Menu gameMenu=new Menu("Game");
                itemAdd("New Game",gameMenu);
                gameMenu.addSeparator();


                itemAdd("Best Record",gameMenu);
                gameMenu.addSeparator();
                itemAdd("Record Remove",gameMenu);
                itemAdd("Exit",gameMenu);

                Menu optionMenu=new Menu("Option");
                Menu matrixMenu=new Menu("Matrix");
                optionMenu.add(matrixMenu);

                itemAdd("3 X 3",matrixMenu);
                itemAdd("4 X 4",matrixMenu);
                itemAdd("5 X 5",matrixMenu);
                itemAdd("6 X 6",matrixMenu);
                itemAdd("7 X 7",matrixMenu);
                itemAdd("8 X 8",matrixMenu);
                itemAdd("9 X 9",matrixMenu);

                optionMenu.addSeparator();
                this.sound_check=sound_check;
                optionMenu.add(sound_check);
                number_check=new CheckboxMenuItem("Number");
                optionMenu.add(number_check);
                optionMenu.addSeparator();

                itemAdd("User Change",optionMenu);
                itemAdd("Image Setting",optionMenu);

                Menu helpMenu=new Menu("Help");

                MenuItem mi=new MenuItem("Homepage...");
                mi.addActionListener(new homepage_actionhandler());
                helpMenu.add(mi);
                helpMenu.addSeparator();
                itemAdd("About Image...",helpMenu);

                Color block_color=new Color(92,112,139);

                mb.add(gameMenu);
                mb.add(optionMenu);
                mb.add(helpMenu);
                setMenuBar(mb);

                p_up=new P_up();
                p_down=new P_down();                       //메인 화면에서의 테두리
                p_east=new P_east();
                p_west=new P_west();
                p_up.setBackground(block_color);
                p_down.setBackground(block_color);
                p_east.setBackground(block_color);
                p_west.setBackground(block_color);

                p_center=new JPanel();
                p_center.setSize(550,400);
                p_board=new JPanel();
                p_main=new JPanel();
                p_state=new state();

                p_state.setSize(150,400);                 //p_state 는 오른쪽 샘플 그림과 아하 버튼
                p_state.setLayout(new GridLayout(3,2));
                p_state.add(image_sam);

                display_file=new JTextField(20);
                display_file.setEnabled(false);

                JPanel button_set1=new JPanel();
                JPanel button_set2=new JPanel();

                button_set1.setLayout(new BorderLayout());
                button_set1.setBorder(bevelborder);
                button_set2.setLayout(new BorderLayout());

                button_set1_image=new Image_state("background/state.jpg");
                Panel button_set1_button=new Panel();
                Panel button_set1_uplabel=new Panel();
                button_set1_image.setSize(200,200);
                button_set1_button.setLayout(new GridLayout(1,2));

                button_set1.add(start_button);
                button_set1.add(next_button);					//button_set1 은 가운데 판넬

                button_set1_uplabel.add(display_file);
                button_set1_button.add(start_button);
                button_set1_button.add(next_button);

                button_set1.add(button_set1_uplabel,BorderLayout.NORTH);
                button_set1.add(button_set1_image,BorderLayout.CENTER);
                button_set2.add(button_set1_button,BorderLayout.NORTH);

                p_state.add(button_set1);
                p_state.add(button_set2);

                number_check.addItemListener(this);

                p_main.setBorder(bevelborder);
                check=new int[block_check];
                p=new jpanel[block_check];

                p_board.setLayout(new BorderLayout());
                p_board.add(p_main,BorderLayout.CENTER);
                p_center.setLayout(new BorderLayout());
                p_center.add(p_board,BorderLayout.CENTER);
                p_center.add(p_state,BorderLayout.EAST);

                add(p_up,BorderLayout.NORTH);
                add(p_center,BorderLayout.CENTER);
                add(p_down,BorderLayout.SOUTH);
                add(p_west,BorderLayout.WEST);
                add(p_east,BorderLayout.EAST);
                addWindowListener(new windowhandler());
                file_find();
                proc();

        }
        public void itemStateChanged(ItemEvent ie){
                for(int i=0;i<block_check;i++)
                p[i].repaint();
        }
        final class Key_handler implements KeyListener{
                public void keyPressed(KeyEvent ke){
                }
                public void keyReleased(KeyEvent ke){
                }
                public void keyTyped(KeyEvent ke){
                }
        }
        public void sound_set(){
                try{
                        in_replay=new FileInputStream("sound/replay.wav");
                        in_start=new FileInputStream("sound/start.wav");

                        sound_back=new AudioStream(in_back);
                        sound_replay=new AudioStream(in_replay);
                        sound_start=new AudioStream(in_start);

                }catch(Exception e){}
        }
        public void proc(){
                try{	in_replay.close();
                        in_replay=new FileInputStream("sound/replay.wav");
                        sound_replay=new AudioStream(in_replay);
                        if(sound_check.getState())
                        AudioPlayer.player.start(sound_replay);

                }catch(Exception e){}
                int k=0;
                int i,j;
                for(i=0;i<check.length;i++)
                check[i]=i;
                check[check.length-1]=check.length-1;
                if(p.length==9){
                        intcheck=3;
                        p_main.setLayout(new GridLayout(3,3));
                        read("score/tab3.ser");
                }else if(p.length==16){
                        intcheck=4;
                        p_main.setLayout(new GridLayout(4,4));
                        read("score/tab4.ser");
                }else if(p.length==25){
                        intcheck=5;
                        p_main.setLayout(new GridLayout(5,5));
                        read("score/tab5.ser");
                }else if(p.length==36){
                        intcheck=6;
                        p_main.setLayout(new GridLayout(6,6));
                        read("score/tab6.ser");
                }else if(p.length==49){
                        intcheck=7;
                        p_main.setLayout(new GridLayout(7,7));
                        read("score/tab7.ser");
                }else if(p.length==64){
                        intcheck=8;
                        p_main.setLayout(new GridLayout(8,8));
                        read("score/tab8.ser");
                }else if(p.length==81){
                        intcheck=9;
                        p_main.setLayout(new GridLayout(9,9));
                        read("score/tab9.ser");
                }
                Color out_side=new Color(203,203,203);
                for(i=0;i<p.length;i++){
                        p[i]=new jpanel(i);
                        if(i<p.length-1)
                        p[i].setBackground(out_side);
                        else p[i].setBackground(color);
                        p[i].addMouseListener(new mousehandler());
                        p_main.add(p[i]);
                }
                for(i=0;i<p.length;i++)
                p[i].setEnabled(false);
                item=file_name;
                replay_proc();
        }
        final class homepage_actionhandler implements ActionListener{
                public void actionPerformed(ActionEvent e) {
                        Runtime run = Runtime.getRuntime();
                        try{
                                run.exec("c:/Program Files/Internet Explorer/Iexplore.exe 										 http://www.n-collection.com");
                        }
                        catch(Exception ioe) {System.out.println(ioe+"Connecting Error.");}
                }
        }
        private void itemAdd(String title,Menu m){
                MenuItem mi=new MenuItem(title);
                mi.addActionListener(ahandler);
                m.add(mi);
        }
        final class state extends JPanel{
                state(){
                }
        }
        final class P_up extends Panel{
        }
        final class P_down extends Panel{
        }
        final class P_west extends Panel{
        }
        final class P_east extends Panel{
        }
        final class ImageSam extends Panel{					// 오른쪽 이미지 그리는 루틴
                public void paint(Graphics g){
                        g.drawImage(
                        image_state,
                        6,
                        7,
                        getWidth()-6,
                        getHeight()-7,
                        0,
                        0,
                        (image_state.getWidth(this)),
                        (image_state.getHeight(this)),
                        this);

                        g.setColor(Color.white);
                        for(int j=0;j<6;j++){
                                g.drawLine(j,j,this.getWidth()-j,j);
                                g.drawLine(j,j,j,this.getHeight()-j);
                        }
                        g.setColor(cc142);
                        for(int j=0;j<7;j++){
                                g.drawLine(this.getWidth()-j,j,this.getWidth()-j,this.getHeight()-j);
                                g.drawLine(j,this.getHeight()-j,this.getWidth()-j,this.getHeight()-j);
                        }
                }
        }
        final class jpanel extends Panel{						//블럭 각각을 그리는 루틴
                private int cont;
                int i;
                public int isize_loc;
                public int jsize_loc;
                Font font;
                Color cc100;
                jpanel(int i){
                        font=new Font("SansSerif",Font.BOLD,17);
                        cc100=new Color(100,100,100);
                        isize_loc=9;
                        jsize_loc=9;
                        this.i=i;
                        this.cont=i_font++;

                }
                public void update(Graphics g){
                        paint(g);
                }
                public void paint(Graphics g){
                        if(isize_loc==9)
                        isize_loc=isize;

                        if((i!=block_check-1)&&(getBackground()!=color)){
                                if(jsize_loc==9)
                                if((isize)%(intcheck)==0){
                                        if(isize!=0){
                                                jsize++;
                                                if(jsize_loc==9)
                                                jsize_loc=jsize;
                                        }
                                        isize_loc=isize=0;
                                        if(jsize_loc==9)
                                        jsize_loc=jsize;
                                        if(isize_loc==9)
                                        isize_loc=0;
                                }
                                if(jsize_loc==9){
                                        jsize_loc=jsize;}
                                g.drawImage(
                                image_state,
                                0,
                                0,
                                getWidth(),
                                getHeight(),
                                (image_state.getWidth(this)/intcheck)*isize_loc,
                                (image_state.getHeight(this)/intcheck)*jsize_loc,
                                (image_state.getWidth(this)/intcheck)*isize_loc+(image_state.getWidth(this)/intcheck),
                                (image_state.getHeight(this)/intcheck)*jsize_loc+(image_state.getHeight(this)/intcheck),
                                this);

                                isize++;

                        }else{ isize=0;jsize=0;}
                        g.setFont(font);
                        if(cont!=block_check)
                        if(number_check.getState()){
                                g.drawString(String.valueOf(cont),(getWidth()/2)-3,(getHeight()/2)+5);

                        }
                        g.setColor(Color.white);

                        for(int j=0;j<1;j++){
                                g.drawLine(j,j,this.getWidth()-j,j);
                                g.drawLine(j,j,j,this.getHeight()-j);
                        }
                        g.setColor(cc100);
                        for(int j=0;j<2;j++){
                                g.drawLine(this.getWidth()-j,j,this.getWidth()-j,this.getHeight()-j);
                                g.drawLine(j,this.getHeight()-j,this.getWidth()-j,this.getHeight()-j);
                        }
                }
        }
        final class actionhandler implements ActionListener{
                public void actionPerformed(ActionEvent ae){
                        MenuItem mi=(MenuItem)ae.getSource();
                        if(mi.getLabel()=="3 X 3"){
                                block_check=9;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="4 X 4"){
                                block_check=16;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="5 X 5"){
                                block_check=25;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="6 X 6"){
                                block_check=36;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="7 X 7"){
                                block_check=49;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="8 X 8"){
                                block_check=64;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }else if(mi.getLabel()=="9 X 9"){
                                block_check=81;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }
                        if(mi.getLabel()=="New Game"){
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }
                        if(mi.getLabel()=="Record Remove"){
                                remove_check=new Remove_Check("Record Remove Check");
                                remove_check.setBounds(300,300,250,200);
                                remove_check.show();
                        }
                        if(mi.getLabel()=="Best Record"){
                                br=new Best_Record("Best Record");
                                br.setBounds(250,260,400,220);
                                br.addWindowListener(new Best_windowhandler());
                                br.show();
                        }
                        if(mi.getLabel()=="Exit"){
                                System.exit(0);
                        }
                        if(mi.getLabel()=="Number"){
                                num_check=true;
                                dispose();
                                System.gc();
                                imagepuzzle=new ImagePuzzle("Image Puzzle",sound_check,file_name,list_count,path_root,user_name);
                                imagepuzzle.setBounds(65,65,900,600);
                                imagepuzzle.show();
                        }
                        if(mi.getLabel()=="User Change"){
                                user_view.view();
                        }
                        if(mi.getLabel()=="Image Setting"){
                                open=new Image_Setting();
                                open.addWindowListener(new Open_windowhandler());
                                open.setBounds(79,118,638,553);
                                open.show();
                        }
                        if (mi.getLabel()=="About Image..."){
                                about=new About("Image Puzzle Info");
                                about.addWindowListener(new About_windowhandler());
                                about.setBounds(300,230,400,300);
                                about.show();
                        }
                }
        }
        final class About_windowhandler extends WindowAdapter
        {
                public void windowClosing(WindowEvent we)
                {
                        about.dispose();
                }
        }
        final class About extends Frame					// About 이미지 그리는 루틴
        {
                About(String name)
                {
                        super(name);

                }
                public void paint(Graphics g){
                        sample=Toolkit.getDefaultToolkit().getImage("background/about.jpg");
                        g.drawImage(
                        sample,
                        0,
                        0,
                        getWidth(),
                        getHeight(),
                        0,
                        0,
                        (sample.getWidth(this)),
                        (sample.getHeight(this)),
                        this);

                        g.setColor(Color.white);
                        for(int j=0;j<5;j++){
                                g.drawLine(j,j,this.getWidth()-j,j);
                                g.drawLine(j,j,j,this.getHeight()-j);
                        }
                        g.setColor(cc142);
                        for(int j=0;j<5;j++){
                                g.drawLine(this.getWidth()-j,j,this.getWidth()-j,this.getHeight()-j);
                                g.drawLine(j,this.getHeight()-j,this.getWidth()-j,this.getHeight()-j);
                        }
                }
        }
final class ImageSam_1 extends Panel{
        //왼쪽 블럭 그림 그리는 루틴
        public void paint(Graphics g){
                sample=Toolkit.getDefaultToolkit().getImage(item);
                g.drawImage(
                sample,
                50,
                60,
                getWidth()-50,
                getHeight()-60,
                0,
                0,
                (sample.getWidth(this)),
                (sample.getHeight(this)),
                this);

                g.setColor(Color.white);
                for(int j=50;j<54;j++){
                        g.drawLine(j,j+5,this.getWidth()-j,j+5);
                        g.drawLine(j,j+5,j,this.getHeight()-j-6);
                }
                g.setColor(cc142);
                for(int j=50;j<54;j++){
                        g.drawLine(this.getWidth()-j,j+5,this.getWidth()-j,this.getHeight()-j-7);
                        g.drawLine(j,this.getHeight()-j-7,this.getWidth()-j,this.getHeight()-j-7);
                }
        }
}
final class Image_state extends Panel{

        Graphics g;
        String item;
        Image_state(String item){
                this.item=item;

        }
        public void paint(Graphics g){
                this.g=g;
                sample=Toolkit.getDefaultToolkit().getImage(item);
                g.drawImage(
                sample,
                0,
                0,
                getWidth(),
                getHeight(),
                0,
                0,
                (sample.getWidth(this)),
                (sample.getHeight(this)),
                this);

                g.setColor(Color.white);
                for(int j=0;j<3;j++){
                        g.drawLine(j,j,this.getWidth()-j,j);
                        g.drawLine(j,j,j,this.getHeight()-j);
                }
                g.setColor(cc142);
                for(int j=0;j<3;j++){
                        g.drawLine(this.getWidth()-j,j,this.getWidth()-j,this.getHeight()-j);
                        g.drawLine(j,this.getHeight()-j,this.getWidth()-j,this.getHeight()-j);
                }
                point();
        }
        public void point(){				// 최대 점수와 사용자 점수를 보여주는 화면
                g.setFont(new Font("SansSerif",Font.PLAIN,22));

                Color back_color=new Color(183,211,186);
                Color font_color=new Color(25,52,118);
                g.setColor(font_color);
                g.drawString(data[0][2],((this.getWidth()/2)-95),(this.getHeight()/2)-20);
                g.drawString(String.valueOf(point_count),((this.getWidth()/2)-95),(this.getHeight()/2)+29);
                g.setColor(back_color);
        }
}
final class list1handler implements ItemListener{				//디렉토리 리스트
        public void itemStateChanged(ItemEvent ie){
                String item=list1.getSelectedItem();
                path_root=(file.getAbsolutePath()+"/"+item);
                list_count=0;
                list1.removeAll();
                list2.removeAll();
                file_textfield.setText("");
                file_find();
        }
}
final class list2handler implements ItemListener{						//파일 리스트
        public void itemStateChanged(ItemEvent ie){

                item=file.getAbsolutePath()+"/"+list2.getSelectedItem();

                list_count=0;
                file_textfield.setText(list2.getSelectedItem());
                file_name_ready=item;

                sample=Toolkit.getDefaultToolkit().getImage(item);
                image_rect.repaint();

        }
}
final class root_choice_handler implements ItemListener{
        public void itemStateChanged(ItemEvent ie){
                if(root_choice.getSelectedItem()=="A:/ 플로피 디스크"){
                        path_root="a:/";
                        file_find();
                }
                if(root_choice.getSelectedItem()=="C:/ 로컬 디스크"){
                        path_root="c:/";
                        file_find();
                }
                if(root_choice.getSelectedItem()=="D:/ 로컬 디스크"){
                        path_root="d:/";
                        file_find();
                }
                if(root_choice.getSelectedItem()=="E:/ 로컬 디스크"){
                        path_root="e:/";
                        file_find();
                }

                list1.removeAll();
                list2.removeAll();
                file_textfield.setText("");
                file_find();
        }
}
final class mousehandler extends MouseAdapter{
        int itemp;
        int count;
        int i,j;

        public void mousePressed(MouseEvent me){
                pp=(jpanel)me.getSource();
                count=0;
                itemp=0;
                i=j=0;

                for(i=0;i<p.length;i++){
                        if(pp.equals(p[i])){
                                c=(Color)p[i].getBackground();
                                break;
                        }
                }
                for(j=0;j<p.length;j++){

                        if(color.equals((Color)p[j].getBackground()))
                        if(j==i-1||j==i+1||j==i+intcheck||j==i-intcheck)
                        if(!(((i%intcheck)==0)&&(j==(i-1))))
                        if(!(((j%intcheck)==0)&&(j==(i+1)))){

                                if(pp.getBackground()!=color){
                                        point_count++;
                                        button_set1_image.repaint();
                                }
                                itemp=check[i];
                                check[i]=check[j];
                                check[j]=itemp;

                                itemp=p[i].jsize_loc;
                                p[i].jsize_loc=p[j].jsize_loc;
                                p[j].jsize_loc=itemp;

                                itemp=p[i].isize_loc;
                                p[i].isize_loc=p[j].isize_loc;
                                p[j].isize_loc=itemp;

                                itemp=p[i].cont;
                                p[i].cont=p[j].cont;
                                p[j].cont=itemp;



                                p[j].setBackground(c);
                                p[i].setBackground(color);

                                p[i].i=block_check-1;
                                p[i].repaint();
                                p[j].i=block_check;
                                p[j].repaint();

                                for(int k=0;k<check.length;k++){
                                        if(check[k]==count) {
                                                count++;

                                        }else {count=0;}
                                }
                                if(count==p.length){						// 답을 얻었을 때
                                        count=0;
                                        try{
                                                InputStream in_winner=new FileInputStream("sound/winner.wav");
                                                AudioStream sound_winner=new AudioStream(in_winner);
                                                if(sound_check.getState())
                                                AudioPlayer.player.start(sound_winner);
                                        }catch(Exception e){}

                                        int level;
                                        for(level=0;level<9;level++)
                                        if(data[level][2]==null) break;
                                        if(level==0){					//처음 자료를 등록할 때

                                                data[level][2]=String.valueOf(point_count);
                                                data[level][1]=user_name;

                                        }else{
                                                for(int z=0;z<=level-1;z++){
                                                        if(Integer.parseInt(data[z][2])>point_count){

                                                                for(int y=level;y>z;y--){				//순위에 따라 레코드를 바꿔줌
                                                                        if(y<=8){
                                                                                data[y][1]=data[y-1][1];
                                                                                data[y][2]=data[y-1][2];
                                                                        }else{
                                                                                data[y-1][1]=data[y-2][1];
                                                                                data[y-1][2]=data[y-2][2];
                                                                        }
                                                                }
                                                                data[z][2]=String.valueOf(point_count);
                                                                data[z][1]=user_name;
                                                                break;


                                                        }else{
                                                                if(level<9){
                                                                        data[level][2]=String.valueOf(point_count);
                                                                        data[level][1]=user_name;
                                                                }
                                                        }
                                                }
                                        }
                                        if(intcheck==3){
                                                write("score/tab3.ser");
                                                read("score/tab3.ser");
                                        }else if(intcheck==4){
                                                write("score/tab4.ser");
                                                read("score/tab4.ser");
                                        }else if(intcheck==5){
                                                write("score/tab5.ser");
                                                read("score/tab5.ser");
                                        }else if(intcheck==6){
                                                write("score/tab6.ser");
                                                read("score/tab6.ser");
                                        }else if(intcheck==7){
                                                write("score/tab7.ser");
                                                read("score/tab7.ser");
                                        }else if(intcheck==8){
                                                write("score/tab8.ser");
                                                read("score/tab8.ser");
                                        }else if(intcheck==9){
                                                write("score/tab9.ser");
                                                read("score/tab9.ser");
                                        }
                                        start_button.setEnabled(true);
                                        next_button.setEnabled(true);

                                        break;

                                }else count=0;
                        }
                }
        }
}
public void write(String f_name){
        try{
                FileOutputStream f_out=new FileOutputStream(f_name);
                ObjectOutputStream objectout=new ObjectOutputStream(f_out);
                objectout.writeObject(data);
                objectout.close();
        }
        catch(Exception e){e.printStackTrace();}
}
public void read(String f_name){
        try{
                FileInputStream f_in=new FileInputStream(f_name);
                ObjectInputStream objectin=new ObjectInputStream(f_in);
                data=(String[][])objectin.readObject();
        }
        catch(Exception e){e.printStackTrace();}
}
final class User extends Frame implements ActionListener{
        TextField user_text;
        JButton user_ok;
        JPanel down;
        user_image image;
        User(String name){
                super(name);
                setLayout(new BorderLayout());
                down=new JPanel();
                user_text=new TextField();
                user_ok=new JButton("OK");
                image=new user_image();
                down.setLayout(new BorderLayout());
                down.add(user_text,BorderLayout.CENTER);
                down.add(user_ok,BorderLayout.EAST);
                add(image,BorderLayout.CENTER);
                add(down,BorderLayout.SOUTH);
                user_ok.addActionListener(this);
                addWindowListener(new user_windowhandler());
                user_ok.addActionListener(this);
        }
        public void actionPerformed(ActionEvent ae){
                JButton ok=(JButton)ae.getSource();
                if(ok.getLabel()=="OK"){
                        user_name=user_text.getText();
                        dispose();
                }
        }
        public void view(){
                setBounds(350,270,300,200);
                show();
        }
        final class user_image extends JPanel{
                user_image(){
                }
                public void paint(Graphics g){
                        sample=Toolkit.getDefaultToolkit().getImage("background/user.jpg");
                        g.drawImage(
                        sample,
                        0,
                        0,
                        getWidth(),
                        getHeight(),
                        0,
                        0,
                        (sample.getWidth(this)),
                        (sample.getHeight(this)),
                        this);

                        g.setColor(Color.white);
                        for(int j=0;j<2;j++){
                                g.drawLine(j,j,this.getWidth()-j,j);
                                g.drawLine(j,j,j,this.getHeight()-j);
                        }
                        g.setColor(cc142);
                        for(int j=0;j<2;j++){
                                g.drawLine(this.getWidth()-j,j,this.getWidth()-j,this.getHeight()-j);
                                g.drawLine(j,this.getHeight()-j,this.getWidth()-j,this.getHeight()-j);
                        }
                }
        }
        final class user_windowhandler extends WindowAdapter{
                public void windowClosing(WindowEvent we){

                        dispose();
                }
        }
}
final class windowhandler extends WindowAdapter{
        public void windowClosing(WindowEvent we){
                System.exit(0);
        }
}
public static void main(String args[]){
        CheckboxMenuItem sound_check=new CheckboxMenuItem("Sound",true);
        String file_name="image/image12.jpg";
        String path_root="image/";
        String user_name="사용자1";

        ImagePuzzle ip=new ImagePuzzle("Image Puzzle",sound_check,file_name,0,path_root,user_name);
        ip.setBackground(Color.blue);
        ip.setBounds(65,65,900,600);
        ip.show();
}
}
less..

구현시 느낌점

※ 이 프로그램에서는 결론부에서 6개의 버튼을 일일이 CLICK해 봄으로써 해당 조건부의 Y값으로 결론부의 범위를 자르게 하였습니다. 이유는 처음에는 조건부의 6개의 버튼중, 또는 비 퍼지값을 임의로 넣었을 때 입력값에 의하여 조건부에 그려짐과 동시에 결론부에도 일괄적인 처리를 통해서 그림을 뿌려지게 하려 하였으나 Paint 메소드가 컴퓨터 내에서 스레드의 형태로 화면에 그림을 뿌려주기 때문에 순차적인 접근으로 일괄적으로 결론부의 그림을 화면에 모두 뿌릴수 없었습니다. 그래서 다소 번거롭지만 각각의 조건부에 해당되는 결론부를 처리할 때 해당되는 결론부 버튼을 클릭함으로써 값을 얻게 하였습니다.

※ 결론부의 잘려진 그림을 그릴 때 직선의 방정식을 이용하여 각각의 X 또는 Y 좌표의 포인트를 계산하려 하였으나 컴퓨터 화면상의 픽셀은 세로, 즉 Y 픽셀은 위로 갈수록 값이 작아지기 때문에 직선의 방정식을 그대로 이용하면 원하는 픽셀의 결과를 얻을 수 없었습니다. 그래서 X를 구하기 위한 식 x=( ((x2-x1)/(y2-y1))*(y-y1) )+x1 의 식을 변형하여 y2와 y1의 위치를 변경하여 시도를 해 보았으나 그것 역시도 주어진 y값에 의해서 원하는 x픽셀을 찾지 못하였습니다. 이 과제에서 주어진 조건은 극히 제한적이기 때문에 y값이 0.25,0.5, 0.75, 1.0을 갖을 때를 switch문을 이용해서 x값을 찾도록 하였습니다.

※ 잘려진 결론부의 그림들을 모두 합하여 y좌표의 max값을 통한 x좌표의 회전값을 이용해서 무게중심을 구해야 합니다만 잘려진 각각의 도형들의 선들이 만나는 지점을 찾는 것이 어려웠습니다. 처음부터 직선의 방정식을 이용해서 잘려진 부분의 x값을 찾을 수 있었다면 약간의 조건문과 반복문으로 max 값만의 line을 축출할 수 있었을 텐데 저는 그렇게 하지 못하여 각각의 잘려진 부분의 무게중심들을 구하여 모두를 더한 값을 잘려진 부분이 있는 결론부의 수로 나눈 값을 최종 결과값으로 출력하도록 하였습니다.

※ Max-Min CRI 알고리즘의 개념은 극히 단순하지만 그것을 프로그램으로 구현하는 과정은 어려웠습니다. 특히 수학의 직선의 방정식과 컴퓨터의 픽셀을 연결하는데 연구가 필요하다고 느꼈습니다.




* 대학교 시절 인공지능 시간에 만들었던 퍼지 알고리즘 객체지향 언어의 장점을 활용하지 못하고 무작정 손가락 가는대로 만들었던 것 같다.

<초기 실행시 화면>

<조건부 2의 버튼을 눌렀을 때의 화면>

<비퍼지값 3을 입력 하고 Setting을 누르고 결론부 1부터 6까지 누른 상태 화면>

< Max-Min Result 버튼을 누른 상태 화면>

SOURCE CODE <- click
less..
  
 import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import javax.swing.JOptionPane;

public class Puzzy extends JFrame{
        JPanel main,right,up,center,down,text_panel;
        JPanel condition[];
        JPanel conclusion[];
        JPanel result_panel;

        DrawArea_condition condition_canvas[];
        DrawArea_conclusion conclusion_canvas[];
        DrawArea_result result_canvas;
        DrawArea_value result_value_panel;

        JTextArea text_result;
        JTextField text_field;

        JButton processing;
        JButton condition_button[];
        JButton conclusion_button[];
        JButton result_button;

        JLabel title[];
        JButton non;
        JLabel title_text;

        BevelBorder bevelborder;
        EtchedBorder etchedborder;

        int panel_count=0
        int temp=0
        int temp2=0
        int text_value=-1
        public float check;
        int x1,x2;
        int result_value;
        public Puzzy(){
                super("Puzzy Application");
                Container c=getContentPane();

                check=0

                result_value_panel=new DrawArea_value();

                processing=new JButton("Setting");
                processing.addActionListener(new actionhandler_button());

                non=new JButton("Non Puzzy Value :");
                non.setEnabled(false);

                text_field=new JTextField(10);

                title_text=new JLabel("  Process Running...");

                bevelborder=new BevelBorder(BevelBorder.RAISED);
                etchedborder=new EtchedBorder(EtchedBorder.RAISED);

                text_result=new JTextArea(9,115);

                main=new JPanel();
                right=new JPanel();
                up=new JPanel();
                center=new JPanel();
                down=new JPanel();
                down.setBackground(new Color(148,167,175));
                text_panel=new JPanel();
                text_panel.setLayout(new BorderLayout());
                text_panel.add(title_text, BorderLayout.NORTH);
                text_panel.add(new JScrollPane(text_result), BorderLayout.CENTER);

                right.setLayout(new GridLayout(4,1));

                title=new JLabel[4];
                title[0]=new JLabel();
                title[1]=new JLabel();
                title[2]=new JLabel();
                title[3]=new JLabel();

                title[0].setText("Condition Type");
                title[1].setText("Conclusion Type");
                title[2].setText("");
                title[3].setText("Processing Screen");

                condition_canvas=new DrawArea_condition[6];
                conclusion_canvas=new DrawArea_conclusion[6];

                condition_canvas[panel_count]=new DrawArea_condition(-2,2);    //조건부 canvas 선언
                panel_count++;				 //인수는 x1,과 x2를 이용하여 라인을 그림
                condition_canvas[panel_count]=new DrawArea_condition(0,4);
                panel_count++;
                condition_canvas[panel_count]=new DrawArea_condition(2,6);
                panel_count++;
                condition_canvas[panel_count]=new DrawArea_condition(4,8);
                panel_count++;
                condition_canvas[panel_count]=new DrawArea_condition(6,10);
                panel_count++;
                condition_canvas[panel_count]=new DrawArea_condition(8,12);

                conclusion_canvas[0]=new DrawArea_conclusion(6,8);	    //결론부 canvas 선언
                conclusion_canvas[1]=new DrawArea_conclusion(4,8);
                conclusion_canvas[2]=new DrawArea_conclusion(2,6);
                conclusion_canvas[3]=new DrawArea_conclusion(0,4);
                conclusion_canvas[4]=new DrawArea_conclusion(0,2);
                conclusion_canvas[5]=new DrawArea_conclusion(0,2);

                JPanel right_sub[];
                right_sub=new JPanel[4];								// 오른쪽 새로 패널 선언
                for(int i=0i<4i++){
                        right_sub[i]=new JPanel();
                        right_sub[i].add(title[i]);
                        right_sub[i].setBorder(bevelborder);
                        right_sub[i].setBackground(new Color(148,167,175));
                        right.add(right_sub[i]);
                }
                right_sub[2].setLayout(new GridLayout(7,1));
                right_sub[2].setBackground(new Color(102,102,153));
                right_sub[2].add(non);
                right_sub[2].add(text_field);
                right_sub[2].add(new JLabel(""));
                right_sub[2].add(title[2]);
                right_sub[2].add(processing);

                condition=new JPanel[6];
                up.setLayout(new GridLayout(1,6));
                conclusion=new JPanel[6];
                center.setLayout(new GridLayout(1,6));

                down.setLayout(new GridLayout(1,6));

                result_button=new JButton("Max-Min Result");
                result_button.addActionListener(new actionhandler_button());
                result_canvas=new DrawArea_result(6,8);

                result_panel=new JPanel();
                result_panel.setLayout(new BorderLayout());
                result_panel.add(result_button,BorderLayout.SOUTH);
                result_panel.add(result_canvas,BorderLayout.CENTER);

                result_panel.setBorder(bevelborder);
                down.add(result_panel);

                DrawArea_value_space draw[]=new DrawArea_value_space[4];

                for(int i=0i<4i++){
                        draw[i]=new DrawArea_value_space();
                }

                JPanel tt[]=new JPanel[5];								//결과값 출력되는 가로 패널들의 선언
                for(int i=0i<5i++){
                        tt[i]=new JPanel();
                        tt[i].setLayout(new BorderLayout());
                        tt[i].setBackground(new Color(148,167,175));
                        down.add(tt[i]);
                }
                condition_button=new JButton[6];
                conclusion_button=new JButton[6];
                tt[2].add(result_value_panel,BorderLayout.CENTER);
                tt[0].add(draw[0]);
                tt[1].add(draw[1]);
                tt[3].add(draw[2]);
                tt[4].add(draw[3]);

                condition_button[0]=new JButton("Condition Type 1");		//조건부 패널 타이틀 선언
                condition_button[1]=new JButton("Condition Type 2");
                condition_button[2]=new JButton("Condition Type 3");
                condition_button[3]=new JButton("Condition Type 4");
                condition_button[4]=new JButton("Condition Type 5");
                condition_button[5]=new JButton("Condition Type 6");

                conclusion_button[0]=new JButton("Conclusion Type 1");		//결론부 패널 타이틀 선언
                conclusion_button[1]=new JButton("Conclusion Type 2");
                conclusion_button[2]=new JButton("Conclusion Type 3");
                conclusion_button[3]=new JButton("Conclusion Type 4");
                conclusion_button[4]=new JButton("Conclusion Type 5");
                conclusion_button[5]=new JButton("Conclusion Type 6");

                for(int i=0i<6i++){
                        condition_button[i].addActionListener(new actionhandler_button());
                        conclusion_button[i].addActionListener(new actionhandler_button());
                        condition[i]=new JPanel();
                        condition[i].setLayout(new BorderLayout());
                        condition[i].setBorder(etchedborder);
                        condition[i].add(condition_canvas[i], BorderLayout.CENTER);			//조건부 패널들에 canvas와 button 붙임
                        condition[i].add(condition_button[i], BorderLayout.NORTH);

                        conclusion[i]=new JPanel();
                        conclusion[i].setLayout(new BorderLayout());
                        conclusion[i].setBorder(etchedborder);
                        conclusion[i].add(conclusion_canvas[i], BorderLayout.CENTER);		//조건부 패널들에 canvas와 button 붙임
                        conclusion[i].add(conclusion_button[i], BorderLayout.SOUTH);

                        up.add(condition[i]);												//up 패널에 6개의 조건부 패널을 붙임
                        center.add(conclusion[i]);									//center 패널에 6개의 결론부 패널을 붙임
                }

                main.setBorder(etchedborder);											// main ==> 왼쪽 패널
                right.setBorder(etchedborder);										// right==> 오른쪽 패널 세로
                up.setBorder(etchedborder);											// up   ==> 왼쪽 main 패널 1번째 패널
                center.setBorder(etchedborder);										// center=> 왼쪽 main 패널 2번째 패널
                down.setBorder(etchedborder);											// down ==> 왼쪽 main 패널 3번째 패널
                text_panel.setBorder(etchedborder);								// text_panel==> 왼쪽 main 패널 4번째 패널

                main.setLayout(new GridLayout(4,1));
                main.add(up);
                main.add(center);
                main.add(down);
                main.add(text_panel);

                c.add(right, BorderLayout.EAST);
                c.add(main, BorderLayout.CENTER);

                setSize(1025,740);
                show();
        }
        public void k_check(int k){										// k값에 따라 this.check 변수에 세로(x좌표) 입력
                if(k==1)
                this.check=(float)2.5
                else if(k==2)
                this.check=(float)5
                else if(k==3)
                this.check=(float)7.5
                else if(k==4)
                this.check=(float)10
                else if(k==0)
                this.check=(float)0
        }
        final class actionhandler_button implements ActionListener{
                public void actionPerformed(ActionEvent ae){
                        JButton bb=(JButton)ae.getSource();
                        int k=0
                        if(bb.getLabel()=="Condition Type 1"){
                                temp=11
                                text_value=0
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Condition Type 2"){
                                temp=12
                                text_value=2
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Condition Type 3"){
                                temp=13
                                text_value=4
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Condition Type 4"){
                                temp=14
                                text_value=6
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Condition Type 5"){
                                temp=15
                                text_value=8
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Condition Type 6"){
                                temp=16
                                text_value=10
                                text_result.setText(text_result.getText()+"\nCondition Area\n"+bb.getLabel()+"를 선택했습니다.\n");
                                for(int i=0i<6i++){
                                        condition_canvas[i].repaint();
                                }
                        }
                        if(bb.getLabel()=="Conclusion Type 1"){          //결론부 버튼이 눌려질 때 채크후 repainting
                                temp2=11
                                if(text_value==0)  k=4
                                else if(text_value==1) k=3
                                else if(text_value==2) k=2
                                else if(text_value==3) k=1
                                else k=0
                                k_check(k);							//입력된 k로 부터 check값을 넣음
                                conclusion_canvas[0].repaint();
                        }
if(bb.getLabel()=="Conclusion Type 2"){
        temp2=12
        if(text_value==0)
        k=2
        else if(text_value==1) k=3
        else if(text_value==2) k=4
        else if(text_value==3) k=3
        else if(text_value==4) k=2
        else if(text_value==5) k=1
        else  k=0
        k_check(k);
        conclusion_canvas[1].repaint();
}
if(bb.getLabel()=="Conclusion Type 3"){
        temp2=13
        if(text_value==0) k=0
        else if(text_value==1) k=1
        else if(text_value==2) k=2
        else if(text_value==3) k=3
        else if(text_value==4) k=4
        else if(text_value==5) k=3
        else if(text_value==6) k=2
        else if(text_value==7) k=1
        else if(text_value==8) k=0
        else if(text_value==9) k=0
        else if(text_value==10) k=0
        else k=0

        k_check(k);
        conclusion_canvas[2].repaint();
}
if(bb.getLabel()=="Conclusion Type 4"){
        temp2=14
        if(text_value==0 || text_value==1 || text_value==2)
        k=0
        else if(text_value==3) k=1
        else if(text_value==4) k=2
        else if(text_value==5) k=3
        else if(text_value==6) k=4
        else if(text_value==7) k=3
        else if(text_value==8) k=2
        else if(text_value==9) k=1
        else if(text_value==10) k=0
        else k=0

        k_check(k);
        conclusion_canvas[3].repaint();
}
if(bb.getLabel()=="Conclusion Type 5"){
        temp2=15

        if(text_value==0 || text_value==1 || text_value==2 || text_value ==3 || text_value ==4) k=0
        else if(text_value==5) k=1
        else if(text_value==6) k=2
        else if(text_value==7) k=3
        else if(text_value==8) k=4
        else if(text_value==9) k=3
        else if(text_value==10) k=2
        else k=0

        k_check(k);
        conclusion_canvas[4].repaint();
}
if(bb.getLabel()=="Conclusion Type 6"){
        temp2=16

        if(text_value==1 || text_value==2 || text_value==3 || text_value==4 || text_value==5 || text_value==6) 				k=0
        else if(text_value==7) k=1
        else if(text_value==8) k=2
        else if(text_value==9) k=3
        else if(text_value==10) k=4
        else k=0

        k_check(k);
        conclusion_canvas[5].repaint();
}
if(bb.getLabel()=="Setting"){				// 입력된 숫자를 이용해 조건부 라인을 다시 셋팅함
        temp=20
        text_value=Integer.parseInt(text_field.getText());
        text_result.setText(text_result.getText()+"\nCondition Area\n"+"비 퍼지값을 임으로 입력합니다. "+
        "0부터 10까지의"+"숫자중에 "+text_value+" 값을 입력했습니다.\n");
        for(int i=0i<6i++){
                condition_canvas[i].repaint();
        }
}

if(bb.getLabel()=="Max-Min Result"){
        Result_Max_Min();
}
}
}
public void Result_Max_Min(){
        result_canvas.repaint();								// 잘려진 부분을 합하는 canvas를 다시 그림
        result_value_panel.repaint();							// 결과값이 나오는 부분 다시 그림
}

class DrawArea_condition extends Canvas{						//조건부 canvas paint 메소드
        int x1,x2;

        public DrawArea_condition(int x1,int x2){					// x1과 x2 픽셀 포인트로 라인을 그림
                this.x1=x1;
                this.x2=x2;
        }
        public void paint(Graphics g){

                g.setColor(new Color(153,153,204));
                g.fillRect(4,4,135,131);

                g.setColor(Color.white);
                g.drawLine(4,4,4,135);
                g.drawLine(4,4,138,4);

                g.setColor(Color.black);
                g.drawLine(138,4,138,135);
                g.drawLine(4,135,138,135);

                g.setColor(Color.black);
                g.drawLine(15,35,15,115);
                g.drawLine(15,115,127,115);

                for(int i=15i<=125i=i+11){					// x좌표 눈금 표시
                        g.drawOval(i,117,2,2);
                }
                for(int i=35i<115i+=8)						// y좌표 눈금 표시
                g.drawOval(11,i,2,2);
                if(x1==-2){
                        g.drawLine(15,35,15+x2*11, 115);
                }
                if((x1!=-2) && (x2!=12)){
                        g.drawLine(15+x1*11,115, 15+x1*11+22, 35);
                        g.drawLine(15+x1*11+22,35,15+x2*11, 115);
                }
                if(x2==12){
                        g.drawLine(15+x1*11,115, 15+x1*11+22, 35);
                }
                g.setColor(Color.red);
                switch(temp){									// temp 전역 변수를 이용하여 조건부에 눌려진 버튼에 의해
                        case 11 : g.drawLine(15,35,15+22, 115);		// 자신의 canvas에 라인을 그림
                        break;
                        case 12 :  g.drawLine(15,115, 15+22, 35);
                        g.drawLine(15+22,35,15+44, 115);
                        break;
                        case 13 : g.drawLine(15+22,115, 15+44, 35);
                        g.drawLine(15+44,35,15+66, 115);
                        break
                        case 14 : g.drawLine(15+44,115, 15+66, 35);
                        g.drawLine(15+66,35,15+88, 115);
                        break
                        case 15 : g.drawLine(15+66,115, 15+88, 35);
                        g.drawLine(15+88,35,15+110, 115);
                        break
                        case 16 : g.drawLine(15+8*11,115, 15+8*11+22, 35);
                        break
                        case 20 : g.drawLine((15+text_value*11)-22, 115, 15+text_value*11, 35);
                        g.drawLine(15+text_value*11,35 ,(15+text_value*11)+22, 115);
                        break

                }

                Font f=new Font("SansSerif", Font.BOLD,10);
                g.setColor(Color.black);
                g.setFont(f);
                g.drawString("Y of 1",15,20);
                g.drawString("X of 10",90,130);
        }
        public void update(){
        }
}
public void swap(int x1,int x2){
        this.x1=x1;
        this.x2=x2;
}
class DrawArea_conclusion extends Canvas{						// 결론부 canvas에 라인을 그림
        int x1,x2;
        int height,width;
        int width_stand,height_stand;
        float conclusion_check;
        int store_x[];
        int store_y[];
        public DrawArea_conclusion(int x1,int x2){
                this.x1=x1;
                this.x2=x2;
                conclusion_check=0
                height=8
                width=13
                width_stand=15
                height_stand=35
                store_x=new int[4];
                store_y=new int[4];
                for(int i=0i<4i++){							//잘려진 횐선을 그리기 위해 x,y 포인터를 저장하는
                        store_x[i]=0								//변수 배열 초기값 0으로 세팅
                        store_y[i]=0
                }
        }
        public void paint(Graphics g){
                //this.g=g;
                g.setColor(new Color(153,153,204));
                g.fillRect(4,4,135,131);

                g.setColor(Color.white);
                g.drawLine(4,4,4,135);
                g.drawLine(4,4,138,4);

                g.setColor(Color.black);
                g.drawLine(138,4,138,135);
                g.drawLine(4,135,138,135);

                g.setColor(Color.black);
                g.drawLine(15,35,15,115);
                g.drawLine(15,115,127,115);

                Font f=new Font("SansSerif", Font.BOLD,10);
                g.setColor(Color.black);
                g.setFont(f);
                g.drawString("Y of 1",15,20);
                g.drawString("X of 2000",90,130);

                for(int i=width_stand;i<=119i=i+width)
                g.drawOval(i,117,2,2);

                for(int i=height_stand;i<115i+=height)
                g.drawOval(11,i,2,2);

                if(x2!=2){
                        g.drawLine(width_stand+x1*width,115, width_stand+x1*width+26, height_stand);
                        g.drawLine(width_stand+x1*width+26,height_stand,width_stand+x2*width, 115);
                }
                if(x2==2){														// 결론부 5,6번째 한 라인만 그림
                        g.drawLine(width_stand+x1*width, height_stand, width_stand+x1*width+26, 115);
                }
                conclusion_check=check;
                if(check!=0){
                        int i=0,j=0
                        int x_value=0
                        int x2_value=0

                        x_value=get_x(width_stand+x1*width,conclusion_check*10);		//필셀의 값을 실제 값으로 산출후 입렵
                        x2_value=get_x2(width_stand+x1*width,width_stand+x2*width,x_value,conclusion_check*10);
                        g.setColor(Color.red);
                        g.drawLine(width_stand,115-(int)((float)8.0*(conclusion_check*10)) ,125,115-(int)((float)8.0*(conclusion_check*10)));

                        g.setColor(Color.white);

                        g.drawLine(width_stand+x1*width, 115,x_value,115-(int)((float)8.0*(conclusion_check*10)));
                        store_x[i++]=width_stand+x1*width;
                        store_y[j++]=115
                        store_x[i++]=x_value;
                        store_y[j++]=115-(int)((float)8.0*(conclusion_check*10));
                        store_x[i++]=x2_value;
                        store_y[j++]=115-(int)((float)8.0*(conclusion_check*10));
                        store_x[i]=width_stand+x2*width;
                        store_y[j]=115
                        g.drawLine(x_value,115-(int)((float)8.0*(conclusion_check*10)),x2_value,115-(int)((float)8.0*(conclusion_check*10)));
                        g.drawLine(x2_value,115-(int)((float)8.0*(conclusion_check*10)), width_stand+x2*width,115);

                        g.drawLine(width_stand+x1*width+26, 115, get_x_center(width_stand+x1*width,115,width_stand+x1+width+26,height_stand,115-(int)((float)8.0*(conclusion_check*10)))+26, 115-(int)((float)8.0*(conclusion_check*10)));
                        g.drawString("[ "+new Float(conclusion_check).toString()+" ]",width_stand+x1*width+15,115-(int)(8.0*(conclusion_check*10))-5);
                        check=0
                }
        }
        public void update(){
        }
}
public int get_x2(int x1,int x2,int x_value,float y_value){       	//4개의 x좌표 중 3번째 x좌표를 찾는 부분
        int x=0

        if(temp2==11)
        x=x2;
        else if(temp2==15 || temp2==16)
        switch((int)(y_value*10.0)){
                case 25 : x=x2-7
                break
                case 50 : x=x2-13
                break
                case 75 : x=x2-20
                break
                case 100: x=x2-26
                break
        }
        else { x=(x1+26)-x_value;
                x=x+x1+26
        }
        return x;
}
public int get_x(int x1,float y_value){      				// 4개의 x좌표 중 2번째 x좌표를 찾는 부분
        int x=0
        x=x1;
        if(temp2==15 || temp2==16)							// 결론부 5,6번 째는 x1 좌표를 그대로 사용
        x=x1;
        else switch((int)(y_value*10.0)){						//결론부 1,2,3,4의 x1좌표를 찾음
                case 25 : x=x+7
                break
                case 50 : x=x+13
                break
                case 75 : x=x+20
                break
                case 100: x=x+26
                break
        }
        return x;
}
public int get_x_center(int x1,int y1,int x2,int y2,int y_value){    //잘린 범위를 표시하기 위해 중앙 x포인터 찾음
        int x=0
        x=x1+((x2-x1)/(y2-y1))*(y_value-y1);
        return x;

}
public float get_round(int value){									//x좌표 픽셀을 이용하여 실제 회전수 값을 찾음
        int count=400
        int re=0
        for(int i=15i<=119i=i+13){
                if(value<=i){
                        re=count;
                        break
                }
                count=count+200
        }
        return re;
}
class DrawArea_value_space extends Canvas{
        public DrawArea_value_space(){
        }
        public void paint(Graphics g){
                g.setColor(new Color(174,174,174));
                g.fillRect(0,100,140,10);

                g.setColor(Color.white);
                g.drawLine(0,100,140,100);
                g.drawLine(0,100,0,110);

                g.setColor(Color.black);
                g.drawLine(0,110,140,110);
                g.drawLine(140,110,140,100);
        }
        public void update(){
        }
}
class DrawArea_value extends Canvas{									//최종 결과값이 출력되는 canvas
        public DrawArea_value(){
        }
        public void paint(Graphics g){
                g.setColor(new Color(99,180,170));
                g.fillRect(0,60,140,50);

                g.setColor(Color.white);
                g.drawLine(0,60,140,60);
                g.drawLine(0,60,0,110);

                g.setColor(Color.black);
                g.drawLine(0,110,140,110);
                g.drawLine(0,135,138,135);
                g.drawLine(140,110,140,60);
                g.setColor(Color.white);
                Font f=new Font("SansSerif", Font.BOLD,22);
                g.setFont(f);
                g.drawString(new Integer((int)result_value).toString(),50,93);
                Font ff=new Font("SansSerif", Font.BOLD,14);
                g.setFont(ff);
                g.drawString("Result Value",50,130);
        }
        public void update(){
        }
}
class DrawArea_result extends Canvas{				//모든 잘려진 부분들의 합을 그리는 canvas
        int x1,x2;
        int height,width;
        int width_stand,height_stand;
        float center_area[];							// 각각의 무게중심을 구한 값을 입력하는 변수

        public DrawArea_result(int x1,int x2){
                this.x1=x1;
                this.x2=x2;
                height=8
                width=13
                width_stand=15
                height_stand=35
                center_area=new float[6];
        }
        public void paint(Graphics g){

                for(int i=0i<4i++)
                center_area[i]=0
                g.setColor(new Color(148,167,175));
                g.fillRect(4,4,135,131);

                g.setColor(Color.white);
                g.drawLine(4,4,4,135);
                g.drawLine(4,4,138,4);

                g.setColor(Color.black);
                g.drawLine(138,4,138,135);
                g.drawLine(4,135,138,135);

                g.setColor(Color.black);
                g.drawLine(15,35,15,115);
                g.drawLine(15,115,127,115);

                for(int i=15i<=119i=i+13)
                g.drawOval(i,117,2,2);

                for(int i=35i<115i+=8)
                g.drawOval(11,i,2,2);
                g.setColor(Color.white);
                int x=0,y=0
                int tti=0
                Font f=new Font("SansSerif", Font.BOLD,10);
                g.setFont(f);
                int last=0
                for(int i=0i<=5i++){
                        if(conclusion_canvas[i].conclusion_check!=0){		//잘려지는 부분이 있는 조건
                                g.drawPolyline(conclusion_canvas[i].store_x,conclusion_canvas[i].store_y,4);
                                center_area[tti++]=(conclusion_canvas[i].conclusion_check*get_round(conclusion_canvas[i].store_x[1])+
                                conclusion_canvas[i].conclusion_check*get_round(conclusion_canvas[i].store_x[2]))/
                                (conclusion_canvas[i].conclusion_check+conclusion_canvas[i].conclusion_check);
                                last=(int)center_area[tti-1];

                                text_result.setText(text_result.getText()+"\n"+"Conclusion Type "+new Integer(i+1).toString()+
                                " Type 의 무게중심 : "+"( "+new Float(conclusion_canvas[i].conclusion_check).toString()+" * "+
                                new Integer((int)get_round(conclusion_canvas[i].store_x[1])).toString()+" + "+
                                new Float(conclusion_canvas[i].conclusion_check).toString()+" * "+
                                new Integer((int)get_round(conclusion_canvas[i].store_x[2])).toString()+") / "+
                                "( "+new Float(conclusion_canvas[i].conclusion_check).toString()+" + "+
                                new Float(conclusion_canvas[i].conclusion_check).toString()+" ) = ");
                                text_result.setText(text_result.getText()+new Integer((int)center_area[tti-1]).toString());
                                g.drawString(new Integer(i+1).toString()+": "+new Integer((int)center_area[tti-1]).toString(),95,10+((tti)*9));
                        }
                }
                text_result.setText(text_result.getText()+"\n\n");

                float tt=0
                int j;

                text_result.setText(text_result.getText()+"( ");
                for(j=0j<(tti-1);j++){
                        text_result.setText(text_result.getText()+ new Integer((int)center_area[j]).toString()+" + ");
                }
                for(j=0j<tti;j++){							//각각의 무게중심을 더함
                        tt=tt+center_area[j];
                }
                result_value=(int)(tt/(j));					//각각의 무게중심을 잘린 부분이 있는 수로 나눔
                text_result.setText(text_result.getText()+ new Integer(last).toString());
                text_result.setText(text_result.getText()+" ) / "+new Integer(j).toString()+" = "+new Integer((int)result_value).toString());

                g.setColor(Color.black);
                g.drawString("Y of 1",15,20);
                g.drawString("X of 2000",90,130);
        }
        public void update(){
        }
}
public static void main(String args[]){
        Puzzy PuzzyApp =new Puzzy();
        PuzzyApp.addWindowListener(
        new WindowAdapter(){
                public void windowClosing(WindowEvent e){
                        System.exit(0);
                }
        }
        );
}
}
less..

 SOURCE CODE <- click
less..
  
 1 import javax.swing.*;
 2 import java.awt.*;
 3 import java.awt.event.*;
 4 import javax.swing.border.*;
 5 import javax.swing.JOptionPane;
 6 
 7 public class EBP extends JFrame{
 8         EBP ebp;
 9         JPanel Up,Down;		 //메인 프래임에서 위와 아래로 패널을 나눔
10         JPanel Type_BackGround[];
11         JPanel Type[];		 //타입별 패널을 3개로 나눔
12         JPanel Type_Field[][]; 	//타입1, 타입2, 타입3에 대한 필드들의 패널
13         JPanel Input_Data[],Output_Data[];
14         JPanel Down_Left,Down_Right,Left,Right;
15         JPanel Space[];
16         JPanel p[],p2[];
17         JButton Processing_Button;
18         JTextField pixel_text1;
19         JTextField pixel_text2;
20 
21         JTextField hidden_text;
22         JTextField Eta_text;
23         JTextField Wait_text;
24 
25         Color color;
26         double Type_Array[][]=
{{0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,
27                         0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},	     
{0,0,1,1,1,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},			
{0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
28                 {0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
29                 {0,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
30                 {0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
31                 {0,0,1,1,1,1,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
32                 {0,0,1,1,1,1,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
33                 {0,0,0,1,1,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
34                 {0,0,0,1,1,0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
35 
36         double Input_Data_Integer[];
37         int pixel_x,pixel_y;
38         double Output_Data_Integer[];
39 
40         double input_to_hidden_wait[][];
41         double hidden_to_output_wait[][];
42 
43         double input_to_hidden[];
44         double hidden_to_output[]=new double[10];
45 
46         double output_error[]=new double[10];
47         double hidden_error[];
48         double wait;
49 
50         double eta;
51 
52         int input_node_count,hidden_node_count;
53         double output[][]={{1,0,0,0,0,0,0,0,0,0},
54                 {0,1,0,0,0,0,0,0,0,0},
55                 {0,0,1,0,0,0,0,0,0,0},
56                 {0,0,0,1,0,0,0,0,0,0},
57                 {0,0,0,0,1,0,0,0,0,0},
58                 {0,0,0,0,0,1,0,0,0,0},
59                 {0,0,0,0,0,0,1,0,0,0},
60                 {0,0,0,0,0,0,0,1,0,0},
61                 {0,0,0,0,0,0,0,0,1,0},
62                 {0,0,0,0,0,0,0,0,0,1}};
63         BevelBorder bevelborder;
64         EtchedBorder etchedborder;
65 
66         public EBP(int pixel_x,int pixel_y,int hidden_node_count,Double eta,Double wait){
67                 super("EBP Application");
68                 Container c=getContentPane();
69 
70                 color=new Color(0,0,255);
71 
72                 this.input_node_count=pixel_x*pixel_y;
73                 this.hidden_node_count=hidden_node_count;
74                 this.eta=eta.doubleValue();
75                 this.wait=wait.doubleValue();
76 
77 
78 
79                 input_to_hidden_wait=new double[hidden_node_count][input_node_count];
80                 hidden_to_output_wait=new double[10][hidden_node_count];
81 
82                 input_to_hidden=new double[hidden_node_count];
83                 hidden_error=new double[hidden_node_count];
84 
85 
86 
87                 Output_Data_Integer=new double[input_node_count];
88 
89                 bevelborder=new BevelBorder(BevelBorder.RAISED);
90                 etchedborder=new EtchedBorder(EtchedBorder.RAISED);
91                 Input_Data_Integer=new double[input_node_count];
92 
93                 for(int j=0j<input_node_count;j++){
94                         Input_Data_Integer[j]=0
95                 }
96                 if(pixel_x!=7||pixel_y!=8){
97                         this.Type_Array=new double[10][input_node_count];
98                         for(int i=0i<10i++)
99                         for(int j=0j<input_node_count;j++){
100                                 Type_Array[i][j]=0
101                         }
102 
103                 }
104                 Processing_Button=new JButton("Processing");
105                 Processing_Button.addActionListener(new actionhandler_button());
106 
107 
108                 JLabel Input_Title=new JLabel("INPUT");
109                 JLabel Output_Title=new JLabel("OUTPUT");
110 
111                 Input_Title.setBorder(bevelborder);
112                 Input_Title.setBackground(new Color(64,94,153));
113                 Output_Title.setBorder(bevelborder);
114                 Output_Title.setBackground(new Color(64,94,153));
115                 Type=new JPanel[10];
116                 for(int i=0i<10i++){
117                         Type[i]=new JPanel();
118                         Type[i].setBorder(bevelborder);
119                         Type[i].setLayout(new GridLayout(pixel_x,pixel_y));
120                 }
121 
122                 Down_Left=new JPanel();
123                 Down_Left.setBorder(bevelborder);
124 
125                 Down_Left.setLayout(new BorderLayout());
126                 JPanel Down_Center=new JPanel();
127                 Down_Center.setLayout(new GridLayout(5,1));
128 
129                 Space=new JPanel[5];
130                 for(int i=0i<5i++){
131                         Space[i]=new JPanel();
132                         Space[i].setBackground(new Color(95,107,122));
133                         Down_Center.add(Space[i]);
134                 }
135                 Space[2].setBorder(bevelborder);
136                 Space[2].setLayout(new BorderLayout());
137                 Space[2].add(Processing_Button,BorderLayout.CENTER);
138 
139                 p=new JPanel[16];
140                 p2=new JPanel[16];
141                 for(int i=0i<16i++){
142                         p[i]=new JPanel();
143                         p2[i]=new JPanel();
144                         p[i].setBackground(color);
145                         p2[i].setBackground(color);
146                         Space[1].add(p[i]);
147                         Space[4].add(p2[i]);
148                 }
149 
150                 Down_Center.setBorder(bevelborder);
151                 Down_Right=new JPanel();
152                 Down_Right.setBorder(bevelborder);
153                 Down_Right.setLayout(new BorderLayout());
154 
155                 Left=new JPanel();
156                 Left.setLayout(new GridLayout(pixel_x,pixel_y));
157                 Right=new JPanel();
158                 Right.setLayout(new GridLayout(pixel_x,pixel_y));
159                 Type_Field=new JPanel[10][input_node_count];
160                 for(int i=0i<10i++)
161                 for(int j=0j<input_node_count;j++){
162                         Type_Field[i][j]=new JPanel();
163                         Type_Field[i][j].setBorder(etchedborder);
164                         Type_Field[i][j].addMouseListener(new mousehandler1());
165                         Type[i].add(Type_Field[i][j]);
166                 }
167                 Setting();
168                 Type_BackGround=new JPanel[10];
169                 for(int i=0i<10i++){
170                         Type_BackGround[i]=new JPanel();
171                         Type_BackGround[i].setLayout(new BorderLayout());
172                         Type_BackGround[i].setBorder(etchedborder);
173                         Type_BackGround[i].setBackground(new Color(212,208,200));
174                 }
175 
176                 Up=new JPanel();
177                 Up.setBorder(bevelborder);
178                 Up.setLayout(new GridLayout(2,5));
179 
180                 for(int i=0i<10i++){
181                         Type_BackGround[i].add(Type[i]);
182                         Up.add(Type_BackGround[i]);
183                 }
184                 Down=new JPanel();
185                 Down.setBorder(bevelborder);
186                 Down.setLayout(new GridLayout(1,3));
187 
188                 Input_Data=new JPanel[input_node_count];
189                 for(int i=0i<input_node_count;i++){
190                         Input_Data[i]=new JPanel();
191                         Input_Data[i].setBorder(etchedborder);
192                         Input_Data[i].addMouseListener(new mousehandler_Input());
193                         Left.add(Input_Data[i]);
194 
195                 }
196                 Output_Data=new JPanel[input_node_count];
197                 for(int i=0i<input_node_count;i++){
198                         Output_Data[i]=new JPanel();
199                         Output_Data[i].setBorder(etchedborder);
200                         Right.add(Output_Data[i]);
201 
202                 }
203                 Down_Left.add(Input_Title,BorderLayout.NORTH);
204                 Down_Left.add(Left,BorderLayout.CENTER);
205                 Down_Right.add(Output_Title,BorderLayout.NORTH);
206                 Down_Right.add(Right,BorderLayout.CENTER);
207 
208                 //setting screen
209                 JPanel right_setting_screen=new JPanel();
210                 right_setting_screen.setLayout(new GridLayout(3,1));
211                 right_setting_screen.setBorder(bevelborder);
212                 JPanel setting[]=new JPanel[3];
213                 for(int i=0i<3i++){
214                         setting[i]=new JPanel();
215                         setting[i].setBorder(etchedborder);
216                         right_setting_screen.add(setting[i]);
217                 }
218                 setting[1].setLayout(new GridLayout(5,1));
219                 JPanel Temp_panel[]=new JPanel[5];
220                 for(int i=0i<5i++){
221                         Temp_panel[i]=new JPanel();
222                         setting[1].add(Temp_panel[i]);
223                 }
224                 Label pixel=new Label("Pixel ");
225                 Label pixel_X=new Label("  X");
226                 Label hidden=new Label("Hid    ");
227                 Label Eta=new Label("Eta    ");
228                 Label Wait=new Label("Wait  ");
229                 Label setting_title=new Label("   [SETTING SPACE]");
230 
231                 pixel_text1=new JTextField(3);
232                 pixel_text2=new JTextField(3);
233 
234                 hidden_text=new JTextField(6);
235                 Eta_text=new JTextField(6);
236                 Wait_text=new JTextField(6);
237 
238 
239                 Temp_panel[0].add(setting_title);
240                 Temp_panel[0].setBorder(bevelborder);
241                 Temp_panel[1].add(pixel);
242                 Temp_panel[1].add(pixel_text1);
243                 Temp_panel[1].add(pixel_X);
244                 Temp_panel[1].add(pixel_text2);
245 
246                 Temp_panel[2].add(hidden);
247                 Temp_panel[2].add(hidden_text);
248 
249                 Temp_panel[3].add(Eta);
250                 Temp_panel[3].add(Eta_text);
251 
252                 Temp_panel[4].add(Wait);
253                 Temp_panel[4].add(Wait_text);
254 
255                 pixel_text1.setText(String.valueOf(pixel_x));
256                 pixel_text2.setText(String.valueOf(pixel_y));
257                 hidden_text.setText(String.valueOf(hidden_node_count));
258                 Eta_text.setText(String.valueOf(eta));
259                 Wait_text.setText(String.valueOf(wait));
260 
261                 JButton clear_button=new JButton("CLEAR");
262                 JButton setting_button=new JButton("SETTING");
263                 clear_button.addActionListener(new actionhandler_button());
264                 setting_button.addActionListener(new actionhandler_button());
265 
266                 setting[2].add(clear_button);
267                 setting[2].add(setting_button);
268 
269                 Down.add(Down_Left);
270                 Down.add(Down_Center);
271                 Down.add(Down_Right);
272 
273                 Panel main=new Panel();
274                 main.setLayout(new GridLayout(2,1));
275                 c.setLayout(new BorderLayout());
276                 main.add(Up);
277                 main.add(Down);
278                 c.add(main,BorderLayout.CENTER);
279                 c.add(right_setting_screen,BorderLayout.EAST);
280 
281 
282 
283                 setBounds(100,60,100,145);
284                 setSize(860,640);
285                 show();
286         }
287         public void Processing_Method(){
288                 System.out.println("Processing");
289 
290                 for(int j=0j<hidden_node_count;j++)
291                 for(int i=0i<input_node_count;i++)
292                 input_to_hidden_wait[j][i]=wait;
293                 for(int j=0j<10j++)
294                 for(int i=0i<hidden_node_count;i++)
295                 hidden_to_output_wait[j][i]=wait;
296                 double tt[]=new double[10];
297                 int count=0
298                 do{
299                         count++;
300                         for(int i=0i<10i++){			//패턴 10개 반복문
301 
302                                 // 1 Level start
303                                 double temp1=0.0
304                                 for(int j=0j<hidden_node_count;j++){
305 
306                                         for(int k=0k<input_node_count;k++)
307                                         temp1+=((double)Type_Array[i][k]*input_to_hidden_wait[j][k]);
308                                         input_to_hidden[j]=Sigm(temp1);
309                                 }
310                                 // 1 Level end
311                                 // 2 Level start
312 
313                                 for(int j=0j<10j++){
314                                         double temp2=0.0
315                                         for(int k=0k<hidden_node_count;k++)
316                                         temp2+=(input_to_hidden[k]*hidden_to_output_wait[j][k]);
317                                         hidden_to_output[j]=Sigm(temp2);
318                                 }
319                                 // 2 Level end
320                                 // 3 Level start
321                                 for(int k=0k<10k++){
322                                         output_error[k]=hidden_to_output[k]*(1-hidden_to_output[k])*(output[i][k]-hidden_to_output[k]);
323                                 }
324                                 // 3 Level end
325                                 // 4 Level start
326 
327                                 for(int j=0j<hidden_node_count;j++){
328                                         double temp=0
329                                         for(int k=0k<10k++)
330                                         temp+=output_error[k]*hidden_to_output_wait[k][j];
331                                         hidden_error[j]=input_to_hidden[j]*(1-input_to_hidden[j])*temp;
332                                 }
333                                 // 4 Level end
334                                 // 1 Level start of Step 4
335                                 for(int j=0j<10j++)
336                                 for(int k=0k<hidden_node_count;k++)	{
337                                         hidden_to_output_wait[j][k]=hidden_to_output_wait[j][k]+(eta*output_error[j]*input_to_hidden[k]);
338 
339                                 }
340                                 // 1 Level end
341                                 // 2 Level start
342                                 for(int k=0k<hidden_node_count;k++){
343                                         for(int j=0j<input_node_count;j++){
344                                                 input_to_hidden_wait[k][j]=input_to_hidden_wait[k][j]+(eta*hidden_error[k]*(double)Type_Array[i][j]);
345                                         }
346                                 }
347                         }
348 
349                 }while(count<=16000);
350                 input_output_processing();
351 
352         }
353         public void input_output_processing(){
354 
355                 // 1 Level start
356                 double temp1=0
357                 for(int j=0j<hidden_node_count;j++){
358 
359                         for(int k=0k<input_node_count;k++)
360                         temp1+=((double)Input_Data_Integer[k]*input_to_hidden_wait[j][k]);
361                         input_to_hidden[j]=Sigm(temp1);
362                 }
363                 // 1 Level end
364                 // 2 Level start
365                 for(int j=0j<10j++){
366                         double temp=0
367                         for(int k=0k<hidden_node_count;k++)
368                         temp+=(input_to_hidden[k]*hidden_to_output_wait[j][k]);
369                         hidden_to_output[j]=Sigm(temp);
370                 }
371                 double temp=hidden_to_output[0];
372                 int count_type=0
373                 for(int i=1i<10i++){
374 
375                         if(temp<=hidden_to_output[i]){
376                                 temp=hidden_to_output[i];
377                                 count_type=i;
378                         }
379 
380                 }
381                 for(int i=0i<input_node_count;i++){
382                         Output_Data_Integer[i]=Type_Array[count_type][i];
383                 }
384                 Output_Data_Interface();
385         }
386         public double Sigm(double Temp){
387                 return 1/(1+Math.exp(-Temp));
388         }
389         public void Output_Data_Interface(){
390                 for(int i=0i<input_node_count;i++){
391                         if(Output_Data_Integer[i]==1)
392                         Output_Data[i].setBackground(color);
393                         else
394                         Output_Data[i].setBackground(new Color(204,204,204));
395                 }
396 
397         }
398 
399         public class mousehandler1 extends MouseAdapter{
400 
401                 public void mousePressed(MouseEvent me){
402                         JPanel pp=(JPanel)me.getSource();
403                         for(int i=0i<10i++){
404 
405                                 for(int j=0j<input_node_count;j++){
406                                         if(pp.equals(Type_Field[i][j])){
407                                                 if(Type_Array[i][j]==0){
408                                                         Type_Field[i][j].setBackground(color);
409                                                         Type_Array[i][j]=1
410                                                 }else{
411                                                         Type_Field[i][j].setBackground(new Color(204,204,204));
412                                                         Type_Array[i][j]=0
413                                                 }
414 
415                                                 break
416                                         }
417                                 }
418                         }
419                 }
420         }
421         public void Setting(){
422 
423                 for(int i=0i<10i++){
424                         for(int j=0j<input_node_count;j++){
425                                 if(Type_Array[i][j]==0){
426                                         Type_Field[i][j].setBackground(new Color(204,204,204));
427                                 }else{
428                                         Type_Field[i][j].setBackground(color);
429                                 }
430                         }
431                 }
432         }
433 
434         public class mousehandler_Input extends MouseAdapter{
435 
436                 public void mousePressed(MouseEvent me){
437                         JPanel pp=(JPanel)me.getSource();
438                         for(int i=0i<input_node_count;i++){
439                                 if(pp.equals(Input_Data[i])){
440 
441                                         if(Input_Data_Integer[i]==0){
442                                                 Input_Data[i].setBackground(color);
443                                                 Input_Data_Integer[i]=1
444 
445                                         }else{
446                                                 Input_Data[i].setBackground(new Color(204,204,204));
447                                                 Input_Data_Integer[i]=0
448 
449                                         }
450                                         break
451                                 }
452 
453                         }
454                         for(int i=0i<input_node_count;i++){
455                                 Output_Data_Integer[i]=Input_Data_Integer[i];
456                         }
457 
458                 }
459         }
460         final class actionhandler_button implements ActionListener{
461 
462                 public void actionPerformed(ActionEvent ae){
463                         JButton bb=(JButton)ae.getSource();
464 
465                         if(bb.getLabel()=="Processing"){
466                                 Processing_Method();
467                         }
468                         if(bb.getLabel()=="CLEAR"){
469                                 pixel_text1.setText("");
470                                 pixel_text2.setText("");
471                                 hidden_text.setText("");
472                                 Eta_text.setText("");
473                                 Wait_text.setText("");
474                         }
475                         if(bb.getLabel()=="SETTING"){
476                                 dispose();
477                                 System.gc();
478 
479                                 Double d1,d2
480                                 d1=new Double(Eta_text.getText());
481                                 d2=new Double(Wait_text.getText());
482 
483                                 ebp=new EBP(Integer.parseInt(pixel_text1.getText()),Integer.parseInt(pixel_text2.getText()),
484                                 Integer.parseInt(hidden_text.getText()),d1,d2);
485                                 ebp.setBounds(100,60,100,145);
486                                 ebp.setSize(860,640);
487                                 ebp.show();
488 
489 
490                         }
491                 }
492         }
493         public static void main(String args[]){
494                 EBP EBPApp =new EBP(7,8,8,new Double(0.3),new Double(0.5));
495                 EBPApp.addWindowListener(
496                 new WindowAdapter(){
497                         public void windowClosing(WindowEvent e){
498                                 System.exit(0);
499                         }
500                 }
501                 );
502         }
503 }
less..