package graficos;


/* ===========================================================
 * Vers�o de Mar�lia da classe XYLineAndShapeRendererDemo
 * ===========================================================
 * A classe XYLineAndShapeRendererDemo est� no pacote:
 * package org.jfree.chart.demo
 */

import java.awt.Color;
import java.awt.GradientPaint;

import java.awt.Graphics;
import java.awt.Panel;
import java.awt.Polygon;
import java.awt.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferStrategy;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

import java.io.OutputStream;
import java.text.NumberFormat;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;
import java.util.Vector;


import javax.imageio.ImageIO;
import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.LookAndFeel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;


import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.ChartUtilities;

import org.jfree.chart.JFreeChart;

import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.SymbolAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.labels.CustomXYToolTipGenerator;
import org.jfree.chart.labels.StandardXYToolTipGenerator;


import org.jfree.chart.plot.PlotOrientation;

import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.LookupPaintScale;

import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;

import org.jfree.chart.title.PaintScaleLegend;

import org.jfree.data.Range;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.ApplicationFrame;

import org.jfree.ui.RectangleEdge;
import org.jfree.ui.RectangleInsets;



import com.lowagie.text.List;





public class Grafico extends JPanel implements Runnable{//ActionListener{//JInternalFrame{//ApplicationFrame {


	//As linhas deste array representam o centro de massa em instantes diferentes, 
	//e as colunas representam as dimens�es
	private double[][]centrosDeMassa;
	
	private JFreeChart chart = null;
	private XYSeriesCollection dataset = null; //Extende indiretamente de XYDataset
	private String titulo = null;
	private Color corMaisEscura= null;

	private static SourceForGraphics fonte = new SourceForGraphics();
	
	private Timer t =null;
    private boolean animacao;
	
	private int cicloAtual;
	private int qtdDimensoes;
	
	private int dimensaoX;
	private int dimensaoY;
	private double escalaHorizontal;
	private double escalaVertical;
	
	private Color[] corPonto = null;
	
	ChartPanel chartPanel = null;
	/**
     * 
     * @param titulo
     * @param tipo (N�o est� sendo usado atualmente)
     * @param animacao - Indica se o gr�fico ser� animado (boolean)
     * @param qtdDimensoes
     * @param posicaoX - Indica qual das dimens�es ser� representada no eixo X
     * @param posicaoY - Indica qual das dimens�es ser� representada no eixo Y
     * @param minDomain - O m�nimo valor em cada eixo do gr�fico
     * @param maxDomain - O m�ximo valor em cada eixo do gr�fico
     */
    public Grafico(final String title, int tipo, boolean animacao, 
    		int qtdDimensoes, int posicaoX, int posicaoY,
    		double minDomain, double maxDomain){//double[][]posicoesAnteriores, double[]centroMassaAnterior){
    	 
    	super();
    	System.out.println("OBJETO");
 		initialize();
 
 		//C�digo de inicializa��o  
 		//createBufferStrategy(2); //Queremos double buffering  
 		
    	this.titulo = title;
       this.centrosDeMassa = new double[2][3];
        this.centrosDeMassa[0]= fonte.calcularCentroDeMassa();
        this.centrosDeMassa[1]= fonte.calcularCentroDeMassa();
       
        
        this.corMaisEscura = new Color(255,255,255);
        this.corPonto = getCorDoPonto(1000 );
        
        this.qtdDimensoes = qtdDimensoes;
        this.cicloAtual = 0;
        this.dimensaoX = posicaoX;
        this.dimensaoY = posicaoY;
        this.escalaHorizontal = minDomain;
        this.escalaVertical = maxDomain;
        
        this.animacao = animacao;
        
		//Cole��o com as s�ries(conjunto de pontos) que estar�o no gr�fico
        dataset = new XYSeriesCollection();
        dataset = updateDataset();
        
        //Cria um chart(o desenho do gr�fico) j� com o dataset inclu�do
        chart = ChartFactory.createXYLineChart(
            this.titulo,
            "X - Posi��o["+dimensaoX+"]",
            "Y - Posi��o["+dimensaoY+"]",
            dataset,
            PlotOrientation.VERTICAL,
            false,//legends
            true,//tooltips
            true);//urls
        
        //Coloca o chart dentro do Panel apropriado
        chartPanel = new ChartPanel(chart);
        
        paintComponent();
        
        //Configura tamanho do chartPanel
        chartPanel.setPreferredSize(new java.awt.Dimension(600, 520));
        
        //Adiciona o chartPanel no nosso Panel Grafico
        add(chartPanel);
        
        /*t = new Timer(5000, new ActionListener(){

			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
				
			}
        	
        });  
        t.setCoalesce(true); 
        t.start();
		*/
    }//Fim do construtor2
    

