praktikum-holons/src/algorithms/geneticAlgorithm/holegGA/GenAlgoWindow.java

package algorithms.geneticAlgorithm.holegGA;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JSplitPane;

import java.awt.BorderLayout;

import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.BoxLayout;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.JPanel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import ui.controller.Control;
import ui.model.Model;
import ui.view.MyCanvas;
import ui.view.UnitGraph;

import javax.swing.JButton;

import algorithms.geneticAlgorithm.Components.GAResultListener;
import algorithms.geneticAlgorithm.holegGA.Components.HolegGeneration;
import algorithms.geneticAlgorithm.holegGA.Components.HolegIndividual;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.HashMap;

import javax.swing.JTextField;
import javax.swing.JLabel;
import javax.swing.JCheckBox;
import javax.swing.JTextArea;

import classes.CpsEdge;
import java.awt.Font;
import java.awt.Dimension;

public class GenAlgoWindow implements GAResultListener<HolegIndividual> {
	
	public static int NUMBER = 10;

	JFrame frame;
	Control controller;
	Model model;
	JTree genTree;
	DefaultTreeModel treeModel;
	DefaultMutableTreeNode treeRoot;
	HashMap<DefaultMutableTreeNode, HolegIndividual> treeIndiHashmap;
	GenAlgoHandler algoHandler;
	ArrayList<DefaultMutableTreeNode> generationNodes = new ArrayList<DefaultMutableTreeNode>();
	private JTextField edgeAmountField;
	private JCheckBox chckbxEditEdges;
	private JTextArea logArea;
	private JTextField popSizeField;
	private JTextField tournamentSizeField;
	private JTextField edgeBreakCount;
	private JTextField iterationsField;
	ParameterArray params = new ParameterArray();
	private JTextField edgeMutationField;
	private JTextField suppliedField;
	private JTextField oversuppliedField;
	private JTextField undersuppliedField;
	private JTextField edgeLengthField;
	private JTextField wildcardUsageField;
	private JTextField wildcardMutationField;
	private JTextField partialSuppliedField;
	private JTextField overproductionField;
	private JTextField generationAmountField;
	private JCheckBox chckbxWildNodes;
	ArrayList<HolegGeneration> generationHistory = new ArrayList<HolegGeneration>();
	/**
	 * Create the application.
	 */
	public GenAlgoWindow(Control controller, Model model) {
		this.model = model;
		this.controller = controller;
		algoHandler = new GenAlgoHandler(controller, model);
		algoHandler.addListener(this);

		treeIndiHashmap = new HashMap<DefaultMutableTreeNode, HolegIndividual>();
		initialize();
		algoHandler.setOriginalNetwork();
		
	}

