//Alex (970149)
// Last edited on 2000-08-19 04:17:44 by stolfi
import java.awt.Rectangle;
import java.awt.Graphics;
import java.*;
import Ponto;
import java.lang.*;

//final boolean I = TRUE;
//final boolean F = FALSE;


public class EscalaImpl extends Escala{
  //ajusta a posicao e o a distancia entre pontos pertencentes a lados de objetos graficos 
  //(ex: servicos) conforme, conforme as coordenadas do retangulo definido na planta, suas
  //dimensoes e as dimensoes da area grafica

private Math mat;

private double NRxmin;

private	double NRymin;

private double fator_de_conversao_X;
  //gr.width (pixels) onde gr e´ um retangulo que representa  a area grafica e r e´ um ret 
  //----------------  determinado pelo usuario na planta.
  //r.width (metros)

private double fator_de_conversao_Y;
  //gr.height (pixels) onde gr e´ um ret que representa  a area grafica e r e´ um ret 
  //------------------ determinado pelo usuario na planta.
  //r.height (metros)

private Rectangle r;
  //E´ necessario guardar o valor de r (apos o termino da execuc do metodo define_escala
  //pois sera' necessario consulta as coordenadas do canto superior esquerdo. 

private Rectangle gr;

private Double d;


public Ponto deslocaPonto (Ponto a, Ponto b, int desloc, int inicio_fim) {
    //Os dois pontos recebidos por esse metodo representam as extremidades
    //do trecho (ou entrada/saida) que deverah ser desenhada. Devolve
    //novas coordenadas deslocadas em um fator de DESLOC, paralelas aas
    //coordenadas originais.
    //Esse metodo eh chamado por DESENHA_TRECHO, DESTACA_CAMINHO e tambem
    //para desenhar as entradas e saidas dos servicos em um trecho.
    //No caso de se desenhar um trecho, deve-se chamar duas vezes o metodo,
    //cada chamada retornando um valor diferente (inicio/fim do trecho).

    //Math mat;
    double dx, dy, tx, ty, d;
    Ponto resp = new Ponto();;
    
    dx = b.x - a.x;
    dy = b.y - a.y;
    d = mat.sqrt(dx*dx + dy*dy);
    if (d == 0) d=1;
    dx = dx/d;
    dy = dy/d;
    tx = -dy;
    ty = dx;

    //Retorna o que foi solicitado: ponto INICIAL ou FINAL do trecho deslocado,
    //conforme foi solicitado quando da chamada do metodo.
    if (inicio_fim == 0) {
	resp.x = a.x - (double) desloc * (tx - 2*dx);
	resp.y = a.y - (double) desloc * (ty - 2*dy);
    } else if (inicio_fim == 1) {
	resp.x = b.x - (double) desloc * (tx + 2*dx);
	resp.y = b.y - (double) desloc * (ty + 2*dy);
    } else System.out.println("Parametro invalido para DeslocaPonto");
   
    return(resp);
}

//lembrete: funçao legal: long round(double);
public void define_escala(Graphics g, Rectangle tmpR) {
  //Determina os fatores de correcao a partir das dimensoes da area (retangulo em metros) da 
  //planta que sera' plotado, e das dimensoes da area grafica (em pixels).
    r=tmpR;
    Rectangle NR;

    gr = g.getClipBounds();

    //      double sX = (double) tmpR.width/ (double) gr.width; 
    //  double sY = (double) tmpR.height/ (double) gr.height;
    //  double s = (sX > sY ? sX : sY);
    //  double hX = (s/sX-1)/2; double hY = (s/sY-1)/2;
      
    //  NRxmin = tmpR.x - tmpR.width*hX; 
    //   NRymin = tmpR.y - tmpR.height*hY; 
    //  double NRxmax = tmpR.x + tmpR.width + tmpR.width*hX; 
    //  double NRymax = tmpR.y + tmpR.height + tmpR.height*hY; 
    NRxmin = tmpR.x;
    NRymin = tmpR.y;
    double NRxmax = NRxmin + tmpR.width;
    double NRymax = NRymin + tmpR.height;
      fator_de_conversao_X = (double) gr.width / (NRxmax-NRxmin); 
      fator_de_conversao_Y = (double) gr.height / (NRymax-NRymin);
}


public void aplica_escala(Ponto[] p, int [] x, int[] y) {
    //System.out.println("Aplica Escala");
    Ponto tmpP;
    for(int i=0; i < p.length; i++) {
    //System.out.println("iteracao:"+i+" Ponto:("+p[i].x+","+p[i].y+")");	
	tmpP = new Ponto();
	tmpP.x = p[i].x;
	tmpP.y = p[i].y;

	d = new Double(fator_de_conversao_X * (tmpP.x - (double) NRxmin));
	x[i] = d.intValue();
	
	  //Determina-se a posicao de um ponto na area grafica.
	  //Ex: (5,3). O canto esquerdo do quadrado foi posicionado (2,2) - na planta.
	  //5-2 = 3. Se a area grafica tiver o dobro da largura da area def na planta:
	  //3 * 2 = 6
	d = new Double(fator_de_conversao_Y * (tmpP.y - (double) NRymin));
	y[i] = d.intValue();

	y[i] = gr.y + (gr.height - (y[i] - gr.y));
	  //idem para as ordenadas.
	}
    }

public Ponto desaplica_escala(Ponto p) {
    Ponto tmpP;

    tmpP = new Ponto();

    tmpP.x = p.x / fator_de_conversao_X + NRxmin;
    tmpP.y = gr.y + (gr.height - (p.y - gr.y));
    tmpP.y = tmpP.y / fator_de_conversao_Y + NRymin;
    return tmpP;
    }

    //public int CoefAngular(Ponto[] p) {
    //return (mat.abs((p[0].x-p[1].x)/(p[0].y-p[1].y)));
    //}


}