    public Grafico(SourceForGraphics font, final String title, int tipo, boolean animacao, 
    		int qtdDimensoes, int posicaoX, int posicaoY,
    		double escalaH, double escalaV){//double[][]posicoesAnteriores, double[]centroMassaAnterior){
    	 
    	super();
    	System.out.println("OBJETO");
 		initialize();
 
 		//C�digo de inicializa��o  
 		//createBufferStrategy(2); //Queremos double buffering  
 		this.fonte = font;
 		
    	this.titulo = title;
        //this.centrosDeMassa = new double[2][3];
        //this.centrosDeMassa[0]= this.fonte.calcularCentroDeMassa();
        //this.centrosDeMassa[1]= this.fonte.calcularCentroDeMassa();
       
        
        this.corMaisEscura = new Color(255,255,255);
        this.corPonto = getCorDoPonto(1000 );
        
        this.qtdDimensoes = qtdDimensoes;
        this.cicloAtual = 0;
        this.dimensaoX = posicaoX;
        this.dimensaoY = posicaoY;
        this.escalaHorizontal = escalaH;
        this.escalaVertical = escalaV;
        
        this.animacao = animacao;
        
		//Cole��o com as s�ries(conjunto de pontos) que estar�o no gr�fico
        dataset = new XYSeriesCollection();
        dataset = updateDataset();
        
        //Cria um chart(o desenho do gr�fico) j� com o dataset inclu�do
        chart = ChartFactory.createXYLineChart(
            this.titulo,
            "X (m)",
            "Y (m)",
            dataset,
            PlotOrientation.VERTICAL,
            true,//legends
            true,//tooltips
            true);//urls
        
        //Coloca o chart dentro do Panel apropriado
        chartPanel = new ChartPanel(chart);
        
        paintComponent();
        
        //Configura tamanho do chartPanel
        chartPanel.setPreferredSize(new java.awt.Dimension(600, 520));
        
        //Adiciona o chartPanel no nosso Panel Grafico
        add(chartPanel);
        
        /*t = new Timer(5000, new ActionListener(){

			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
				
			}
        	
        });  
        t.setCoalesce(true); 
        t.start();
		*/
    }//Fim do construtor2
    
    
	public void run() {
		while(animacao){
			//processEvents();  
			//processLogics();  
			//draw(); 
			
			
			//DESCOMENTAR DEPOIS
			//repintar(null);
			
		}
	}
    