	/**
	 * Initialize the contents of the frame.
	 */
	private void initialize() {
		frame = new JFrame();
		frame.setBounds(100, 100, 444, 700);
		frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		frame.getContentPane().setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.X_AXIS));
		
	
		JSplitPane mainSplitPane = new JSplitPane();
		mainSplitPane.setResizeWeight(0.3);
		frame.getContentPane().add(mainSplitPane);
		
		JScrollPane treeScrollPane = new JScrollPane();
		mainSplitPane.setLeftComponent(treeScrollPane);
		
		genTree = new JTree();
		treeScrollPane.setViewportView(genTree);
		
		treeModel = (DefaultTreeModel) genTree.getModel();
		treeRoot = new DefaultMutableTreeNode("Generations");
		treeModel.setRoot(treeRoot);
		genTree.setModel(treeModel);
		
		JSplitPane rightSplitPane = new JSplitPane();
		rightSplitPane.setResizeWeight(0.7);
		rightSplitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);
		mainSplitPane.setRightComponent(rightSplitPane);
		
		JPanel parameterPanel = new JPanel();
		parameterPanel.setPreferredSize(new Dimension(100, 650));
		JScrollPane parameterScrollView = new JScrollPane();
		rightSplitPane.setLeftComponent(parameterScrollView);
		parameterScrollView.setViewportView(parameterPanel);

		
		JButton btnCreategeneration = new JButton("create N Generations");
		btnCreategeneration.setBounds(10, 11, 137, 23);
		btnCreategeneration.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {
				setParameters();
				algoHandler.createGeneration(Integer.parseInt(generationAmountField.getText()), params);
			}
		});
		parameterPanel.setLayout(null);
		parameterPanel.add(btnCreategeneration);
		
		edgeAmountField = new JTextField();
		edgeAmountField.setText("0");
		edgeAmountField.setBounds(147, 119, 86, 20);
		parameterPanel.add(edgeAmountField);
		edgeAmountField.setColumns(10);
		
		JLabel lblMaxEdges = new JLabel("Max Edges");
		lblMaxEdges.setBounds(10, 122, 91, 14);
		parameterPanel.add(lblMaxEdges);
		
		chckbxEditEdges = new JCheckBox("\r\n");
		chckbxEditEdges.setBounds(147, 92, 25, 23);
		parameterPanel.add(chckbxEditEdges);
		
		JLabel lblEditEdges = new JLabel("Edit Edges?");
		lblEditEdges.setBounds(10, 96, 91, 14);
		parameterPanel.add(lblEditEdges);
		
		popSizeField = new JTextField();
		popSizeField.setText("100");
		popSizeField.setBounds(147, 45, 86, 20);
		parameterPanel.add(popSizeField);
		popSizeField.setColumns(10);
		
		tournamentSizeField = new JTextField();
		tournamentSizeField.setText("30");
		tournamentSizeField.setBounds(147, 70, 86, 20);
		parameterPanel.add(tournamentSizeField);
		tournamentSizeField.setColumns(10);
		
		JLabel lblPopulationSize = new JLabel("Population Size");
		lblPopulationSize.setBounds(10, 45, 91, 14);
		parameterPanel.add(lblPopulationSize);
		
		JLabel lblTournamentSize = new JLabel("Tournament Size");
		lblTournamentSize.setBounds(10, 73, 91, 14);
		parameterPanel.add(lblTournamentSize);
		
		edgeBreakCount = new JTextField();
		edgeBreakCount.setText("0");
		edgeBreakCount.setBounds(147, 144, 86, 20);
		parameterPanel.add(edgeBreakCount);
		edgeBreakCount.setColumns(10);
		
		JLabel lblEdgeBreakProb = new JLabel("Edge Break Amount");
		lblEdgeBreakProb.setBounds(10, 147, 117, 14);
		parameterPanel.add(lblEdgeBreakProb);
		
		iterationsField = new JTextField();
		iterationsField.setText("1");
		iterationsField.setBounds(147, 169, 86, 20);
		parameterPanel.add(iterationsField);
		iterationsField.setColumns(10);
		
		JLabel lblSimIteration = new JLabel("Sim Iterations");
		lblSimIteration.setBounds(10, 172, 91, 14);
		parameterPanel.add(lblSimIteration);
		
		edgeMutationField = new JTextField();
		edgeMutationField.setText("0.01");
		edgeMutationField.setBounds(147, 194, 86, 20);
		parameterPanel.add(edgeMutationField);
		edgeMutationField.setColumns(10);
		
		JLabel lblMutationProb = new JLabel("Edge Mutation Prob");
		lblMutationProb.setBounds(10, 197, 117, 14);
		parameterPanel.add(lblMutationProb);
		
		suppliedField = new JTextField();
		suppliedField.setText("+10.0");
		suppliedField.setBounds(147, 297, 86, 20);
		parameterPanel.add(suppliedField);
		suppliedField.setColumns(10);
		
		JLabel lblFittnesspointsPerAttribute = new JLabel("Fittnesspoints per Attribute:");
		lblFittnesspointsPerAttribute.setFont(new Font("Tahoma", Font.PLAIN, 12));
		lblFittnesspointsPerAttribute.setBounds(59, 275, 157, 14);
		parameterPanel.add(lblFittnesspointsPerAttribute);
		
		JLabel lblSuppliedEntity = new JLabel("each supplied Entity");
		lblSuppliedEntity.setBounds(10, 300, 117, 14);
		parameterPanel.add(lblSuppliedEntity);
		
		oversuppliedField = new JTextField();
		oversuppliedField.setText("+10.0");
		oversuppliedField.setBounds(147, 322, 86, 20);
		parameterPanel.add(oversuppliedField);
		oversuppliedField.setColumns(10);
		
		JLabel lblOversuppliedEntity = new JLabel("each oversupplied Entity");
		lblOversuppliedEntity.setBounds(10, 325, 127, 14);
		parameterPanel.add(lblOversuppliedEntity);
		
		undersuppliedField = new JTextField();
		undersuppliedField.setText("-10.0");
		undersuppliedField.setBounds(147, 347, 86, 20);
		parameterPanel.add(undersuppliedField);
		undersuppliedField.setColumns(10);
		
		JLabel lblEachUndersuppliedEntity = new JLabel("each undersupplied Entity");
		lblEachUndersuppliedEntity.setBounds(10, 350, 127, 14);
		parameterPanel.add(lblEachUndersuppliedEntity);
		
		edgeLengthField = new JTextField();
		edgeLengthField.setText("-1.0");
		edgeLengthField.setBounds(147, 397, 86, 20);
		parameterPanel.add(edgeLengthField);
		edgeLengthField.setColumns(10);
		
		JLabel lblForEdge = new JLabel("for 100 edge length");
		lblForEdge.setBounds(10, 400, 127, 14);
		parameterPanel.add(lblForEdge);
		
		wildcardUsageField = new JTextField();
		wildcardUsageField.setText("-7.0");
		wildcardUsageField.setBounds(147, 422, 86, 20);
		parameterPanel.add(wildcardUsageField);
		wildcardUsageField.setColumns(10);
		
		JLabel lblWildcardUsage = new JLabel("each Wildcard usage");
		lblWildcardUsage.setBounds(10, 425, 127, 14);
		parameterPanel.add(lblWildcardUsage);
		
		JLabel lblWildcardMutation = new JLabel("Wildcard Mutation Prob");
		lblWildcardMutation.setBounds(10, 222, 117, 14);
		parameterPanel.add(lblWildcardMutation);
		
		wildcardMutationField = new JTextField();
		wildcardMutationField.setText("0.01");
		wildcardMutationField.setBounds(147, 219, 86, 20);
		parameterPanel.add(wildcardMutationField);
		wildcardMutationField.setColumns(10);
		
		JLabel lblEachPartiallySupplied = new JLabel("each partialsupplied Entity");
		lblEachPartiallySupplied.setBounds(10, 375, 137, 14);
		parameterPanel.add(lblEachPartiallySupplied);
		
		partialSuppliedField = new JTextField();
		partialSuppliedField.setText("-2.0");
		partialSuppliedField.setBounds(147, 372, 86, 20);
		parameterPanel.add(partialSuppliedField);
		partialSuppliedField.setColumns(10);
		
		JLabel lblForOverproduction = new JLabel("for 1000 overproduction");
		lblForOverproduction.setBounds(10, 450, 117, 14);
		parameterPanel.add(lblForOverproduction);
		
		overproductionField = new JTextField();
		overproductionField.setText("-5.0");
		overproductionField.setBounds(147, 447, 86, 20);
		parameterPanel.add(overproductionField);
		overproductionField.setColumns(10);
		
		generationAmountField = new JTextField();
		generationAmountField.setText("1");
		generationAmountField.setBounds(147, 12, 86, 20);
		parameterPanel.add(generationAmountField);
		generationAmountField.setColumns(10);
		
		JLabel lblNodesInWildcards = new JLabel("Nodes in Wildcards?");
		lblNodesInWildcards.setBounds(10, 247, 117, 14);
		parameterPanel.add(lblNodesInWildcards);
		
		chckbxWildNodes = new JCheckBox("");
		chckbxWildNodes.setBounds(147, 245, 97, 20);
		parameterPanel.add(chckbxWildNodes);
		
		logArea = new JTextArea();
		rightSplitPane.setRightComponent(logArea);
		
		 MouseListener ml = new MouseAdapter() {
		     public void mousePressed(MouseEvent e) {
		         int selRow = genTree.getRowForLocation(e.getX(), e.getY());
		         TreePath selPath = genTree.getPathForLocation(e.getX(), e.getY());
		         if(selRow != -1) {
		             if(e.getClickCount() == 1) {
		                 nodeSingleClick(selRow, selPath);
		             }
		             else if(e.getClickCount() == 2) {
		                 nodeDoubleClick(selRow, selPath);
		             }
		         }
		     }
		 };
		 genTree.addMouseListener(ml);
		
	}
	
	public void nodeSingleClick(int selRow, TreePath selPath){
		DefaultMutableTreeNode node = (DefaultMutableTreeNode)selPath.getLastPathComponent();
		if(node.getUserObject() instanceof HolegGeneration){
			logArea.setText(((HolegGeneration)node.getUserObject()).getInformation());
		}
	}
	
	public void nodeDoubleClick(int selRow, TreePath selPath){
		DefaultMutableTreeNode node = (DefaultMutableTreeNode)selPath.getLastPathComponent();
		
		if(treeIndiHashmap.get(node) != null){
			algoHandler.drawIndividualWithPos(treeIndiHashmap.get(node));
			logArea.setText(treeIndiHashmap.get(node).log);
		}
	}
	

	@Override
	public void populationCreated(HolegGeneration holegGen) {
		DefaultMutableTreeNode genNode = new DefaultMutableTreeNode(holegGen);
		generationHistory.add(holegGen);
		ArrayList<HolegIndividual> population = holegGen.getGeneration();
		for(int i = 0; i < population.size(); i++){
			DefaultMutableTreeNode child = new DefaultMutableTreeNode("Individual " + i);
			population.get(i).setId(holegGen.getGenCount(), i);
			treeIndiHashmap.put(child, population.get(i));
			genNode.add(child);
		}
		generationNodes.add(genNode);
		treeRoot.insert(genNode, 0);
		treeModel.reload();	
		if(holegGen.getGenCount() == HolegGeneration.ORIGINAL_GEN){
			//edgeAmountField.setText(Integer.toString(holegGen.getGeneration().get(0).getAllEdges().size()));
			int nodeAmount = holegGen.getGeneration().get(0).getIndexes().size();
			int maxEdges = (nodeAmount*(nodeAmount-1))/2;
			edgeAmountField.setText(Integer.toString(maxEdges));

			params.set(params.ORIGINAL_NETWORK, holegGen.getGeneration().get(0));
		}
	}
	
	
	
	/**
	 * sets All Parameters from the Textfields into the ParameterArray;
	 */
	public void setParameters(){
		params.set(params.MAX_EDGES, Integer.parseInt(edgeAmountField.getText()));
		params.set(params.EDIT_EDGES, chckbxEditEdges.isSelected());
		params.set(params.POPULATION_SIZE, Integer.parseInt(popSizeField.getText()));
		params.set(params.TOURNAMENT_SIZE, Integer.parseInt(tournamentSizeField.getText()));
		params.set(params.EDGE_BREAK_AMOUNT, Integer.parseInt(edgeBreakCount.getText()));
		params.set(params.SIM_ITERATIONS, Integer.parseInt(iterationsField.getText()));
		params.set(params.EDGE_MUTATION_PROB, Double.parseDouble(edgeMutationField.getText()));
		params.set(params.SUPPLIED_POINTS, Double.parseDouble(suppliedField.getText()));
		params.set(params.OVERSUPPLIED_POINTS, Double.parseDouble(oversuppliedField.getText()));
		params.set(params.UNDERSUPPLIED_POINTS, Double.parseDouble(undersuppliedField.getText()));
		params.set(params.LENGTH_POINTS, Double.parseDouble(edgeLengthField.getText()));
		params.set(params.WILDCARD_USAGE, Double.parseDouble(wildcardUsageField.getText()));
		params.set(params.WILDCARD_MUTATION_PROB, Double.parseDouble(wildcardMutationField.getText()));
		params.set(params.PARTIALSUPPLIED_POINTS, Double.parseDouble(partialSuppliedField.getText()));
		params.set(params.OVERPRODUCTION, Double.parseDouble(overproductionField.getText()));	
		params.set(params.NODES_IN_WILDCARDS, chckbxWildNodes.isSelected());
		params.set(params.TOURNAMENT_PROB, 0.15);
	}
	
	public ArrayList<HolegGeneration> evaluationRun(ParameterArray params){
		generationHistory = new ArrayList<HolegGeneration>();
		params.set(params.ORIGINAL_NETWORK, this.params.get(params.ORIGINAL_NETWORK));
		algoHandler.createGeneration(100, params);
		return generationHistory;
		
	}
	
	public void setEvalParameters(ParameterArray params){
		this.params = params;
		/*params.set(params.MAX_EDGES, 50);
		params.set(params.EDIT_EDGES, true);
		params.set(params.POPULATION_SIZE, 100);
		params.set(params.TOURNAMENT_SIZE, 30);
		params.set(params.EDGE_BREAK_AMOUNT, 4);
		params.set(params.SIM_ITERATIONS, 1);
		params.set(params.EDGE_MUTATION_PROB, 0.01);
		params.set(params.SUPPLIED_POINTS, 10.0);
		params.set(params.OVERSUPPLIED_POINTS, 10.0);
		params.set(params.UNDERSUPPLIED_POINTS, -10.0);
		params.set(params.LENGTH_POINTS, -1.0);
		params.set(params.WILDCARD_USAGE, -5.0);
		params.set(params.WILDCARD_MUTATION_PROB, 0.05);
		params.set(params.PARTIALSUPPLIED_POINTS, 3.0);
		params.set(params.OVERPRODUCTION, -5.0);	
		params.set(params.NODES_IN_WILDCARDS, true);
		*/
	}
}