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

package algorithms.geneticAlgorithm.holegGA;

import java.util.ArrayList;

import javax.swing.JTextField;

import classes.AbstractCpsObject;
import classes.Category;
import classes.CpsEdge;
import classes.CpsNode;
import classes.HolonWildCard;
import classes.Position;
import ui.controller.Control;
import ui.model.Model;
import algorithms.geneticAlgorithm.Components.GAResultListener;
import algorithms.geneticAlgorithm.Components.GASelectionStrategy;
import algorithms.geneticAlgorithm.Components.GeneticAlgo;
import algorithms.geneticAlgorithm.Components.Selections.TournamentProportionalSelection;
import algorithms.geneticAlgorithm.Components.Selections.TournamentRankSelection;
import algorithms.geneticAlgorithm.Components.Selections.TournamentSelectionStrategy;
import algorithms.geneticAlgorithm.holegGA.Components.HolegCrossover;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFactory;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFittnessFkt;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFittnessScenario;
import algorithms.geneticAlgorithm.holegGA.Components.HolegGeneration;
import algorithms.geneticAlgorithm.holegGA.Components.HolegIndividual;
import algorithms.geneticAlgorithm.holegGA.Components.HolegMutation;

public class GenAlgoHandler {
	
	ArrayList<GAResultListener<HolegIndividual>> listeners = new ArrayList<GAResultListener<HolegIndividual>>();
	HolegFactory factory;
	Control controller;
	Model model;
	int genCount;

	GeneticAlgo<HolegIndividual> holegGA;
	TournamentSelectionStrategy tRS;
	//TournamentRankSelection<HolegIndividual> tRS;
	//TournamentProportionalSelection<HolegIndividual> tRS;
	HolegFittnessScenario hF;
	HolegMutation hM;
	HolegCrossover hC;
	ArrayList<AbstractCpsObject> objSpace;
	CpsNode theNode = new CpsNode("Node");
	
	public GenAlgoHandler(Control controller, Model model){
		this.controller = controller;
		this.model = model;
		genCount = 1;
		objSpace = new ArrayList<AbstractCpsObject>();
		for(Category cat : model.getCategories()){
			for(AbstractCpsObject obj : cat.getObjects()){
				if(!(obj instanceof HolonWildCard) && obj.useForGA){
					objSpace.add(obj);
				}
			}
		}
		
		ArrayList<AbstractCpsObject> origin = model.getObjectsOnCanvas();
		ArrayList<CpsEdge> edges = model.getEdgesOnCanvas();
		factory = new HolegFactory(objSpace, 0, 0);
		factory.originalObjects = origin;
		factory.originalEdges = edges;
		
		hC = new HolegCrossover();
		hF = new HolegFittnessScenario(controller);
		hM = new HolegMutation(0.01);
		hM.setObjectSpace(objSpace);
		tRS = new TournamentSelectionStrategy<HolegIndividual>();
		//tRS = new TournamentRankSelection<HolegIndividual>();
		//tRS = new TournamentProportionalSelection<HolegIndividual>();
		holegGA = new GeneticAlgo<HolegIndividual>(tRS, hC, hM, hF, factory, 0);
		
	}
	
	public void createGeneration(int genAmount, ParameterArray params){
		factory.maxConnections = (int)params.get(params.MAX_EDGES);
		factory.editEdges = (boolean)params.get(params.EDIT_EDGES);
		holegGA.popSize = (int)params.get(params.POPULATION_SIZE);
		tRS.tournamentSize = (int)params.get(params.TOURNAMENT_SIZE);
		tRS.selectProb = (double)params.get(params.TOURNAMENT_PROB);
		hF.setParameters(params);
		
		
		if((boolean)params.get(params.NODES_IN_WILDCARDS)){
			if(!objSpace.contains(theNode)){
				objSpace.add(theNode);
			}else{
				objSpace.remove(theNode);
			}
		}
		hM.setParameters(params);
		for(int i = 0; i < genAmount; i++){
			hF.initialize();
			if(genCount == 1){
				holegGA.generateRandomPopulation();
				HolegGeneration holegGen = new HolegGeneration(genCount);
				holegGen.setGeneration(holegGA.getSortedPopulation());
				addGenToPopulationListeners(holegGen);
			}else{
				holegGA.createNextGeneration();
				HolegGeneration holegGen = new HolegGeneration(genCount);
				holegGen.setGeneration(holegGA.getSortedPopulation());
				addGenToPopulationListeners(holegGen);
			}
		genCount++;
		}
	}
	
	public void drawIndividualWithPos(HolegIndividual hI){
		model.setObjectsOnCanvas(new ArrayList<AbstractCpsObject>());
		model.setEdgesOnCanvas(new ArrayList<CpsEdge>());
		
		hI.configurateNetwork();
		for(int i = 0; i < hI.getIndexes().size(); i++){
			controller.addObjectCanvas(hI.getObjectAt(i));
		}
		
		for(GAEdge e : hI.getAllEdges()){
			controller.addEdgeOnCanvas(e);
		}
		
	}
	
	public void addListener(GAResultListener<HolegIndividual> listener){
		listeners.add(listener);
	}
	
	public void addGenToPopulationListeners(HolegGeneration holegGen){
		for(GAResultListener<HolegIndividual> listener : listeners){
			listener.populationCreated(holegGen);
		}
	}
	
	public ArrayList<HolegIndividual> sortPopulation(ArrayList<HolegIndividual> individuals){
		ArrayList<HolegIndividual> sortedList = new ArrayList<HolegIndividual>();
		for(HolegIndividual hI : individuals){
			for(int i = 0; i <= sortedList.size(); i++){
				if(i == sortedList.size()){
					sortedList.add(hI);
					break;
				}else if(sortedList.get(i).getFittness() < hI.getFittness()){
					sortedList.add(i, hI);
					break;
				}
			}
		}
		return sortedList;
	}
	
	public void setOriginalNetwork(){
		HolegIndividual originIndividual = new HolegIndividual(model.getObjectsOnCanvas(),
					model.getEdgesOnCanvas());

		HolegGeneration originalGen = new HolegGeneration(HolegGeneration.ORIGINAL_GEN);
		hF.calculateFittness(originIndividual);
		ArrayList<HolegIndividual> population = new ArrayList<HolegIndividual>();
		population.add(originIndividual);
		originalGen.setGeneration(population);
		addGenToPopulationListeners(originalGen);
	}
	
	

}