	public void repintar(Vector<Peixe> peixes){
		
		System.out.println("repintar");
		//paintComponent2();
		String nomeArquivo = "";
		if(peixes == null){
			;//processLogics_SourceReports(nomeArquivo);
		}
		else{
			processLogics_SourceSwarm(peixes);
		}
		chart = ChartFactory.createXYLineChart(
		            nomeArquivo,
		            "X - Posi��o["+dimensaoX+"]",
		            "Y - Posi��o["+dimensaoY+"]",
		            dataset,
		            PlotOrientation.VERTICAL,
		            true,
		            true,
		            true);
		        
		paintComponent();
	    	
		try {
			synchronized(this) {  
			     this.wait(50);  
			} 
			
			System.out.println("Esperei 0.05s");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	/**Esta fun��o serve para atualizar a fonte, ou seja, o conjunto de pontos,
	 * e o dataset*/
	/*public void processLogics_SourceSwarm(Vector <Peixe> peixes){
		fonte.lerLivingSwarm(peixes, dimensaoX, dimensaoY);
		
        this.centrosDeMassa[0]= new double[2];//this.centrosDeMassa[1];
        this.centrosDeMassa[1]= new double[2];//fonte.calcularCentroDeMassa();///ATEN��O!!!
		
		//atualiza a cole��o de s�ries (XYSeriesCollection), onde cada s�rie � um conjunto de pontos.
        dataset = updateDataset();
	}*/
	
	public void processLogics_SourceReports(String nomeArquivo){
		nomeArquivo = this.titulo + ".txt";
		if(this.cicloAtual>0 ){
			System.out.println("Ciclo Atual = "+cicloAtual);
			/*Cada vez que paintComponent2 � executado nomeArquivo � o t�tulo, ]
			 *portanto representa o ciclo 0. Por isso deve-se substituir o ciclo 0 pelo ciclo atual*/
			nomeArquivo = nomeArquivo.replace("0", cicloAtual+"");
		}
		
		//fonte.lerArquivoSwarm(dimensaoX, dimensaoY, nomeArquivo);
		
        this.centrosDeMassa[0]= new double[2];//this.centrosDeMassa[1];
        this.centrosDeMassa[1]= new double[2];//fonte.calcularCentroDeMassa();
		
		//atualiza a cole��o de s�ries (XYSeriesCollection), onde cada s�rie � um conjunto de pontos.
        dataset = updateDataset();
        
        this.cicloAtual++;
	}
	
	
	public void paintComponent(){
		
		  

		XYPlot plot = (XYPlot) chart.getPlot();
        
        plot.setDataset(dataset);
      
        //Color[] corPonto = getCorDoPonto(indiceMatar );
        MyXYLineAndShapeRenderer2 renderer = new MyXYLineAndShapeRenderer2(corPonto);
        
        //Gera as dicas de cada ponto
        //CustomXYToolTipGenerator ttg = gerarToolTips();
        //renderer.setToolTipGenerator(ttg);
       



		/*******************************************************************
		 * C�digo que personaliza a cor e o formato dos pontos em cada s�rie
		 *******************************************************************/     
   
        //C�digo que cria as cores dos pontos no gr�fico     
        
        /**Vermelho Claro**/
        Color corCMDepois =  new Color(255, 85, 85);
        
        int transparencia = 100;
        /**Azul claro**/
        Color corSeriePontosAlvo =  new Color(0, 79, 157);
        /**Azul claro**/
        Color corSeriePontosAlvo_Acerto =  new Color(0, 79, 157, transparencia);
        /**Verde**/
        Color corSeriePontosAlvo_Erro =  new Color(85, 255, 85);
        
        /**Vermelho**/
        Color corSeriePontosObstaculo =  new Color(255, 0, 0);
        /**Azul claro**/
        Color corSeriePontosObstaculo_Acerto =  new Color(255, 0, 0, transparencia);
        /**Verde**/
        Color corSeriePontosObstaculo_Erro =  new Color(254, 1, 235);
        
        /**Vermelho Escuro**/
        Color corPontosAgentes = new Color(128, 0, 0);
        
        //C�digo que cria os formatos dos pontos no gr�fico
        double size = 6.0;
        double delta = size / 2.0;
        int[] xpoints = {(int) 0.0, (int) delta, (int)-delta};
        int[] ypoints = {(int)-delta, (int)delta, (int)delta};
 
        Shape shape1 = new Rectangle2D.Double(-delta, -delta, size, size);//quadrado
        Shape shape2 = new Ellipse2D.Double(-delta, -delta, size, size);//circulo
        Shape shape3 = new Polygon(xpoints, ypoints, 3);//tri�ngulo

        //Personaliza a s�rie - Posi��es limites
        renderer.setSeriesLinesVisible(0, false);
        renderer.setSeriesShapesVisible(0, true);
        renderer.setSeriesShape(0,shape3);
        renderer.setSeriesPaint(0, Color.LIGHT_GRAY);
        
        //Personaliza s�rie 7 - Agentes
        renderer.setSeriesShape(7,shape1);
        renderer.setSeriesLinesVisible(7, false);
        renderer.setSeriesShapesVisible(7, true);
        renderer.setSeriesPaint(7, corPontosAgentes);
        
      
        //Personaliza s�rie 1 - Pontos Alvo 
   
        	renderer.setSeriesShape(1,shape2);
        	renderer.setSeriesLinesVisible(1, false);
        	renderer.setSeriesShapesVisible(1, true);
        	renderer.setSeriesPaint(1, corSeriePontosAlvo);   
     
            
        //Personaliza s�rie 3 - Pontos Amostras Alvo com Acerto
        renderer.setSeriesLinesVisible(2, false);
        renderer.setSeriesShapesVisible(2, true);
        renderer.setSeriesShape(2,shape3);
        renderer.setSeriesPaint(2, corSeriePontosAlvo_Acerto);
        
        //Personaliza s�rie 3 - Pontos Amostras Alvo com Erro
        renderer.setSeriesShape(3,shape3); //"0" � o �ndice da s�rie no "array", e "shape3" � o formato dos pontos nesta s�rie
        renderer.setSeriesLinesVisible(3, false);//seta se as linhas entres os pontos desta s�rie s�o vis�veis ou n�o
        renderer.setSeriesShapesVisible(3, true);//seta se as formas dos pontos desta s�rie s�o vis�veis ou n�o
        renderer.setSeriesPaint(3, corSeriePontosAlvo_Erro);// seta a cor dos pontos pertencentes a esta s�rie
       
        //Personaliza s�rie 4 - Pontos Obstaculo 
        
    		renderer.setSeriesShape(4,shape2);
    		renderer.setSeriesLinesVisible(4, false);
    		renderer.setSeriesShapesVisible(4, true);
    		renderer.setSeriesPaint(4, corSeriePontosObstaculo);   
 
        
		//Personaliza s�rie 5 - Pontos Amostras Obstaculo com Acerto
		renderer.setSeriesLinesVisible(5, false);
		renderer.setSeriesShapesVisible(5, true);
		renderer.setSeriesShape(5,shape3);
		renderer.setSeriesPaint(5, corSeriePontosObstaculo_Acerto);
    
	    //Personaliza s�rie 6 - Pontos Amostras Obstaculo com Erro
	    renderer.setSeriesShape(6,shape3); //"0" � o �ndice da s�rie no "array", e "shape3" � o formato dos pontos nesta s�rie
	    renderer.setSeriesLinesVisible(6, false);//seta se as linhas entres os pontos desta s�rie s�o vis�veis ou n�o
	    renderer.setSeriesShapesVisible(6, true);//seta se as formas dos pontos desta s�rie s�o vis�veis ou n�o
	    renderer.setSeriesPaint(6, corSeriePontosObstaculo_Erro);// seta a cor dos pontos pertencentes a esta s�rie
	        
        
     
        
		/**************************************************************************
		 * FIM do c�digo que personaliza a cor e o formato dos pontos em cada s�rie
		 **************************************************************************/
  
        plot.setRenderer(renderer);
  
        chartPanel.setChart(chart);

        
	}
    //Fun��o que serve para salvar o gr�fico :P
   
	public void salvarGrafico(String formato)
    {
    	 ApplicationFrame frame = new ApplicationFrame(this.titulo);
    	 final ChartPanel chartPanel = new ChartPanel(chart);
    	 
    	 frame.setContentPane(chartPanel);
    	 frame.pack();
        
 		
 		File file = new File("Gr�ficos Gerados/" + this.titulo + formato);
 		try {
 		   ChartRenderingInfo info = chartPanel.getChartRenderingInfo();
 		  
 		   OutputStream out = new  BufferedOutputStream(new FileOutputStream(file));
 		   if (formato.equals("png"))
 		      ChartUtilities.writeChartAsPNG(out, chart, chartPanel.getWidth(), chartPanel.getHeight(), info );
 		   else 
 			   ChartUtilities.writeChartAsJPEG(out, chart, chartPanel.getWidth(), chartPanel.getHeight(), info );
 		   out.flush();
 		   out.close();
 		   //JOptionPane.showMessageDialog(null, "O gr�fico foi salvo com sucesso");
 		}catch(FileNotFoundException e){
 		   JOptionPane.showMessageDialog(null,"Arquivo n�o encontrado!","Aten��o",JOptionPane.ERROR_MESSAGE);
 		}catch(Exception e) {
 		   JOptionPane.showMessageDialog(null,"---Erro na cria��o do arquivo!","Aten��o",JOptionPane.ERROR_MESSAGE);
 		}
 	
    }
   
    //Fun��o que cria a "tip" de cada ponto
    private CustomXYToolTipGenerator gerarToolTips(){
    	CustomXYToolTipGenerator ttg = new CustomXYToolTipGenerator();
    	LinkedList listaTipCMAntes = new LinkedList();
    	listaTipCMAntes.add("CM - Anterior");
    	ttg.addToolTipSeries(listaTipCMAntes);
    	
    	LinkedList listaTipCMDepois = new LinkedList();
    	listaTipCMDepois.add("CM - Atual");
    	ttg.addToolTipSeries(listaTipCMDepois);
    	
    	//LinkedList[] listaTipPeixes = new LinkedList[conjuntoDePontos.getQtdPeixesInicial()];
    	LinkedList listaTipPeixes = new LinkedList();
    	String itemTip ="";
    	
    	Vector <Ponto> conjuntoDePontos = fonte.getConjuntoDePontos();
    	
    	int i=0;
    	while(i < conjuntoDePontos.size())
		{
    		itemTip = conjuntoDePontos.get(i).toString();
    		listaTipPeixes.add(itemTip);
    		i++;
    	}
    	ttg.addToolTipSeries(listaTipPeixes);
    	
       	return ttg;
    }
    
    //Fun��o que calcula a cor de cada ponto de acordo com seu tamanho
    private Color[] getCorDoPonto(double indiceLimiar)
    {
    	Vector <Ponto> conjuntoDePontos = fonte.getConjuntoDePontos();
    	
    	Color[] corDoPonto = new Color[conjuntoDePontos.size()];
    	for(int i=0; i < conjuntoDePontos.size();i++ )
		{
    		//All points(particles) have the same color
    		corDoPonto[i] = new Color(0, 79, 157);
    	}
    	
    	return corDoPonto;
    }

    
    private void initialize() {
        this.setSize(new java.awt.Dimension(650, 570));
		this.setAlignmentX(this.CENTER_ALIGNMENT);
	}


    
    private XYSeries[] createSerieCentroDeMassa()
    {
    	int qtdPontos = this.centrosDeMassa.length;
    	XYSeries[] seriesCM = new XYSeries[qtdPontos];
    	
    	/*
    	for(int i =0; i < qtdPontos; i++ ){
    		seriesCM[i] = new XYSeries("CM antes");
    	}*/
    	seriesCM[0] = new XYSeries("CM anterior");
    	seriesCM[1] = new XYSeries("CM atual");
    	
        for(int i =0; i < qtdPontos; i++ ){
        	//System.out.println(this.centrosDeMassa[i][0] + ","+ this.centrosDeMassa[i][1]);
        	seriesCM [i].add(this.centrosDeMassa[i][0], this.centrosDeMassa[i][1]);
        }
         
       // if(dataset.getSeriesCount() == 1){
	    	
	     //   for(int h = 0; h < seriesCM.length; h++)
	      //  	dataset.addSeries(seriesCM[h]);
	       // System.out.println("segunda e terceira serie criada");
       // }
        return seriesCM;
    }
    
    /**
     * @param dimensaoX - Indica qual das posicoes ser� representada no eixo X
     * @param dimensaoY - Indica qual das posicoes ser� representada no eixo Y
     * @return
     */
    private XYSeries createSeriePosicoesAntes()
    {
    	XYSeries posicoesAntes;
    	if (this.dataset.getSeriesCount()!=0)
    	{
    	
    		posicoesAntes = new XYSeries("Posicoes Antes");//dataset.getSeries(1); //pega a s�rie(posicoesDepois)
    	    //posicoesAntes.setDescription("Posicoes Antes");
     
    	}
    	else{
    		//Adiciona uma s�rie vazia
    		posicoesAntes = new XYSeries("Posicoes Antes");
    		
    	}
    	return posicoesAntes;
    }
    
    /**
     * 
     * @param dimensaoX - Indica qual das posicoes ser� representada no eixo X
     * @param dimensaoY - Indica qual das posicoes ser� representada no eixo Y
     * @return
     */
    private XYSeries createSeriePosicoesDepois()
    {
    	int qtdPontos = fonte.getConjuntoDePontos().size();
    	
    	XYSeries seriesPosicoes = new XYSeries("Posicoes Depois");
		
		for(int i =0; i < qtdPontos; i++ ){
			seriesPosicoes.add(
    			fonte.getConjuntoDePontos().get(i).getPosition(0), 
    			fonte.getConjuntoDePontos().get(i).getPosition(1));
		}
		
		return seriesPosicoes;
        
    }
    
    private XYSeries createSeriePosicoesLimites()
    {
    	
	   XYSeries seriesPosicoes = new XYSeries("Posicoes Limites");
	   
	   seriesPosicoes.add(0, 0);
       seriesPosicoes.add(escalaHorizontal, escalaVertical);
       seriesPosicoes.add(0, escalaVertical);
       seriesPosicoes.add(escalaHorizontal, 0);
       
      /* seriesPosicoes.add(-min, -min);
       seriesPosicoes.add(-min, max);
       seriesPosicoes.add(max, -min);
       seriesPosicoes.add(max, max); */
    
       return seriesPosicoes;
    }
    /**
     * Cria o dataset de pontos a serem plotados no gr�fico     
     * @param posicaoX - Indica qual das posicoes ser� representada no eixo X
     * @param posicaoY - Indica qual das posicoes ser� representada no eixo Y
     */
    private XYSeriesCollection updateDataset() {

    	
    	 
        //------------Desenha Pontos Verdes----------
    	XYSeries posicoesAntes = createSeriePosicoesAntes();//lembrar:Esta fun��o DEVE ser chamada antes da fun��o seguinte

        //------------Desenha Pontos Azuis----------
    	//XYSeries posicoesDepois = createSeriePosicoesDepois();
    	
    	int qtdPontos = fonte.getConjuntoDePontos().size();
    	
    	XYSeries seriesPosicoesMouseAlvo = new XYSeries("Posicoes Mouse Alvo");
    	XYSeries seriesPosicoesMouseObstaculo = new XYSeries("Posicoes Mouse Obstaculo");
    	XYSeries seriesPosicoesAgentes = new XYSeries("Posicoes Agentes");
    	XYSeries seriesPosicoesAmostrasAlvo = new XYSeries("Posicoes Amostras - Alvo");
    	XYSeries seriesPosicoesAmostrasObstaculo = new XYSeries("Posicoes Amostras - Obstaculo");
    	XYSeries seriesPosicoesAmostrasErradasAlvo = new XYSeries("Posicoes Amostras Erradas - Alvo");
    	XYSeries seriesPosicoesAmostrasErradasObstaculo = new XYSeries("Posicoes Amostras Erradas - Obstaculo");
    	
		for(int i =0; i < qtdPontos; i++ ){
			if(fonte.getConjuntoDePontos().get(i).getTipo()==0){//Se for do tipo posicao de mouse que representa alvo
				seriesPosicoesMouseAlvo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==1){//Se for do tipo posicao de mouse que representa obstaculo
				seriesPosicoesMouseObstaculo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==2){///Se for do tipo posicao de agente
				seriesPosicoesAgentes.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==3){//Se for do tipo posicao de ponto que mapeia funcao alvo
				seriesPosicoesAmostrasAlvo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==4){//Se for do tipo posicao de ponto que mapeia funcao obstaculo
				seriesPosicoesAmostrasObstaculo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==5){//Se for do tipo posicao de ponto alvo que n�o mapeia funcao alvo
				seriesPosicoesAmostrasErradasAlvo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			else if(fonte.getConjuntoDePontos().get(i).getTipo()==6){//Se for do tipo posicao de ponto obstaculo que n�o mapeia funcao obstaculo
				seriesPosicoesAmostrasErradasObstaculo.add(
						fonte.getConjuntoDePontos().get(i).getPosition(0), 
						fonte.getConjuntoDePontos().get(i).getPosition(1));
			}
			
		}
    
        //-------Desenha os pontos e a linha vermelha------------
    	//XYSeries[] seriesCM = createSerieCentroDeMassa();//Cada s�rieCM s� tem 1 ponto 


    	XYSeries posicoesLimites = createSeriePosicoesLimites();
        
       
        
    	dataset.removeAllSeries();//remove todas 
    	//A ordem em que s�o adicionadas � importante
 		
    	dataset.addSeries(posicoesLimites);
    	//Adiciona nesta cole��o a s�rie que representa os pontos por onde o mouse passou
		dataset.addSeries(seriesPosicoesMouseAlvo);
		//Adiciona nesta cole��o a s�rie que representa os pontos pertencentes a funcao
		dataset.addSeries(seriesPosicoesAmostrasAlvo);
		//Adiciona nesta cole��o a s�rie que representa os pontos n�o pertencentes a funcao
		dataset.addSeries(seriesPosicoesAmostrasErradasAlvo);
		
		//Adiciona nesta cole��o a s�rie que representa os pontos por onde o mouse passou
		dataset.addSeries(seriesPosicoesMouseObstaculo);
		//Adiciona nesta cole��o a s�rie que representa os pontos pertencentes a funcao
		dataset.addSeries(seriesPosicoesAmostrasObstaculo);
		//Adiciona nesta cole��o a s�rie que representa os pontos n�o pertencentes a funcao
		dataset.addSeries(seriesPosicoesAmostrasErradasObstaculo);
		
		//Adiciona nesta cole��o a s�rie que representa as posi��es dos agentes
		dataset.addSeries(seriesPosicoesAgentes);
		
		dataset.addSeries(posicoesAntes);
		
		//dataset.addSeries(seriesCM[0]);
		
		//dataset.addSeries(seriesCM[1]);
		
		
        /*
        //Remove as s�ries do gr�fico anterior
        if(dataset.getSeriesCount()!=0){
        	dataset.removeAllSeries();
        	System.out.println("Removi todas as s�ries");
        } 
        //Adiciona nesta cole��o as 2 s�ries que representam os centros de massa
        for( int h = 0; h < seriesCM.length; h++)
        	dataset.addSeries(seriesCM[h]);
        
        //Adiciona nesta cole��o a s�rie que representa os pontos depois do operador
        dataset.addSeries(seriesPosicoesDepois);
        
        //Adiciona nesta cole��o a s�rie que representa os pontos antes do operador
        if(seriesPosicoesAntes!=null)
        	dataset.addSeries(seriesPosicoesAntes);
       */
       
      
        
        return dataset;
    }

  

    public static void main(final String[] args) {
    	//testando a classe....
        double[][] posA = {{1.7304785857617972 , -4.409133171859863},
        		{0.23319362379936373 , -6.083282052423094},
        		{-8.967296455466895 ,  0.1518616714090762},
        		{0.757469934571514  , -1.152460514680057 },
        		{1.0129280804179042 , -1.7342037308040774 }  };
        
        double[][] posD = {{0.7304785857617972 , -3.409133171859863},
        		{0.13319362379936373 , -4.083282052423094},
        		{-5.967296455466895 ,  0.1518616714090762},
        		{1.257469934571514  , -0.152460514680057 },
        		{1.0129280804179042 , -1.7342037308040774 }  };
        
        double[][] CMs = {{0.7304785857617972 , 3.409133171859863},
        		{0.43319362379936373 , 2.083282052423094}};
        
        SourceForGraphics font= new SourceForGraphics();
        //cria e mostra o grafico...
       final Grafico demo =new Grafico(font, "Teste", 1,false, 1000, 0, 1,-100,100 );
        //demo.pack();
        //RefineryUtilities.centerFrameOnScreen(demo);
        demo.setVisible(true);
        JFrame f = new JFrame("Ol� Mundo");
        f.add(demo);
        //demo.show();
        System.out.println(demo.getSize());
        f.setVisible(true);
      
        
        //createGraphicsFromReports(28, 29, "cycle[0]-Vollitive.txt", -100, 100, animacao);
    }

/*
    public static Grafico createGraphicsFromReports(String nomeArquivo, 
    									int dimensaoX, int dimensaoY, 
    									double minDomain, double maxDomain,
    									boolean animacao){
    	
    	fonte.lerArquivoSwarm(dimensaoX,dimensaoY, nomeArquivo);
        nomeArquivo = nomeArquivo.split(".txt")[0];
         //cria e mostra o grafico...
         Grafico demo = new Grafico(nomeArquivo, 1,animacao, 1000, dimensaoX, dimensaoY,minDomain,maxDomain );
         //demo.pack();
         //RefineryUtilities.centerFrameOnScreen(demo);
         demo.setVisible(true);
         
         return demo;
    }
    
    public static Grafico createGraphic(Vector<Peixe> peixes,
    										int dimensaoX, int dimensaoY, 
    										double minDomain, double maxDomain) {

		fonte.lerLivingSwarm(peixes, dimensaoX, dimensaoY);

		String nomeArquivo = "Cardume no Aquario";
		// cria e mostra o grafico...
		Grafico demo = new Grafico(nomeArquivo, 1, false, 1000, dimensaoX,
				dimensaoY, minDomain, maxDomain);
		// demo.pack();
		// RefineryUtilities.centerFrameOnScreen(demo);
		//demo.setVisible(true);
		//JFrame f = new JFrame("Cardume no Aquario");
		//f.add(demo);
		//Thread thread = new Thread(demo);
		//thread.start();

		// System.out.println(demo.getSize());
		//f.setSize(new java.awt.Dimension(650, 570));
		//f.setVisible(true);
		//f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

		return demo;
	}

*/
	
    public JFreeChart getChart() {
		return chart;
	}


	public void setChart(JFreeChart chart) {
		this.chart = chart;
	}


	public ChartPanel getChartPanel() {
		return chartPanel;
	}


	public void setChartPanel(ChartPanel chartPanel) {
		this.chartPanel = chartPanel;
	}



    
    
  

} 
