package algoritmo;

import auxiliar.Conversor;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;

/**
 *
 * @author Marília
 */
public class SensorFotografico extends SensorFitness {

    private BufferedImage mascara;
    private BufferedImage imagemAmbiente;
    
    private EspacoDeBusca espacoDeBusca;

    private int[] posicaoAgenteEmPx = new int[2];
    private int diametroDoSensorEmPx;
    int inicioSubImagemX;//ponto acima à esquerda
    int inicioSubImagemY;//ponto acima à esquerda
    int diferencaXInicialMascara;
    int diferencaYInicialMascara;

    //Valor Alvo da foto Padrão
    int alvoValorMinimoCorVermelha = 100;
    int alvoValorMaximoCorVermelha = 255;
    int alvoValorMinimoCorVerde = 0;
    int alvoValorMaximoCorVerde = 70;
    int alvoValorMinimoCorAzul = 0;
    int alvoValorMaximoCorAzul = 70;
    
    int temp = 0;
    int idAgenteDoSensor=0;

    public SensorFotografico(ConjuntoDeSolucoes conjuntoDeSolucoes, int idAgente, File imagem) {
        super(conjuntoDeSolucoes);
        setSensorDiametro(100);//em metros
        setCor(new java.awt.Color(255, 50, 50, 150));//cor que representa o sensor(vermelho)
        setNivelPrecisao(5);
        setErroAssociadoAoSensor(0);//pode ser neg. ou pos.
        inicializarAmbiente(imagem);
        inicializarMascara();
        setObjetivoEncontrado(false);
        this.idAgenteDoSensor = idAgente;
        
    }

    private void inicializarAmbiente(File imagem){
        
        espacoDeBusca = EspacoDeBusca.getInstance();
        if(imagem==null)
            imagemAmbiente = espacoDeBusca.getCanvas().getImagemAmbiente();//getCopia(espacoDeBusca.getCanvas().getImagemAmbiente());
        else{
            try {
                imagemAmbiente = ImageIO.read(imagem);
            } catch (IOException ex) {
                Logger.getLogger(SensorFotografico.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    private void inicializarMascara() {
        
        int[] alcanceSensor = Conversor.converterEscalaMetroParaEscalaImagem((int) getSensorDiametro(),
                                                                            (int) getSensorDiametro(),
                                                                            espacoDeBusca.getLimiteMaxCoordX(),
                                                                            espacoDeBusca.getLimiteMaxCoordY(),
                                                                            imagemAmbiente.getWidth(),
                                                                            imagemAmbiente.getHeight());

        diametroDoSensorEmPx = alcanceSensor[0];
        int width = diametroDoSensorEmPx;
        int height = diametroDoSensorEmPx;

        mascara = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics gr = mascara.createGraphics();
        gr.setColor(Color.BLACK);
        gr.fillRect(0, 0, width, height);
        gr.setColor(Color.WHITE);
        gr.fillOval(0, 0, width, height);  //aqui vai o desenho do poligono que você quer
        //gr.setColor(Color.GREEN);
        //gr.drawArc( 0, 0, width, height, 0, 360);

        /*try {
            ImageIO.write(mascara, "jpg", new File("images\\Sensor Fotografico\\mascara" + temp + ".jpg"));
         } catch (IOException ex) {
            Logger.getLogger(SensorFotografico.class.getName()).log(Level.SEVERE, null, ex);
        }*/
    }

    public Solucao sensorResponse(double[] posicao) {

        BufferedImage regiaoFotografada = fotografarRegiao(posicao);
        Solucao sensorResponse = avaliarRegigao(regiaoFotografada,posicao);//Calcula o fitness

        if (sensorResponse.getQtdPixelsComObjetivo() > getNivelPrecisao()) {
          
            sensorResponse.salvarRegiaoMapeada(idAgenteDoSensor);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
            setObjetivoEncontrado(true);
        } else {
            
            sensorResponse.setFotoRegiao(null);
            //sensorResponse.setOrigemVetorIndicacaoPosicao(null);// posicao do agente
            //sensorResponse.setVetorIndicacaoPosicao(null);//{0,0}
            setObjetivoEncontrado(false);
        }

        atualizarUtilidadesDasSolucoes(sensorResponse);
        atualizaMemoriaLocaisVisitados(sensorResponse);//<<<<<<<<<<<<<<<  salvar solucoes
        return sensorResponse;
    }

    public BufferedImage fotografarRegiao(double[] posicaoAgente) {

        BufferedImage subImagem = null;
        try {
            
            posicaoAgenteEmPx = Conversor.converterEscalaMetroParaEscalaImagem(posicaoAgente[0], posicaoAgente[1],
                                                                            espacoDeBusca.getLimiteMaxCoordX(),
                                                                            espacoDeBusca.getLimiteMaxCoordY(),
                                                                            imagemAmbiente.getWidth(),
                                                                            imagemAmbiente.getHeight());
            //enverter a escala do y
            posicaoAgenteEmPx[1] = Math.abs(imagemAmbiente.getHeight() - posicaoAgenteEmPx[1]);
            //System.out.println("posAgX:"+posicaoAgenteEmPx[0]+" | posAgY:"+posicaoAgenteEmPx[1]);
            inicioSubImagemX = posicaoAgenteEmPx[0] - diametroDoSensorEmPx / 2;
            inicioSubImagemY = posicaoAgenteEmPx[1] - diametroDoSensorEmPx / 2;
            //Testa se os vértices da subImagem estão dentro da imagem

            int diametroDoSensorEmPxDimX = diametroDoSensorEmPx;
            int diametroDoSensorEmPxDimY = diametroDoSensorEmPx;
            int diferenca;
            diferencaXInicialMascara = 0;
            diferencaYInicialMascara = 0;
            if(inicioSubImagemX <0){
                diferenca = 0-inicioSubImagemX;
                inicioSubImagemX = 0;
                diametroDoSensorEmPxDimX -= diferenca;
                diferencaXInicialMascara = diferenca;
            }
            if(inicioSubImagemY <0){
                diferenca = 0-inicioSubImagemY;
                inicioSubImagemY = 0;
                diametroDoSensorEmPxDimY -= diferenca;
                diferencaYInicialMascara = diferenca;
            }
            //PS: o que tem a maior diferença prevalece
            if(inicioSubImagemX+diametroDoSensorEmPx > imagemAmbiente.getWidth()){
                diferenca = (inicioSubImagemX+diametroDoSensorEmPx)-imagemAmbiente.getWidth();
                diametroDoSensorEmPxDimX -= diferenca;
            }
            if(inicioSubImagemY+diametroDoSensorEmPx > imagemAmbiente.getHeight()){
                diferenca = (inicioSubImagemY+diametroDoSensorEmPx)-imagemAmbiente.getHeight();
                diametroDoSensorEmPxDimY -= diferenca;
            }

            //System.out.println("inicioSubImagemX: "+ inicioSubImagemX+"  inicioSubImagemY:"+inicioSubImagemY);
            //System.out.println("fimSubImagemX: "+ (inicioSubImagemX+diametroDoSensorEmPxDimX)+"  fimSubImagemY:"+(inicioSubImagemY+diametroDoSensorEmPxDimY));
            subImagem = imagemAmbiente.getSubimage(inicioSubImagemX, inicioSubImagemY, diametroDoSensorEmPxDimX, diametroDoSensorEmPxDimY);
            

        } catch (Exception e) {
            e.printStackTrace();
        }
        return getCopia(subImagem);
    }

    //retorna vetor com origem no ponto mais proximo que vai até o ponto mais longe do tubo encontrado
    public Solucao avaliarRegigao(BufferedImage regiaoFotografada,double[] posicaoAgente){

            Solucao solucao = new Solucao(getMemoriaDeSolucoes().getNumSolucoes());
            solucao.setPosicao(posicaoAgente);
            solucao.setRaioDaAreaDaImagemEmMetros(getSensorDiametro()/2);


            //Atributo para manipular a imagem fotografada (o resultado é esta mesma imagem modificada)
            Graphics graphics2D = regiaoFotografada.createGraphics();

            int widthFotografia = regiaoFotografada.getWidth();
            int heightFotografia = regiaoFotografada.getHeight();
            int widthMascara = mascara.getWidth();
            int heightMascara = mascara.getHeight();
           
            int pontos_img[] = new int[widthFotografia * heightFotografia];
            regiaoFotografada.getRGB(0, 0, widthFotografia, heightFotografia, pontos_img, 0, widthFotografia);

            int pontos_mask[] = new int[widthMascara * heightMascara];
            mascara.getRGB(0, 0, widthMascara, heightMascara, pontos_mask, 0, widthMascara);
            
            int[] posicaoAgenteNaSubImgemEmPx = new int[2];
            posicaoAgenteNaSubImgemEmPx[0]= (int) (diametroDoSensorEmPx/2 - diferencaXInicialMascara);//diferenca caso o agente esteja nas pontas onde não podemos avaliar toda a area do sensor
            posicaoAgenteNaSubImgemEmPx[1]= (int) (diametroDoSensorEmPx/2 - diferencaYInicialMascara);

            //Para definir vetor que está presente no cálculo do lbest
            int[] posicaoPontoComDistMinimaEmPx1 = new int[2];//do primeiro quadrante
            int[] posicaoPontoComDistMaximaEmPx1 = new int[2];//do primeiro quadrante
            double distanciaMinima1 = (diametroDoSensorEmPx/2) + 1; //raio+1 //do primeiro quadrante
            double distanciaMaxima1 = 0;//do primeiro quadrante

            int[] posicaoPontoComDistMinimaEmPx2 = new int[2];//do segundo quadrante
            int[] posicaoPontoComDistMaximaEmPx2 = new int[2];//do segundo quadrante
            double distanciaMinima2 = (diametroDoSensorEmPx/2) + 1; //raio+1 //do segundo quadrante
            double distanciaMaxima2 = 0;//do segundo quadrante

            int[] posicaoPontoComDistMinimaEmPx3 = new int[2];//do terceiro quadrante
            int[] posicaoPontoComDistMaximaEmPx3 = new int[2];//do terceiro quadrante
            double distanciaMinima3 = (diametroDoSensorEmPx/2) + 1; //raio+1 //do terceiro quadrante
            double distanciaMaxima3 = 0;//do terceiro quadrante

            int[] posicaoPontoComDistMinimaEmPx4 = new int[2];//do quarto quadrante
            int[] posicaoPontoComDistMaximaEmPx4 = new int[2];//do quarto quadrante
            double distanciaMinima4 = (diametroDoSensorEmPx/2) + 1; //raio+1 //do quarto quadrante
            double distanciaMaxima4 = 0;//do quarto quadrante

            double dist = 0;

            //System.out.println("posicaoAgenteNaSubImgemEmPx: " + posicaoAgenteNaSubImgemEmPx[0] + "," + posicaoAgenteNaSubImgemEmPx[1]);
            int indice, indiceMascara;//índice do pixel no array de pixels
            Color corDoPixel;
            int numPixelsComTub = 0;

            //BufferedImage imagemCrua = getCopia(regiaoFotografada);
            //Graphics graphics2DImagemCrua = imagemCrua.getGraphics();

            for (int linha = 0, linhaMask = linha+diferencaYInicialMascara;
                 linha < heightFotografia && linhaMask <heightMascara;
                 linha++, linhaMask++) {
                for (int coluna = 0, colunaMask = coluna + diferencaXInicialMascara;
                     coluna < widthFotografia && colunaMask <widthMascara;
                     coluna++, colunaMask++) {


                    indice = linha * widthFotografia + coluna;
                    indiceMascara = (linhaMask)* (widthMascara) + (colunaMask);

                    /*Compara mascara com imagem. A imagem vai receber as regiões pretas da máscara*/
                    pontos_img[indice] = pontos_img[indice] & pontos_mask[indiceMascara];
                    corDoPixel = new Color(pontos_img[indice]);

                    int red = corDoPixel.getRed();
                    int green = corDoPixel.getGreen();
                    int blue = corDoPixel.getBlue();
                   
                    //if (red != 0 && green != 0 && blue != 0) {
                        //Se a cor do pixel for a cor que representa o tubo 
                        if (   red <= alvoValorMaximoCorVermelha
                            && red >= alvoValorMinimoCorVermelha
                            && green <= alvoValorMaximoCorVerde
                            && green >= alvoValorMinimoCorVerde
                            && blue <= alvoValorMaximoCorAzul
                            && blue >= alvoValorMinimoCorAzul)
                        {
                            //Pinta o pixel de branco
                            graphics2D.setColor(Color.WHITE);//Cor que os pixels de tubo serão pintados
                            graphics2D.drawLine(coluna, linha, coluna, linha);
                             //Adiciona o numero de pixels que representam o tubo
                            numPixelsComTub++;
                            

                            //Distancia euclidiana do agente até o pixel
                            dist = Math.sqrt(Math.pow((coluna - posicaoAgenteNaSubImgemEmPx[0]), 2) + Math.pow(linha - posicaoAgenteNaSubImgemEmPx[1], 2));

                            int quadrante = determinarQuadrante(coluna, linha, posicaoAgenteNaSubImgemEmPx);

                            if(quadrante==1){// determina o minimo e o maximo do quadrante 1
                                if (dist < distanciaMinima1) {
                                    distanciaMinima1 = dist;
                                    posicaoPontoComDistMinimaEmPx1[0] = coluna;//x
                                    posicaoPontoComDistMinimaEmPx1[1] = linha;//y
                                }
                                if (dist > distanciaMaxima1) {
                                    distanciaMaxima1 = dist;
                                    posicaoPontoComDistMaximaEmPx1[0] = coluna;//x
                                    posicaoPontoComDistMaximaEmPx1[1] = linha;//y

                                }
                            }else if(quadrante==2){ // determina o minimo e o maximo do quadrante 2
                                if (dist < distanciaMinima2) {
                                    distanciaMinima2 = dist;
                                    posicaoPontoComDistMinimaEmPx2[0] = coluna;//x
                                    posicaoPontoComDistMinimaEmPx2[1] = linha;//y
                                }
                                if (dist > distanciaMaxima2) {
                                    distanciaMaxima2 = dist;
                                    posicaoPontoComDistMaximaEmPx2[0] = coluna;//x
                                    posicaoPontoComDistMaximaEmPx2[1] = linha;//y
                                }
                            }else if(quadrante==3){ // determina o minimo e o maximo do quadrante 2
                                if (dist < distanciaMinima3) {
                                    distanciaMinima3 = dist;
                                    posicaoPontoComDistMinimaEmPx3[0] = coluna;//x
                                    posicaoPontoComDistMinimaEmPx3[1] = linha;//y
                                }
                                if (dist > distanciaMaxima3) {
                                    distanciaMaxima3 = dist;
                                    posicaoPontoComDistMaximaEmPx3[0] = coluna;//x
                                    posicaoPontoComDistMaximaEmPx3[1] = linha;//y
                                }
                            }else if(quadrante==4){ // determina o minimo e o maximo do quadrante 2
                                if (dist < distanciaMinima4) {
                                    distanciaMinima4 = dist;
                                    posicaoPontoComDistMinimaEmPx4[0] = coluna;//x
                                    posicaoPontoComDistMinimaEmPx4[1] = linha;//y
                                }
                                if (dist > distanciaMaxima4) {
                                    distanciaMaxima4 = dist;
                                    posicaoPontoComDistMaximaEmPx4[0] = coluna;//x
                                    posicaoPontoComDistMaximaEmPx4[1] = linha;//y
                                }
                            }
                            
                            
                        }
                        else{//Se a cor do pixel não for a cor que representa o tubo
                            graphics2D.setColor(Color.BLACK);
                            graphics2D.drawLine(coluna, linha, coluna, linha);
                        }
                    /*}else{//se pixel preto
                        graphics2D.setColor(Color.BLACK);
                        graphics2D.drawLine(coluna, linha, coluna, linha);
                        //Pinta o pixel de cinza
                        //graphics2DImagemCrua.setColor(Color.GRAY);
                        //graphics2DImagemCrua.drawLine(coluna, linha, coluna, linha);
                    }*/
                }//Fim for de colunas
            }//Fim for de linha
        /*
        try {
            ImageIO.write(imagemCrua, "jpg", new File("images\\Sensor Fotografico\\imagemCrua" + temp + ".jpg"));
            ImageIO.write(mascara, "jpg", new File("images\\Sensor Fotografico\\mascara" + temp + ".bmp"));
         } catch (IOException ex) {
            Logger.getLogger(SensorFotografico.class.getName()).log(Level.SEVERE, null, ex);
        }*/
            //System.out.println("distancia Mínima:" + distanciaMinima);
            //System.out.println("posicaoPontoComDistMinimaEmPx: " + posicaoPontoComDistMinimaEmPx[0] + "," + posicaoPontoComDistMinimaEmPx[1]);
            //System.out.println("posicaoPontoComDistMaximaEmPx1: " + posicaoPontoComDistMaximaEmPx1[0] + "," + posicaoPontoComDistMaximaEmPx1[1]);

            if(posicaoPontoComDistMinimaEmPx1[0]!=0 && posicaoPontoComDistMinimaEmPx1[1]!=0){
                //se achou tubulação
                //graphics2D.setColor(Color.BLUE);
                //graphics2D.drawLine(posicaoPontoComDistMinimaEmPx1[0], posicaoPontoComDistMinimaEmPx1[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx1[0], posicaoPontoComDistMaximaEmPx1[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.setColor(Color.RED);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx1[0], posicaoPontoComDistMaximaEmPx1[1], posicaoPontoComDistMinimaEmPx1[0], posicaoPontoComDistMinimaEmPx1[1]);
            }else{
                //Se não tiver achado nada, as posicões dos pontos com distancia minima e máxima serão a própria posicao do agente e o vetor, portanto, será nulo {0,0}
                posicaoPontoComDistMinimaEmPx1 = posicaoAgenteNaSubImgemEmPx;
                posicaoPontoComDistMaximaEmPx1 = posicaoAgenteNaSubImgemEmPx;
            }

            if(posicaoPontoComDistMinimaEmPx2[0]!=0 && posicaoPontoComDistMinimaEmPx2[1]!=0){
                //se achou tubulação
                //graphics2D.setColor(Color.BLUE);
                //graphics2D.drawLine(posicaoPontoComDistMinimaEmPx2[0], posicaoPontoComDistMinimaEmPx2[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx2[0], posicaoPontoComDistMaximaEmPx2[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.setColor(Color.RED);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx2[0], posicaoPontoComDistMaximaEmPx2[1], posicaoPontoComDistMinimaEmPx2[0], posicaoPontoComDistMinimaEmPx2[1]);
            }else{
                //Se não tiver achado nada, as posicões dos pontos com distancia minima e máxima serão a própria posicao do agente e o vetor, portanto, será nulo {0,0}
                posicaoPontoComDistMinimaEmPx2 = posicaoAgenteNaSubImgemEmPx;
                posicaoPontoComDistMaximaEmPx2 = posicaoAgenteNaSubImgemEmPx;
            }

            if(posicaoPontoComDistMinimaEmPx3[0]!=0 && posicaoPontoComDistMinimaEmPx3[1]!=0){
                //se achou tubulação
                //graphics2D.setColor(Color.BLUE);
                //graphics2D.drawLine(posicaoPontoComDistMinimaEmPx3[0], posicaoPontoComDistMinimaEmPx3[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx3[0], posicaoPontoComDistMaximaEmPx3[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.setColor(Color.RED);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx3[0], posicaoPontoComDistMaximaEmPx3[1], posicaoPontoComDistMinimaEmPx3[0], posicaoPontoComDistMinimaEmPx3[1]);
            }else{
                //Se não tiver achado nada, as posicões dos pontos com distancia minima e máxima serão a própria posicao do agente e o vetor, portanto, será nulo {0,0}
                posicaoPontoComDistMinimaEmPx3 = posicaoAgenteNaSubImgemEmPx;
                posicaoPontoComDistMaximaEmPx3 = posicaoAgenteNaSubImgemEmPx;
            }

            if(posicaoPontoComDistMinimaEmPx4[0]!=0 && posicaoPontoComDistMinimaEmPx4[1]!=0){
                //se achou tubulação
                //graphics2D.setColor(Color.BLUE);
                //graphics2D.drawLine(posicaoPontoComDistMinimaEmPx4[0], posicaoPontoComDistMinimaEmPx4[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx4[0], posicaoPontoComDistMaximaEmPx4[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                //graphics2D.setColor(Color.RED);
                //graphics2D.drawLine(posicaoPontoComDistMaximaEmPx4[0], posicaoPontoComDistMaximaEmPx4[1], posicaoPontoComDistMinimaEmPx4[0], posicaoPontoComDistMinimaEmPx4[1]);
            }else{
                //Se não tiver achado nada, as posicões dos pontos com distancia minima e máxima serão a própria posicao do agente e o vetor, portanto, será nulo {0,0}
                posicaoPontoComDistMinimaEmPx4 = posicaoAgenteNaSubImgemEmPx;
                posicaoPontoComDistMaximaEmPx4 = posicaoAgenteNaSubImgemEmPx;
            }

            //System.out.println("Centro: " + posicaoAgenteNaSubImgemEmPx[0]+","+ posicaoAgenteNaSubImgemEmPx[1]);
            //System.out.println("Minimo (1): " + posicaoPontoComDistMinimaEmPx1[0]+","+ posicaoPontoComDistMinimaEmPx1[1]);
            //System.out.println("Minimo (2): " + posicaoPontoComDistMinimaEmPx2[0]+","+ posicaoPontoComDistMinimaEmPx2[1]);
            //System.out.println("Minimo (3): " + posicaoPontoComDistMinimaEmPx3[0]+","+ posicaoPontoComDistMinimaEmPx3[1]);
            //System.out.println("Minimo (4): " + posicaoPontoComDistMinimaEmPx4[0]+","+ posicaoPontoComDistMinimaEmPx4[1]);
            temp++;

            //Converte as coordenadas do ponto na foto para coordenadas correspondentes na imagem ambiente(não é conversão de escalas)
            posicaoPontoComDistMinimaEmPx1 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMinimaEmPx1);
            posicaoPontoComDistMaximaEmPx1 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMaximaEmPx1);

            posicaoPontoComDistMinimaEmPx2 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMinimaEmPx2);
            posicaoPontoComDistMaximaEmPx2 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMaximaEmPx2);

            posicaoPontoComDistMinimaEmPx3 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMinimaEmPx3);
            posicaoPontoComDistMaximaEmPx3 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMaximaEmPx3);

            posicaoPontoComDistMinimaEmPx4 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMinimaEmPx4);
            posicaoPontoComDistMaximaEmPx4 = coordNaFotoParaCoordNaImagemAmbiente(posicaoPontoComDistMaximaEmPx4);

            int[] vetorLbestQuadrante1EmPx = new int[2];//vetor com origem no ponto mais proximo e final no ponto mais longe
            vetorLbestQuadrante1EmPx[0] = posicaoPontoComDistMaximaEmPx1[0] - posicaoPontoComDistMinimaEmPx1[0];
            vetorLbestQuadrante1EmPx[1] = posicaoPontoComDistMaximaEmPx1[1] - posicaoPontoComDistMinimaEmPx1[1];

            int[] vetorLbestQuadrante2EmPx = new int[2];//vetor com origem no ponto mais proximo e final no ponto mais longe
            vetorLbestQuadrante2EmPx[0] = posicaoPontoComDistMaximaEmPx2[0] - posicaoPontoComDistMinimaEmPx2[0];
            vetorLbestQuadrante2EmPx[1] = posicaoPontoComDistMaximaEmPx2[1] - posicaoPontoComDistMinimaEmPx2[1];

            int[] vetorLbestQuadrante3EmPx = new int[2];//vetor com origem no ponto mais proximo e final no ponto mais longe
            vetorLbestQuadrante3EmPx[0] = posicaoPontoComDistMaximaEmPx3[0] - posicaoPontoComDistMinimaEmPx3[0];
            vetorLbestQuadrante3EmPx[1] = posicaoPontoComDistMaximaEmPx3[1] - posicaoPontoComDistMinimaEmPx3[1];

            int[] vetorLbestQuadrante4EmPx = new int[2];//vetor com origem no ponto mais proximo e final no ponto mais longe
            vetorLbestQuadrante4EmPx[0] = posicaoPontoComDistMaximaEmPx4[0] - posicaoPontoComDistMinimaEmPx4[0];
            vetorLbestQuadrante4EmPx[1] = posicaoPontoComDistMaximaEmPx4[1] - posicaoPontoComDistMinimaEmPx4[1];
           
            //System.out.println("posicaoPontoComDistMinimaEmPx: (coord imagem) " + posicaoPontoComDistMinimaEmPx[0] + "," + posicaoPontoComDistMinimaEmPx[1]);
            
            double[] posTemp1 = converterPxParaMetro(posicaoPontoComDistMinimaEmPx1,false);
            double[] posTemp2 = converterPxParaMetro(posicaoPontoComDistMaximaEmPx1,false);
            double[] posTemp3 = converterPxParaMetro(vetorLbestQuadrante1EmPx,true);
            //System.out.println("vetorLbestEmPx: " + vetorLbestEmPx[0] + "," + vetorLbestEmPx[1]);
            System.out.println("posicaoPontoComDistMinimaEmMetros: " + posTemp1[0] + "," + posTemp1[1]);
            System.out.println("posicaoPontoComDistMaximaEmMetros: " + posTemp2[0] + "," + posTemp2[1]);
            System.out.println("vetorLbestEmMetros: " + posTemp3[0] + "," + posTemp3[1]);

            solucao.setQtdPixelsComObjetivo(numPixelsComTub);

            solucao.setOrigemVetorIndicacaoPosicaoQuadrante1( converterPxParaMetro(posicaoPontoComDistMinimaEmPx1,false) );
            solucao.setVetorIndicacaoPosicaoQuadrante1( converterPxParaMetro(vetorLbestQuadrante1EmPx,true) );

            solucao.setOrigemVetorIndicacaoPosicaoQuadrante2( converterPxParaMetro(posicaoPontoComDistMinimaEmPx2,false) );
            solucao.setVetorIndicacaoPosicaoQuadrante2( converterPxParaMetro(vetorLbestQuadrante2EmPx,true) );

            solucao.setOrigemVetorIndicacaoPosicaoQuadrante3( converterPxParaMetro(posicaoPontoComDistMinimaEmPx3,false) );
            solucao.setVetorIndicacaoPosicaoQuadrante3( converterPxParaMetro(vetorLbestQuadrante3EmPx,true) );

            solucao.setOrigemVetorIndicacaoPosicaoQuadrante4( converterPxParaMetro(posicaoPontoComDistMinimaEmPx4,false) );
            solucao.setVetorIndicacaoPosicaoQuadrante4( converterPxParaMetro(vetorLbestQuadrante4EmPx,true) );

            solucao.setFotoRegiao(regiaoFotografada);
           
            return solucao;
    }

    public int[] coordNaFotoParaCoordNaImagemAmbiente(int[] pontoNaFoto){
        int[] pontoCoordImagemAmbiente = new int[2];
        //inicioSubImagemX e inicioSubImagemY correspondem ao ponto 0,0 da foto
        pontoCoordImagemAmbiente[0] = inicioSubImagemX + pontoNaFoto[0];
        pontoCoordImagemAmbiente[1] = inicioSubImagemY + pontoNaFoto[1];
        return pontoCoordImagemAmbiente;
    }

    public double[] converterPxParaMetro(int[] vetorOuPontoEmPx, boolean isVetor){

         double[] vetorOuPontoEmMetros = Conversor.converterEscalaImagemParaEscalaMetro(vetorOuPontoEmPx[0],vetorOuPontoEmPx[1],
                                                              imagemAmbiente.getWidth(),
                                                              imagemAmbiente.getHeight(),
                                                              espacoDeBusca.getLimiteMaxCoordX(),
                                                              espacoDeBusca.getLimiteMaxCoordY());
         if(!isVetor){
            //Desenverte y
            vetorOuPontoEmMetros[1] = Math.abs(vetorOuPontoEmMetros[1] - espacoDeBusca.getLimiteMaxCoordY());
         }else{//se for vetor
             vetorOuPontoEmMetros[1] = -vetorOuPontoEmMetros[1];//inverte sinal
         }
         return vetorOuPontoEmMetros;
 
    }

    public void setCorAlvo(int alvoValorMinimoCorVermelha,
                            int alvoValorMaximoCorVermelha,
                            int alvoValorMinimoCorVerde,
                            int alvoValorMaximoCorVerde,
                            int alvoValorMinimoCorAzul,
                            int alvoValorMaximoCorAzul){
        
        this.alvoValorMinimoCorVermelha = alvoValorMinimoCorVermelha;
        this.alvoValorMaximoCorVermelha = alvoValorMaximoCorVermelha;
        this.alvoValorMinimoCorVerde = alvoValorMinimoCorVerde;
        this.alvoValorMaximoCorVerde = alvoValorMaximoCorVerde ;
        this.alvoValorMinimoCorAzul = alvoValorMinimoCorAzul;
        this.alvoValorMaximoCorAzul = alvoValorMaximoCorAzul;
    }

    public BufferedImage construirMapa(){
        ConjuntoDeSolucoes memoriaDeSolucoes = getMemoriaDeSolucoes();
        int widthMapa = imagemAmbiente.getWidth();
        int heightMapa = imagemAmbiente.getHeight();
        int widthFotoDaSolucao;
        int heightFotoDaSolucao;
        int inicioFotoX;
        int inicioFotoY;
        int indice;
        BufferedImage mapa = new BufferedImage(widthMapa, heightMapa, BufferedImage.TYPE_INT_RGB);
        BufferedImage fotoDaSolucao;

        int pontos_mapa[] = new int[widthMapa * heightMapa];
        mapa.getRGB(0, 0, widthMapa, heightMapa, pontos_mapa, 0, widthMapa);

        int pontos_fotoDaSolucao[];

        int[] posicaoEmPx;
        Solucao solucao;
        try {
            for(int i=0;i<memoriaDeSolucoes.getNumSolucoes();i++){
                solucao = memoriaDeSolucoes.get(i);
                if(solucao.getFotoRegiao()!=null){
                    
                        fotoDaSolucao = ImageIO.read(new File("images\\Sensor Fotografico\\FotoDeRegiao-Ag"+idAgenteDoSensor+"foto"+ solucao.getIdSolucao() + ".png"));
                        widthFotoDaSolucao = fotoDaSolucao.getWidth();
                        heightFotoDaSolucao = fotoDaSolucao.getHeight();
                        pontos_fotoDaSolucao = new int[widthFotoDaSolucao * heightFotoDaSolucao];
                        fotoDaSolucao.getRGB(0, 0, widthFotoDaSolucao, heightFotoDaSolucao, pontos_fotoDaSolucao, 0, widthFotoDaSolucao);
                        posicaoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(solucao.getPosicao()[0], solucao.getPosicao()[1], espacoDeBusca.getLimiteMaxCoordX(), espacoDeBusca.getLimiteMaxCoordY(), mapa.getWidth(), mapa.getHeight());
                        //enverter a escala do y
                        posicaoEmPx[1] = Math.abs(mapa.getHeight() - posicaoEmPx[1]);

                        inicioFotoX = posicaoEmPx[0] - diametroDoSensorEmPx / 2;
                        inicioFotoY = posicaoEmPx[1] - diametroDoSensorEmPx / 2;

                        if(inicioFotoX <0){
                           inicioFotoX = 0;
                        }
                        if(inicioFotoY <0){
                            inicioFotoY = 0;
                        }
                        int indiceFotoSolucao=0;
                        for (int linha = 0; linha < heightMapa; linha++) {
                            for (int coluna = 0; coluna < widthMapa; coluna++) {
                                indice = linha * widthMapa + coluna;
                                if(linha>=inicioFotoY && linha<(inicioFotoY+heightFotoDaSolucao)
                                        && coluna>=inicioFotoX && coluna<(inicioFotoX+widthFotoDaSolucao)){
                                    if( pontos_fotoDaSolucao[indiceFotoSolucao]!=Color.LIGHT_GRAY.getRGB()){
                                        pontos_mapa[indice] = pontos_mapa[indice] | pontos_fotoDaSolucao[indiceFotoSolucao];
                                    }
                                    indiceFotoSolucao++;
                                }
                            }
                        }


                }

            }//para cada solucao

            mapa.setRGB(0, 0, widthMapa, heightMapa, pontos_mapa, 0, widthMapa);
            ImageIO.write( mapa, "jpg", new File("images\\Sensor Fotografico\\mapa-Ag" + idAgenteDoSensor+ ".jpg"));
        } catch (IOException ex) {
                    Logger.getLogger(SensorFotografico.class.getName()).log(Level.SEVERE, null, ex);
        }
       return mapa;
    }

    public BufferedImage getCopia(BufferedImage in) {

            BufferedImage temp = new BufferedImage(in.getWidth(), in.getHeight(),BufferedImage.TYPE_INT_RGB);
            Graphics2D g2d = temp.createGraphics();
            g2d.drawImage(in, null, 0, 0);

            return temp;
    }

    public int determinarQuadrante(int coluna, int linha, int[] centro){
        //quandrantes como em geometria e trigonometria,i.e. contados sentido anti-horario
        if(coluna >= centro[0] && linha <=centro[1]){
            return 1;
        }else if (coluna <= centro[0] && linha <=centro[1]){
            return 2;
        }else if (coluna <= centro[0] && linha >=centro[1]){
            return 3;
        }else if (coluna >= centro[0] && linha >=centro[1]){
            return 4;
        }else//pixel central
            return 1;
    }

     public Solucao estabelecerMelhorSolucaoPossivel(){
        //Atributo para manipular a imagem fotografada (o resultado é esta mesma imagem modificada)
            int width = imagemAmbiente.getWidth();
            int height = imagemAmbiente.getHeight();

            BufferedImage regiaoFotografada = this.getCopia(imagemAmbiente.getSubimage(0, 0, width, height));
            Graphics graphics2D =regiaoFotografada.createGraphics();

            int pontos_img[] = new int[width * height];
            regiaoFotografada.getRGB(0, 0, width, height, pontos_img, 0, width);


            //System.out.println("posicaoAgenteNaSubImgemEmPx: " + posicaoAgenteNaSubImgemEmPx[0] + "," + posicaoAgenteNaSubImgemEmPx[1]);
            int indice;//índice do pixel no array de pixels
            Color corDoPixel;
            int numPixelsComTub = 0;

            //BufferedImage imagemCrua = getCopia(regiaoFotografada);
            //Graphics graphics2DImagemCrua = imagemCrua.getGraphics();

            for (int linha = 0; linha < height; linha++) {
                for (int coluna = 0;coluna < width ; coluna++) {


                    indice = linha * width + coluna;


                    /*Compara mascara com imagem. A imagem vai receber as regiões pretas da máscara*/
                    //pontos_img[indice] = pontos_img[indice] & pontos_mask[indice];
                    corDoPixel = new Color(pontos_img[indice]);

                    int red = corDoPixel.getRed();
                    int green = corDoPixel.getGreen();
                    int blue = corDoPixel.getBlue();

                    //if (red != 0 && green != 0 && blue != 0) {
                        //Se a cor do pixel for a cor que representa o tubo
                        if (   red <= alvoValorMaximoCorVermelha
                            && red >= alvoValorMinimoCorVermelha
                            && green <= alvoValorMaximoCorVerde
                            && green >= alvoValorMinimoCorVerde
                            && blue <= alvoValorMaximoCorAzul
                            && blue >= alvoValorMinimoCorAzul)
                        {
                            //Pinta o pixel de branco
                            graphics2D.setColor(Color.WHITE);//Cor que os pixels de tubo serão pintados
                            graphics2D.drawLine(coluna, linha, coluna, linha);
                             //Adiciona o numero de pixels que representam o tubo
                            numPixelsComTub++;

                        }
                        else{//Se a cor do pixel não for a cor que representa o tubo
                            graphics2D.setColor(Color.BLACK);
                            graphics2D.drawLine(coluna, linha, coluna, linha);
                        }
                    /*}else{//se pixel preto
                        //Pinta o pixel de cinza
                        graphics2D.setColor(Color.BLACK);
                        graphics2D.drawLine(coluna, linha, coluna, linha);
                        //graphics2DImagemCrua.setColor(Color.GRAY);
                        //graphics2DImagemCrua.drawLine(coluna, linha, coluna, linha);
                    }*/
                }//Fim for de colunas
            }//Fim for de linha


            Solucao solucao = new Solucao(10000);
            solucao.setFotoRegiao(regiaoFotografada);

            try{
                ImageIO.write( regiaoFotografada, "jpg", new File("images\\Sensor Fotografico\\mapaSolucaoIdeal.png"));
            } catch (Exception e) {
                 e.printStackTrace();
            }
            System.out.println("Salvou Imagem Ideal");
            System.out.println("Num. Pixels com Tubo: "+ numPixelsComTub);
            return solucao;
    }



    //----------------------MAIN------------------------//
    @SuppressWarnings("empty-statement")
    public static void main(String[] args) {
        ConjuntoDeSolucoes memoriaSolucoes = new ConjuntoDeSolucoes();
        SensorFotografico temp = new SensorFotografico(memoriaSolucoes,0, new File("src\\imagens\\Exemplos de Ambientes\\ModeloAmbiente1420x800comTubos.jpg"));
        
        double[] posicao = {646,689};//{500,280};//{603,480};//em metros
        BufferedImage regiaoFotografada = temp.fotografarRegiao(posicao);
        Solucao sensorResponse = temp.avaliarRegigao(regiaoFotografada,posicao);//Calcula o fitness
        sensorResponse.salvarRegiaoMapeada(0);
        System.out.println("OrigemVetorIndicacaoPosicao: "+sensorResponse.getOrigemVetorIndicacaoPosicaoQuadrante1()[0]+","+sensorResponse.getOrigemVetorIndicacaoPosicaoQuadrante1()[1]);
        System.out.println("VetorIndicacaoPosicao: "+sensorResponse.getVetorIndicacaoPosicaoQuadrante1()[0]+","+sensorResponse.getVetorIndicacaoPosicaoQuadrante1()[1]);
        System.out.println("MelhorPosicao: "+sensorResponse.getMelhorPosicaoQuadrante1()[0]+","+sensorResponse.getMelhorPosicaoQuadrante1()[1]);
        System.out.println("QtdPixels: "+sensorResponse.getQtdPixelsComObjetivo());

        double y = 0, n = 0, m = 0;
        double x = 0;
        double dist = 0;
        int graus = 90;
        for (double a = 0; a <= graus; a=a+2.5) {
            m = 5 * Math.sin(Math.toRadians(a));//y
            n = 5 * Math.cos(Math.toRadians(a));//x
            y += m;
            x += n;
            dist += Math.sqrt(Math.pow(n,2)+Math.pow(m,2));
            //System.out.println("sen " + a + "=" + Math.sin(Math.toRadians(a)));
        }
        /*
        System.out.println("y=" + y);
        System.out.println("x=" + x);
        System.out.println("distancia Percorrida (Arco) Para Virar "+graus+" Graus: " + dist);
        double distPercorridaParaVirarAlfaGraus = Math.sqrt(Math.pow(x,2)+Math.pow(y,2));
        System.out.println("distancia Percorrida (reta) Para Virar "+graus+" Graus: " + distPercorridaParaVirarAlfaGraus
         * */
    }

    //pega o tempo do sistema
    public static String now(String dateFormat) {
        Calendar cal = Calendar.getInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        return sdf.format(cal.getTime());
    }

    public void testeSensorFotografico(double[] posicao) {
        //http://www.guj.com.br/posts/list/102293.java#552004
        //http://javaboutique.internet.com/tutorials/rasters/
        //http://javaboutique.internet.com/tutorials/rasters2/
        try {
            BufferedImage imagemPrincipal = ImageIO.read(new File("src\\imagens\\Exemplos de Ambientes\\modeloAmbienteMarinho1027x655.jpg"));
            BufferedImage image = new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
            //////
            posicao = new double[2];
            posicao[0] = 603;//420;
            posicao[1] = 480;//130;
            /////
            System.out.println("iniciou");

            for (int h = 0; h < 1; h++) {//para 20 agentes
                System.out.println("número de agentes:" + h);
                int[] posicaoEmPx = new int[2];
                posicaoEmPx = Conversor.converterEscalaMetroParaEscalaImagem(posicao[0],
                        posicao[1],
                        1027,
                        655,
                        1027,
                        655);
                //System.out.println("posicaoPx[0]: "+ posicaoAgenteEmPx[0]+"| posicaoAgente[1]: "+ posicaoAgenteEmPx[1]);
                //desenverter a escala do y
                posicaoEmPx[1] = Math.abs(imagemPrincipal.getHeight() - posicaoEmPx[1]);
                setSensorDiametro(207);
                EspacoDeBusca espacoDeBusca = EspacoDeBusca.getInstance();
                int[] alcanceSensor = Conversor.converterEscalaMetroParaEscalaImagem((int) getSensorDiametro(),
                        (int) getSensorDiametro(),
                        espacoDeBusca.getLimiteMaxCoordX(),
                        espacoDeBusca.getLimiteMaxCoordY(),
                        imagemPrincipal.getWidth(),
                        imagemPrincipal.getHeight());

                int diametroDoSensor = alcanceSensor[0];//antes 300 , agora 100
                //posicaoAgenteEmPx = Conversor.ajustarEscala(posicaoAgenteEmPx);
                int inicioSubImagemX = posicaoEmPx[0] - diametroDoSensor / 2;
                int inicioSubImagemY = posicaoEmPx[1] - diametroDoSensor / 2;

                image = imagemPrincipal.getSubimage(inicioSubImagemX, inicioSubImagemY, diametroDoSensor, diametroDoSensor);

                int width = image.getWidth();
                int height = image.getHeight();
                int width2 = diametroDoSensor;
                int height2 = diametroDoSensor;
                /*System.out.println("posicaoPx[0]: "+ posicaoAgenteEmPx[0]+"| posicaoAgente[1]: "+ posicaoAgenteEmPx[1]
                +"| InicioSubImagemX: "+ inicioSubImagemX +"| InicioSubImagemY: "+ inicioSubImagemY
                +"| WidthSubImagem: "+ width +"| HeightSubImagem: "+ height
                +"| width2: "+ width2 +"| heigh2t: "+ height2);
                 */
                BufferedImage mascara = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                Graphics gr = mascara.createGraphics();
                gr.setColor(Color.BLACK);
                gr.fillRect(0, 0, width, height);
                gr.setColor(Color.WHITE);
                gr.fillOval(0, 0, width, height);  //aqui vai o desenho do poligono que você quer

                //ImageIO.write(mascara, "gif", new File("images\\Sensor Fotografico\\teste1.gif"));

                int pontos_img[] = new int[width * height];
                image.getRGB(0, 0, width, height, pontos_img, 0, width);

                int pontos_mask[] = new int[width * height];
                mascara.getRGB(0, 0, width, height, pontos_mask, 0, width);

                int contadorLinha = 0;
                int contadorColuna = 0;
                StringBuffer string = new StringBuffer();
                StringBuffer string2 = new StringBuffer();
                //IndexColorModel.getRGBdefault().getComponents(width, pontos_mask, height) //colorModel;
                Color myColor;

                StringBuffer strTub = new StringBuffer();
                StringBuffer strMar = new StringBuffer();
                StringBuffer strNad = new StringBuffer();
                StringBuffer strPla = new StringBuffer();
                strTub.append("tub:");
                strMar.append("mar:");
                strNad.append("nad:");
                strPla.append("pla:");
                int numPixelComTub = 0;
                int numPixelComMar = 0;
                int numPixelComNad = 0;
                int numPixelComPla = 0;
                BufferedImage mapa = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                Graphics grMapa = mapa.createGraphics();
                int[] posicaoAgenteNaSubImgemEmPx = {(diametroDoSensor / 2), (diametroDoSensor / 2)};
                int[] posicaoPontoComDistMinimaEmPx = new int[2];
                int[] posicaoPontoComDistMaximaEmPx = new int[2];
                double distanciaMinima = (diametroDoSensor / 2) + 1;
                double distanciaMaxima = 0;
                double dist = 0;
                System.out.println("posicaoAgenteNaSubImgemEmPx: " + posicaoAgenteNaSubImgemEmPx[0] + "," + posicaoAgenteNaSubImgemEmPx[1]);
                for (int i = 0; i < pontos_img.length; i++) {
                    pontos_img[i] = pontos_img[i] & pontos_mask[i];
                    grMapa.setColor(Color.WHITE);
                    int pixel = pontos_img[(contadorLinha * width + contadorColuna)];
                    if (pixel != -16777216) {
                        myColor = new Color(image.getRGB(contadorLinha, contadorColuna));

                        int red = myColor.getRed();
                        int green = myColor.getGreen();
                        int blue = myColor.getBlue();

                        //string2.append("  ");
                        //string2.append(contadorLinha);
                        //string2.append(contadorColuna);
                        if (red > 100 && green < 50 && blue < 50) {
                            //string2.append(": tub");
                            numPixelComTub++;
                            grMapa.drawLine(contadorLinha, contadorColuna, contadorLinha, contadorColuna);
                            //Distancia euclidiana até o ponto
                            dist = Math.sqrt(Math.pow((contadorLinha - posicaoAgenteNaSubImgemEmPx[0]), 2) + Math.pow(contadorColuna - posicaoAgenteNaSubImgemEmPx[1], 2));
                            if (dist < distanciaMinima) {
                                distanciaMinima = dist;
                                posicaoPontoComDistMinimaEmPx[0] = contadorLinha;
                                posicaoPontoComDistMinimaEmPx[1] = contadorColuna;
                            }
                            if (dist > distanciaMaxima) {
                                distanciaMaxima = dist;
                                posicaoPontoComDistMaximaEmPx[0] = contadorLinha;
                                posicaoPontoComDistMaximaEmPx[1] = contadorColuna;
                            }

                        } else if (pixel == -16777216) {
                            numPixelComNad++;
                        //string2.append(": nad");
                        }
                        if ((red > 120 && green > 120 && blue > 120)) {
                            numPixelComPla++;
                        //string2.append(": pla");
                        } else {
                            numPixelComMar++;
                        //string2.append(": mar");
                        }
                    //pontos_img[i] = -1;
                    } else {
                        grMapa.setColor(Color.LIGHT_GRAY);
                        grMapa.drawLine(contadorLinha, contadorColuna, contadorLinha, contadorColuna);
                    }

                    //string.append("  ");
                    //string.append(contadorLinha);
                    //string.append(contadorColuna);

                    if (contadorColuna == width - 1) {
                        //string.append("\n");
                        //string2.append("\n");

                        contadorLinha++;
                        contadorColuna = 0;
                    //string.append(pontos_img[i]);
                    } else {
                        contadorColuna++;
                    //string.append(pontos_img[i]);
                    }

                }
                System.out.println("distancia Mínima:" + distanciaMinima);
                System.out.println("posicaoPontoComDistMinimaEmPx: " + posicaoPontoComDistMinimaEmPx[0] + "," + posicaoPontoComDistMinimaEmPx[1]);
                grMapa.setColor(Color.RED);
                grMapa.drawLine(posicaoPontoComDistMinimaEmPx[0], posicaoPontoComDistMinimaEmPx[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);
                grMapa.drawLine(posicaoPontoComDistMaximaEmPx[0], posicaoPontoComDistMaximaEmPx[1], posicaoAgenteNaSubImgemEmPx[0], posicaoAgenteNaSubImgemEmPx[1]);

                strTub.append(numPixelComTub);
                strNad.append(numPixelComNad);
                strMar.append(numPixelComMar);
                strPla.append(numPixelComPla);
                System.out.println(strTub);
                System.out.println(strNad);
                System.out.println(strMar);
                System.out.println(strPla);

                //System.out.println(string);
                System.out.println(string2);
                image.setRGB(0, 0, width, height, pontos_img, 0, width);
                ImageIO.write(mapa, "jpg", new File("images\\Sensor Fotografico\\mapa" + temp + ".jpg"));
            }
            ImageIO.write(image, "jpg", new File("images\\Sensor Fotografico\\imagem" + temp + ".jpg"));
            temp++;
        } catch (Exception e) {
            e.printStackTrace();
        }
        //BufferedImage regiaoFotografada = regiao.getSubimage(0, 0, raio, raio);
        System.out.println("Terminou");

    }
}
