package puzzle.puzzleClasses;

import java.awt.BorderLayout;
import java.awt.Checkbox;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.GridLayout;
import java.util.Hashtable;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFormattedTextField;
import javax.swing.JLabel;
import javax.swing.JRadioButton;
import javax.swing.JSlider;
import javax.swing.JToggleButton;

import jv.geom.PgElementSet;
import jv.object.PsPanel;
import jv.project.PvDisplayIf;
import jv.vecmath.PdVector;

public class Metodos {
	static 	double 			Pi				= Math.PI;
	
	/**Cor que tem de coordenadas em RGB (r,g,b).*/
	public static Color corRGB(int r,int g,int b){
		float rr=(float)(((double)r)/255);float gg=(float)(((double)g)/255);float bb=(float)(((double)b)/255);
		Color cor	= new Color(rr,gg,bb);
		return cor;
	}
	
	/**Função que transforma um string num boolean ***/
	static Boolean stringToBool(String a){
		Boolean aa=new Boolean(a);
		return aa;		
	}
	
	/**Indica se dois números são iguais a menos de um erro eps, se a=b.*/
	static	boolean numIguais(double a,double b,double eps){
		boolean iguais	= false;
		if(Math.abs(a-b)<=eps){
			iguais	= true;
		}
		return iguais;
	}
	
	static boolean vectIguais(PdVector a,PdVector b,double eps){
		boolean[] iguais = new boolean[(int) a.getSize()];
		boolean ig = false;
		for(int i=0;i<a.getSize();i++){
			if(numIguais(a.m_data[i],b.m_data[i],eps)){
				iguais[i]=true;
			}else{
				iguais[i]=false;
			}
			ig = ig&&iguais[i];
		}
		
		return ig;
	}
	
	/**Indica se um número pertence a um array de inteiros.*/
	static	boolean pertence(int num,int[] conj,double eps){
		boolean pertence	= false;
		for(int i=0;i<conj.length;i++){
			if(numIguais(num,conj[i],eps)){
				pertence	= true; i = conj.length;
			}else {
				pertence	= false;
			}
		}
		return	pertence;
	}
	
	/**Dada uma grelha de (valorM) de colunas e (valorN) de linhas, e uma quadrícula na posição (par),
	 * este método permite obter o número dessa quadrícula.*/
	static int parOrdInd(int[] par,int valorM,int valorN){
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				if(par[0]==i&&par[1]==j){
					i=valorM;j=valorN;break;
				}else {
					ind++;
				}
			}
		}
		return ind;
	}
	
	/**Troca as posições dos elementos de um conjunto pela ordem contrária.*/
	static int[] invConj(int[] conj){
		int[] invConj = new int[conj.length];
		for(int i=0;i<conj.length;i++){
			invConj[i] = conj[conj.length-1-i];
		}
		return invConj;
	}
	
	static int[] indParOrd(int ind,int valorM,int valorN){
		int[] par	= {0,0};
		int a= 0;
		for(int i=0;i<valorM;i++){
			for(int j=0;j<valorN;j++){
				if(a==ind){
					par[0] = i; par[1]= j; i=valorM;j=valorN;break;
				}else {
					a++;
				}
			}
		}
		return par;
	}
	
	/**Dada uma grelha com (valorN*multN) de linhas e (valorM*mult) de colunas, em que cada quadrícula está ordenada (com a seguinte ordem: fixa uma coluna, conta por ordem crescente as linhas, fixa a próxima coluna, conta as linhas e assim por diante),
	 * este método dá a posição de uma quadrícula numa grelha do mesmo tamanho que a inicial, ordenada da mesma forma, só que com (valorN) de linhas e (valorM) de colunas.*/
	static int nPlaca(int indice,int multM,int valorM,int multN,int valorN){
		double quocMultValorN	= Math.floor(indice/(multN*valorN*multM));
		double restoMult	= indice%(valorN*multN);
		double quocResto	= Math.floor(restoMult/multN);
		int	nPlaca	= (int)((quocMultValorN*valorN)+quocResto);
		
		return nPlaca;
	}
	
	/**Dada uma grelha com (valorN*multN) de linhas e (valorM*mult) de colunas, em que cada quadrícula está ordenada (com a seguinte ordem: fixa uma coluna, conta por ordem crescente as linhas, fixa a próxima coluna, conta as linhas e assim por diante),
	 * este método dá a posição de uma quadrícula numa grelha do mesmo tamanho que a inicial, ordenada da mesma forma, só que com (valorN) de linhas e (valorM) de colunas.*/
	static int nPlacaInv(int indice,int multM,int valorM,int multN,int valorN){
		double quocMultValorN	= Math.floor(indice/(multN*valorN*multM));
		double restoMult	= indice%(valorN*multN);
		double quocResto	= Math.floor(restoMult/multN);
		int	nPlaca	= (int)((quocMultValorN*valorN)+((valorN*multN-1)-quocResto));
		
		return nPlaca;
	}
	
	/**Função que transforma um string num inteiro*/
  	static int StringToInt(String Str){
	  int result=0;
	  char[] textchar = new char[Str.length()];
	  textchar = Str.toCharArray();
	  for(int i=0; i<Str.length(); i++){
		  if(Character.isDigit(textchar[i])){
			  result = result+(int)(Math.pow((double) 10,(double) i))*Character.getNumericValue(textchar[textchar.length-i-1]);
		  }else{result=0;}
	  }
	  return result;
  	}
	
	
	/**Tem como objectivo manter o rato no modo para fazer o "pick" sobre os objectos, em uma janela.*/		
	static void pickE1(PvDisplayIf m_disp){
		if (m_disp != null) {
			m_disp.setMajorMode(PvDisplayIf.MODE_INITIAL_PICK);
		}
	}
	
	/**Tem como objectivo manter o rato no modo para fazer o "pick" sobre os objectos, em várias janelas.*/		
	static void pickE(PvDisplayIf[] m_disp){
		for(int i=0;i<m_disp.length;i++){
			if (m_disp[i] != null) {
				m_disp[i].setMajorMode(PvDisplayIf.MODE_INITIAL_PICK);
			}
		}
	}
	
	/**Tem como objectivo manter o rato no modo para fazer rodar sobre os objectos, no caso de se ter várias janelas.*/	
	static void rotateE(PvDisplayIf[] m_disp){
		for(int i=0;i<m_disp.length;i++){
			if (m_disp[i] != null) {
				m_disp[i].setMajorMode(PvDisplayIf.MODE_ORBIT);	
			}
		}
	}
	
	/**Tem como objectivo manter o rato no modo para fazer rodar sobre os objectos, no caso de só se ter uma janela.*/	
	static void rotateE1(PvDisplayIf m_disp){
		if (m_disp != null) {
			m_disp.setMajorMode(PvDisplayIf.MODE_ORBIT);	
		}
	}
	
	/**Instruções para o botão que permite fazer "pick" nos objectos de uma janela.*/
	static void escolher1(PvDisplayIf m_disp,JToggleButton pick){
		pick.setSelected(true);
		pick.setText(Legendas.pickLegenda);
		pick.setToolTipText(Legendas.escolherFuncao);
		pickE1(m_disp);
	}
	
	/**Instruções para o botão que permite fazer "pick" nos objectos de várias janelas.*/
	static void escolher(PvDisplayIf[] m_disp,JToggleButton pick){
		pick.setSelected(true);
		pick.setText(Legendas.pickLegenda);
		pick.setToolTipText(Legendas.escolherFuncao);
		pickE(m_disp);
	}
	
		
	/**Instruções para o botão que permite rodar os objectos de uma janela.*/
	static void rodar1(PvDisplayIf m_disp,JToggleButton pick){
		pick.setSelected(false);
		pick.setText(Legendas.rodarLegenda);
		pick.setToolTipText(Legendas.rodarFuncao);
		rotateE1(m_disp);
	}
	
	/**Instruções para o botão que permite rodar os objectos de várias janelas.*/
	static void rodar(PvDisplayIf m_disp,JToggleButton pick){
		pick.setSelected(false);
		pick.setText(Legendas.rodarLegenda);
		pick.setToolTipText(Legendas.rodarFuncao);
		rotateE1(m_disp);
	}
	
	
	
	/*Construções:*/
		
		/**Plano que contém o ponto P e vector normal N*/ 
		/*plano[P_, N_, x1_: - 5, x2_:5, y1_: - 5, y2_:5] := 
			Module[{d}, d = -(N.P); 
			ParametricPlot3D[{x, y, -(d + N[[1]]*x + N[[2]]*y)/N[[3]]},
			{x, x1,x2}, {y, y1, y2}]];
			
			(double x1	= -limitesX;double x2	= limitesX;
			double y1	= -limitesY;double y2	= limitesY;)*/
		static void plano(PgElementSet plano,PdVector P,PdVector N,double limitesX,double limitesY,Color cor,boolean transp,double transparencia){
			/*Limites do domínio:*/
			double x1	= -limitesX;double x2	= limitesX;
			double y1	= -limitesY;double y2	= limitesY;
			/*.....................*/
			int ind = 0;
			int numXLines = 2;
			int numYLines = 2;
			plano.setNumVertices(numXLines*numYLines);
			for (int i=0; i<numXLines;i=(i+1)) {
				for (int j=0; j<numYLines; j=(j+1)) {
					double d	= -PdVector.dot(N,P);//=-produtoEscalar(N,P);
					double x ;
					double y ;
					double z ;
					if(N.m_data[2]!=0){
						x 	= (x2-x1)*i/(numXLines-1)+x1;//Entre x1 e x2
						y 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
						z	= -(d+N.m_data[0]*x+N.m_data[1]*y)/(N.m_data[2]);
					}else if(N.m_data[1]!=0){
						x 	= (x2-x1)*i/(numXLines-1)+x1;//Entre x1 e x2
						y	= -(d+N.m_data[0]*x)/(N.m_data[1]);
						z 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
					}else if(N.m_data[0]!=0){
						y 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
						x	= -(d+N.m_data[1]*y)/(N.m_data[0]);
						z 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
					}else {
						x	= 0;
						y	= 0;
						z	= 0;
					}
					
					plano.setVertex(ind++,x, y ,z);
				}
			}
			plano.makeQuadrConn(numXLines,numYLines);
			plano.makeElementNormals();
			plano.makeVertexNormals();
			plano.close();
			/*Tudo o que diz respeito ao aspecto da esfera:*/
			plano.showTransparency(transp);
			plano.setTransparency(transparencia);
			plano.showEdges(false);
			plano.setGlobalElementColor(cor);
			/*........................................................*/
			//plano.fixBoundaries(); 
			plano.update(plano);
				
		}
		
	/**Plano que contém o ponto P e vector normal N*/ 
	/*plano[P_, N_, x1_: - 5, x2_:5, y1_: - 5, y2_:5] := 
		Module[{d}, d = -(N.P); 
		ParametricPlot3D[{x, y, -(d + N[[1]]*x + N[[2]]*y)/N[[3]]},
		{x, x1,x2}, {y, y1, y2}]];
			
		(double x1	= -limitesX;double x2	= limitesX;
		double y1	= -limitesY;double y2	= limitesY;)*/
	static void planoD(PgElementSet plano,double d,PdVector N,double limitesX,double limitesY,Color cor,boolean transp,double transparencia){
		/*Limites do domínio:*/
		double x1	= -limitesX;double x2	= limitesX;
		double y1	= -limitesY;double y2	= limitesY;
		/*.....................*/
		int ind = 0;
		int numXLines = 2;
		int numYLines = 2;
		plano.setNumVertices(numXLines*numYLines);
		for (int i=0; i<numXLines;i=(i+1)) {
			for (int j=0; j<numYLines; j=(j+1)) {
				double x ;
				double y ;
				double z ;
				if(N.m_data[2]!=0){
					x 	= (x2-x1)*i/(numXLines-1)+x1;//Entre x1 e x2
					y 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
					z	= -(d+N.m_data[0]*x+N.m_data[1]*y)/(N.m_data[2]);
				}else if(N.m_data[1]!=0){
					x 	= (x2-x1)*i/(numXLines-1)+x1;//Entre x1 e x2
					y	= -(d+N.m_data[0]*x)/(N.m_data[1]);
					z 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
				}else if(N.m_data[0]!=0){
					y 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
					x	= -(d+N.m_data[1]*y)/(N.m_data[0]);
					z 	= (y2-y1)*j/(numYLines-1)+y1;//Entre y1 e y2
				}else {
					x	= 0;
					y	= 0;
					z	= 0;
				}
					
				plano.setVertex(ind++,x, y ,z);
				
			}
		}
		plano.makeQuadrConn(numXLines,numYLines);
		plano.makeElementNormals();
		plano.makeVertexNormals();
		plano.close();
		/*Tudo o que diz respeito ao aspecto da esfera:*/
		plano.showTransparency(transp);
		plano.setTransparency(transparencia);
		plano.showEdges(false);
		plano.setGlobalElementColor(cor);
		/*........................................................*/
		//plano.fixBoundaries(); 
		plano.update(plano);
				
	}
	
		/**Para construir um plano, em que temos controle sobre a contagem das linhas e das colunas.*/
		static void computePlanoLC(PgElementSet plano,double xMin,double xMax,double yMin,double yMax,int numXLines,int numYLines,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			int ind = 0;
			plano.setNumVertices(numXLines*numYLines);
			for(int i=0;i<numYLines;i++){
				for(int j=0;j<numXLines;j++){
					double x	= (yMax-yMin)*i/(numYLines-1)+yMin;
					double y	= (xMax-xMin)*j/(numXLines-1)+xMin;
					double z	= 0;
					plano.setVertex(ind, x,z,y);ind++;
				}
			}
			plano.makeQuadrConn(numYLines,numXLines);
			plano.setGlobalElementColor(cor);
			plano.setGlobalEdgeSize(sizeArestas);
			plano.setGlobalEdgeColor(corArestas);			
			
			plano.showTransparency(true);
			plano.setTransparency(transp);
			plano.showBoundaries(mostraArestas);
			plano.setGlobalBndColor(corArestas);
			plano.setGlobalBndSize(sizeArestas);
			plano.showEdges(false);
			plano.showElements(mostraFaces);
			plano.setVisible(visivel);
			plano.showSmoothElementColors(true);
			plano.showSmoothLighting(true);
			plano.showElementBackColors(false);
			plano.update(plano);
		}
		
		/**Para construir um plano, em que temos controle sobre a contagem das linhas e das colunas.*/
	static void computePlanoLCProp(PgElementSet plano,double xMin,double xMax,double yMin,double yMax,int numXLines,int numYLines,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
		plano.setGlobalElementColor(cor);
		plano.setGlobalEdgeSize(sizeArestas);
		plano.setGlobalEdgeColor(corArestas);			
				
		plano.showTransparency(true);
		plano.setTransparency(transp);
		plano.showBoundaries(mostraArestas);
		plano.setGlobalBndColor(corArestas);
		plano.setGlobalBndSize(sizeArestas);
		plano.showEdges(false);
		plano.showElements(mostraFaces);
		plano.setVisible(visivel);
		plano.showSmoothElementColors(true);
		plano.showSmoothLighting(true);
		plano.showElementBackColors(false);
		plano.update(plano);
	}
	
		/**Para construir um plano*/
		static void computePlano(PgElementSet plano,double xMin,double xMax,double yMin,double yMax,int numXLines,int numYLines,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			plano.computePlane(numXLines,numYLines,xMin,yMin,xMax,yMax);
			plano.setGlobalElementColor(cor);
			plano.setGlobalEdgeSize(sizeArestas);
			plano.setGlobalEdgeColor(corArestas);			
			
			plano.showTransparency(true);
			plano.setTransparency(transp);
			plano.showBoundaries(mostraArestas);
			plano.setGlobalBndColor(corArestas);
			plano.setGlobalBndSize(sizeArestas);
			plano.showEdges(false);
			plano.showElements(mostraFaces);
			plano.setVisible(visivel);
			plano.showSmoothElementColors(true);
			plano.showSmoothLighting(true);
			plano.showElementBackColors(false);
			plano.update(plano);
		}
				
		/**Para construir uma esfera dado o centro C e raio */
		static void computeEsfera(PgElementSet esfera,PdVector C,double raio,boolean mostraEsf,boolean mostraArestas){
			esfera.computeSphere(8,8,raio);
			esfera.translate(C);
			esfera.showElements(mostraEsf);
			esfera.showEdges(mostraArestas);
			esfera.showSmoothElementColors(true);
			esfera.showSmoothLighting(true);
			esfera.showElementBackColors(false);
			esfera.update(esfera);
		}
		
		/**Para construir um toro dado o seu raio e o seu centro.*/
		static void computeToro(PgElementSet toro,double raio,double centro,int numXLines,int numYLines,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			int ind = 0;
			toro.setNumVertices(numXLines*numYLines);
			for(int i=0;i<numXLines;i++){
				double angX	= 2*Pi*i/(numXLines-1);
				for(int j=0;j<numYLines;j++){
					double angY	= 2*Pi*j/(numYLines-1);
					double x	= (centro+raio*Math.cos(angX))*Math.cos(angY);
					double y	= (centro+raio*Math.cos(angX))*Math.sin(angY);
					double z	= raio*Math.sin(angX);
					toro.setVertex(ind, x,y,z);ind++;
				}
			}
			toro.makeQuadrConn(numXLines,numYLines);
			toro.setGlobalElementColor(cor);
			toro.showVertices(false);
			toro.showEdges(mostraArestas);
			toro.showElements(mostraFaces);
			toro.setVisible(visivel);
			toro.showSmoothElementColors(true);
			toro.showSmoothLighting(true);
			toro.showElementBackColors(false);
			toro.update(toro);
				
		}
	
		/**Para construir partes de um toro dado o seu raio e o seu centro.*/
		static void computePartesToro(PgElementSet parteToro,double raio,double centro,int numXLines,int numYLines,double[] angX,double[] angY,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			int ind = 0;
			parteToro.setNumVertices(numXLines*numYLines);
			for(int i=0;i<numXLines;i++){
				double aangX	= (angX[1]-angX[0])*i/(numXLines-1)+angX[0];//Varia entre angX[0] e angX[1]
				for(int j=0;j<numYLines;j++){
					double aangY	= (-angY[1]+angY[0])*j/(numYLines-1)+angY[1];//Varia entre angY[0] e angY[1]
					double x	= (centro+raio*Math.cos(aangX))*Math.cos(aangY);
					double y	= (centro+raio*Math.cos(aangX))*Math.sin(aangY);
					double z	= raio*Math.sin(aangX);
					parteToro.setVertex(ind, x,y,z);ind++;
				}
			}
			parteToro.makeQuadrConn(numXLines,numYLines);
			
			parteToro.showTransparency(true);
			parteToro.setTransparency(transp);
			parteToro.showBoundaries(mostraArestas);
			parteToro.setGlobalBndColor(corArestas);
			parteToro.setGlobalBndSize(sizeArestas);
			parteToro.setGlobalElementColor(cor);
			parteToro.showVertices(false);
			parteToro.showEdges(false);
			parteToro.showElements(mostraFaces);
			parteToro.setVisible(visivel);
			parteToro.showSmoothElementColors(true);
			parteToro.showSmoothLighting(true);
			parteToro.showElementBackColors(false);
			parteToro.update(parteToro);
						
		}
		
	/**Para construir partes de um toro dado o seu raio e o seu centro.*/
	static void computePartesToroProp(PgElementSet parteToro,double raio,double centro,int numXLines,int numYLines,double[] angX,double[] angY,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
		parteToro.showTransparency(true);
		parteToro.setTransparency(transp);
		parteToro.showBoundaries(mostraArestas);
		parteToro.setGlobalBndColor(corArestas);
		parteToro.setGlobalBndSize(sizeArestas);
		parteToro.setGlobalElementColor(cor);
		parteToro.showVertices(false);
		parteToro.showEdges(false);
		parteToro.showElements(mostraFaces);
		parteToro.setVisible(visivel);
		parteToro.showSmoothElementColors(true);
		parteToro.showSmoothLighting(true);
		parteToro.showElementBackColors(false);
		parteToro.update(parteToro);
						
	}

		
		/**Para construir um cilindro dado as suas extremidades, P e Q, e raio.*/
		static void computeCilindro(PgElementSet geom,PdVector P,PdVector Q,double raio,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			PdVector PQ	= uv(P,Q);
			PdVector ortog	= vectOrtogonal(PQ,1);
			PdVector w	= cross(PQ,ortog);
			
			int numXLine	= 10;
			int numYLine	= 2;
			
			
			geom.setNumVertices(numXLine*numYLine);
			geom.setNumElements(numXLine+1);
			int ind	= 0;
			
			for(int i=0;i<numXLine;i++){
				double a = 2*Pi*i/(numXLine-1);//Varia entre 0 e 2Pi.
				for(int j=0;j<numYLine;j++){
					double k = j/(numYLine-1);//Varia entre 0 e 1.
					//Cada ponto do cilindro P+k(Q-P)+raio*cos(a)*u+raio*sin(a)*v, em que u é ortogonal a PQ e v ortogonal a u e a PQ 
					PdVector v = somaVect(somaVect(P,multiVectNum(k,uv(P,Q))),somaVect(multiVectNum(raio*Math.cos(a),ortog),multiVectNum(raio*Math.sin(a),w)));
					
					geom.setVertex(ind,v);	ind++;
				}
			}
			geom.makeQuadrConn(numXLine,numYLine);
			
			geom.showElements(mostraFaces);
			geom.showEdges(mostraArestas);
			geom.setGlobalElementColor(cor);
			geom.setVisible(visivel);
			geom.showSmoothElementColors(true);
			geom.showSmoothLighting(true);
			geom.showElementBackColors(false);
			geom.update(geom);
		}
		
		/**Para construir um cilindro dado as suas extremidades, P e Q, e raio, e dadas o nº de linhas em ambasa as direcções.*/
		static void computeCilindroNumLines(PgElementSet cilindro,PdVector P,PdVector Q,double raio,int numXLine,int numYLine,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			PdVector PQ	= uv(P,Q);
			PdVector ortog	= vectOrtogonal(PQ,1);ortog	= uni(ortog);
			PdVector w	= cross(PQ,ortog);	w	= uni(w);
			cilindro.setNumVertices(numXLine*numYLine);
			cilindro.setNumElements(numXLine+1);
			PgElementSet	cili	= new PgElementSet(3);
			cili.setNumVertices(numXLine*numYLine);
			int ind	= 0;
					
			for(int i=0;i<numXLine;i++){
				double a = 2*Pi*i/(numXLine-1);//Varia entre 0 e 2Pi.
				for(int j=0;j<numYLine;j++){
					double k = j/((double)numYLine-1);//Varia entre 0 e 1.
					//Cada ponto do cilindro P+k(Q-P)+raio*cos(a)*u+raio*sin(a)*v, em que u é ortogonal a PQ e v ortogonal a u e a PQ 
					PdVector v = somaVect(somaVect(P,multiVectNum(k,uv(P,Q))),somaVect(multiVectNum(raio*Math.cos(a),ortog),multiVectNum(raio*Math.sin(a),w)));
					
					cili.setVertex(ind,v);	ind++;
				}
			}
			for(int i=0;i<numXLine*numYLine;i++){
				cilindro.setVertex(i,cili.getVertex(i));
			}
			cilindro.makeQuadrConn(numXLine,numYLine);
			cilindro.showElements(mostraFaces);
			cilindro.showEdges(mostraArestas);
			cilindro.setGlobalElementColor(cor);
			cilindro.setVisible(visivel);
			cilindro.showSmoothElementColors(true);
			cilindro.showSmoothLighting(true);
			cilindro.showElementBackColors(false);
			cilindro.update(cilindro);
		}
		
		/**Do rectângulo para o cilindro ou tira de Moebius.*/
		/*Mocil[t_, u_,tor_:1] := 
		 {(2 + t Sin[tor u/2]) Cos[u], (2 + t Sin[tor u/2]) Sin[u], t Cos[tor u/2]} // N;
Mocilrec[t_, u_, tt_, tor_:1] := 
	If[u < 0.01, {2, 2u, t} - tt{0, 4 Pi, 0}, Mocil[t, u, tor] - tt{0, 4 Pi, 0}];

Moebcilre2[a_, tor_:1, larg_:1, pp_:15, opts_:{}] := 
	Show[{Graphics3D[EdgeForm[]], 
		ParametricPlot3D[
		  Mocilrec[t, u, a, tor], {t, -larg, larg}, {u, 2 (a - 1) Pi, 2 Pi a}, 
		  Evaluate[ndsp], PlotPoints -> {3, pp}]}, dsp, 
	  PlotRange -> {{-3, 3}, {-20, 0}, {-1.2, 1.2}}, Boxed -> False,
	  Axes -> Null, opts];
*/
		/**Método para transformar um rectângulo num cilindro (se tor=0) ou num toro (se tor=1).*/
static void rectCil(PgElementSet cilindro,double m_a,int tor,double larg,double raio,int numXLine,int numYLine,boolean mostraFaces,boolean mostraArestas){
	double u1 = 2*(m_a-1)*Pi, u2 = 2*Pi*m_a, t1 = -larg, t2 = larg;
	double[] ang	= {u1,u2}, compr	= {t1,t2};
	
	cilindro.setNumVertices(numXLine*numYLine);
	int indV = 0;
	for(int k=0;k<numXLine;k++){
		double u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
		for(int l=0;l<numYLine;l++){
			double t;
			if(tor==0){
				t	= (compr[1]-compr[0])*l/(numYLine-1)+compr[0];
			}else {
				t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
			}
			PdVector v; 
			if(u<0.01){
				if(tor==0){
					v = new PdVector(raio,raio*u-m_a*2*raio*Pi+2*raio*Pi,t);
				}else {
					v = new PdVector(raio,raio*u-m_a*2*raio*Pi+2*raio*Pi,raio*t);
				}
			}else {
				if(tor==0){
					v = new PdVector((raio+raio*t*Math.sin(tor*u/2))*Math.cos(u),(raio+raio*t*Math.sin(tor*u/2))*Math.sin(u)-m_a*2*raio*Pi+2*raio*Pi,t*Math.cos(tor*u/2));
				}else {
					v = new PdVector((raio+raio*t*Math.sin(tor*u/2))*Math.cos(u),(raio+raio*t*Math.sin(tor*u/2))*Math.sin(u)-m_a*2*raio*Pi+2*raio*Pi,raio*t*Math.cos(tor*u/2));	
				}
			}
			cilindro.setVertex(indV,v); indV++;
		}
	}
	cilindro.makeQuadrConn(numXLine,numYLine);
	cilindro.showEdges(mostraArestas);
	cilindro.showElements(mostraFaces);
	cilindro.showSmoothElementColors(true);
	cilindro.showSmoothLighting(true);
	cilindro.showElementBackColors(false);
	cilindro.update(cilindro);
}
	
	
	/**Método para transformar as partes de um rectângulo nas correspondentes de um cilindro (se tor=0) ou nas correspondentes de um toro (se tor=1).*/
	static void rectCils(PvDisplayIf ab,PgElementSet[] cilindro,PdVector[] normal,PgElementSet[] facesFig,int valorM,int valorN,double m_a,int tor,double larg,double raio,int numXLine,int numYLine,boolean update){
		double u1 = 2*(m_a-1)*Pi;
		double u2 = 2*Pi*m_a;
		double[] ang	= {u1,u1};
		double uDelta = (u2-u1)/valorM;
		double t1 = -larg;
		double t2 = larg;
		double[] compr	= {t1,t1};
		double tDelta = (t2-t1)/valorN;
		PdVector ptoIntCili;
		if(tor==0){
			ptoIntCili		= new PdVector(0.1,+0.1,0.1);
		}else {
			ptoIntCili		= new PdVector(0,-2*raio*Pi,0);
		}
		
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+uDelta;
			compr[1] = t1; 
			for(int j=0;j<valorN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+tDelta;
				
				cilindro[ind].setNumVertices(numXLine*numYLine);
				
				int indV = 0;
				for(int k=0;k<numXLine;k++){
					double u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
					for(int l=0;l<numYLine;l++){
						double t	= (compr[1]-compr[0])*l/(numYLine-1)+compr[0];
						PdVector v; //raio = 2;
						if(u<0.01){
							if(tor==0){
								v = new PdVector(raio,raio*u-m_a*2*raio*Pi+2*raio*Pi,t);
							}else {
								v = new PdVector(raio,raio*u-m_a*2*raio*Pi+2*Pi*raio,raio*t);
							}
						}else {
							if(tor==0){
								v = new PdVector((raio+raio*t*Math.sin(tor*u/2))*Math.cos(u),(raio+raio*t*Math.sin(tor*u/2))*Math.sin(u)-m_a*2*raio*Pi+2*raio*Pi,t*Math.cos(tor*u/2));
								ptoIntCili		= new PdVector(0,-m_a*2*raio*Pi+2*raio*Pi,0);
								
							}else {
								v = new PdVector((raio+raio*t*Math.sin(tor*u/2))*Math.cos(u),(raio+raio*t*Math.sin(tor*u/2))*Math.sin(u)-m_a*2*raio*Pi+2*Pi*raio,raio*t*Math.cos(tor*u/2));
								ptoIntCili		= new PdVector(0,0,0);
							}
						}
						cilindro[ind].setVertex(indV,v); indV++;
					}
				}
				
				cilindro[ind].makeQuadrConn(numXLine,numYLine);
				
				int nInd = ind;
				if(tor==1){
					double q	= Math.floor((double)ind/valorN);
					double r	= ((double)ind)%valorN;
					nInd	= (int)(valorN*q+((valorN-1)-r));
				}
				cilindro[ind].showTransparency(true);
				cilindro[ind].setTransparency(Puzzle3D.transpMin);
				cilindro[ind].showBoundaries(facesFig[nInd].isShowingBoundaries());
				
				cilindro[ind].setGlobalBndColor(Puzzle3D.corArestas);
				cilindro[ind].setGlobalBndSize(Puzzle3D.sizeArestas);
				
				cilindro[ind].showElements(facesFig[nInd].isShowingElements());
				cilindro[ind].showEdges(facesFig[nInd].isShowingEdges());
				cilindro[ind].showElementColors(true);
				cilindro[ind].showSmoothElementColors(true);
				cilindro[ind].showSmoothLighting(true);
				cilindro[ind].showElementBackColors(false);
				cilindro[ind].setGlobalElementColor(facesFig[nInd].getGlobalElementColor());
				cilindro[ind].setVisible(facesFig[nInd].isVisible());
				PdVector[] vert	= {cilindro[ind].getVertex(0),cilindro[ind].getVertex(numYLine-1),cilindro[ind].getVertex(numXLine*numYLine-1-(numYLine-1)),cilindro[ind].getVertex(numXLine*numYLine-1)};
				normal[ind]	= vNormal(vert,ptoIntCili);
				if(update){cilindro[ind].update(cilindro[ind]);}
				ind++;
				
			}
		}
	}
	
	
	static void computeLinha(PgElementSet linha,int[][] distCores,double larg,double raio,double valorM,double valorN,int numYLine){	
		boolean naoLinha	= true; 
		double uDelta = 2*Pi/valorM, t1 = -larg, t2 = larg, tDelta = (t2-t1)/((double)valorN);
		
		linha.setNumVertices(numYLine*2);int ind = 0; PdVector v = new PdVector(0,0,0); 
		for(int i=0;i<4;i++){
			if(valorM==2&&
			valorN%2==1&&Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][1]==(int)((valorN+1)/2-1)&&distCores[0][1]==(int)((valorN+1)/2-1)){
				double ii = Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][0];
				double jj = Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][1];
				double u = (uDelta*(ii+1)+uDelta*ii)/2;
				for(int k=0;k<2;k++){
					for(int l=0;l<numYLine;l++){
						double t	= (tDelta*(jj+1)-tDelta*jj)*l/(numYLine-1)+t1+tDelta*jj;
						v = new PdVector((raio+raio*t*Math.sin(u/2))*Math.cos(u),(raio+raio*t*Math.sin(u/2))*Math.sin(u)-2*raio*Pi+2*Pi*raio,raio*t*Math.cos(u/2));
						linha.setVertex(ind,v);ind++;	
					}
				}
					naoLinha	= false;i=4;
				}
				
		}
		
		if(naoLinha){ for(int l=0;l<2*numYLine;l++){ linha.setVertex(l,new PdVector(0,0,0));ind++; } }
		linha.makeQuadrConn(2,numYLine);
		linha.setVisible(!naoLinha);
		linha.showEdges(true);
		linha.showElements(true);
		linha.showVertices(false);
		linha.setGlobalEdgeSize(Puzzle3D.sizeLinhaDiv);
		linha.setGlobalEdgeColor(Color.yellow);
		linha.showSmoothElementColors(true);
		linha.showSmoothLighting(true);
		linha.showElementBackColors(false);
		linha.update(linha);
	}
	
	static void computeLinhaGK(PgElementSet linha,int[][] distCores,double raio,double Raio,double valorM,double valorN,int numYLine){	
		boolean naoLinha	= true; 
		double uDelta = 2*Pi/valorM, t1 = 0, t2 = 2*Pi, tDelta = (t2-t1)/((double)valorN);
		PdVector transl = new PdVector(-13*Pi,-33*Pi,+2*raio*Pi);
		linha.setNumVertices(numYLine*2);int ind = 0; PdVector v = new PdVector(0,0,0); 
		for(int i=0;i<4;i++){
			if(valorM==2&&
			valorN%2==1&&Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][1]==(int)((valorN+1)/2-1)&&distCores[0][1]==(int)((valorN+1)/2-1)){
				double ii = Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][0];
				double jj = Puzzle3D.Contig(Puzzle3D.nome,distCores[0])[i][1];
				double u = (uDelta*(ii+1)+uDelta*ii)/2;
				for(int k=0;k<2;k++){
					for(int l=0;l<numYLine;l++){
						double t	= (tDelta*(jj+1)-tDelta*jj)*l/(numYLine-1)+t1+tDelta*jj;
						double a = (raio+Raio)/(2*Raio); double b = (-raio-Raio)/(raio-Raio);
						double uu = 2*Pi-u;
						double bb = Pi/2*(1 - Math.cos(uu/2-Pi/2)*Math.cos(uu/2-Pi/2));
						double x, y, z;
						if(uu<=2*Pi&&uu>Pi){
							x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(t+Pi+bb);
							y = 16*Math.sin(uu);
						}else {
							x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(uu)*Math.cos(t+bb);
							y = 16*Math.sin(uu)+a*Raio*(1-Math.cos(uu)/b)*Math.sin(uu)*Math.cos(t+bb);
						}
						z = a*Raio*(1-Math.cos(uu)/b)*Math.sin(t+bb);
						v = new PdVector(x+12*Pi,y+32*Pi,z-2*raio*Pi);
						linha.setVertex(ind,somaVect(v,transl));ind++;	
					}
				}
					naoLinha	= false;i=4;
				}
				
		}
		
		if(naoLinha){ for(int l=0;l<2*numYLine;l++){ linha.setVertex(l,new PdVector(0,0,0));ind++; } }
		linha.makeQuadrConn(2,numYLine);
		linha.setVisible(!naoLinha);
		linha.showEdges(true);
		linha.showElements(true);
		linha.showVertices(false);
		linha.setGlobalEdgeSize(Puzzle3D.sizeLinhaDiv);
		linha.setGlobalEdgeColor(Color.yellow);
		linha.showSmoothElementColors(true);
		linha.showSmoothLighting(true);
		linha.showElementBackColors(false);
		linha.update(linha);
	}
	
	/**Calcular o vector normal a cada face.*/
	static PdVector vNormal(PdVector[] vert,PdVector ptoInterior){
		PdVector normal;
		PdVector u	= uv(vert[0],vert[1]);
		PdVector v	= uv(vert[1],vert[2]);
		PdVector vectInt	= uv(ptoInterior,vert[0]);
		PdVector c	= cross(u,v);
		if(produtoEscalar(vectInt,c)>=0){
			normal	= uni(c);
		}else {
			normal	= uni(cross(uv(vert[2],vert[1]),uv(vert[1],vert[0])));
		}	
		
		return normal;
	}

	/*static void rectCilToro(PgElementSet[] cilindro,PgElementSet[] facesFig,int valorM,int valorN,double m_a,double raio,double Raio,int numXLine,int numYLine){
		double m_aa;
		double t1;
		double t2;
		double larg = 2*Pi;
		if(m_a<=0.5){
			m_aa = 2*m_a;
			t1 = -larg; t2 = 0;
		}else {
			m_aa = 2*m_a-1;
			t1 = 0; t2 = larg;
		}
		double u1 = 2*(m_aa-1)*Pi;
		double u2 = 2*Pi*m_aa;
		double[] ang	= {u1,u1};
		double uDelta = (u2-u1)/valorM;
		double[] compr	= {t1,t1};
		double tDelta = (t2-t1)/valorN;
		
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+uDelta;
			compr[1] = t1; 
			for(int j=0;j<valorN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+tDelta;
				
				cilindro[ind].setNumVertices(numXLine*numYLine);
				
				int indV = 0;
				for(int k=0;k<numXLine;k++){
					double u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
					for(int l=0;l<numYLine;l++){
						double t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
						PdVector v;
						if(m_a<=0.5){
							if(u<0.01){
								v = new PdVector(Raio+raio,Raio*t,raio*u-m_aa*4*Pi);
							}else {
								v = new PdVector(Raio+raio*Math.cos(u),Raio*t,raio*Math.sin(u)-m_aa*4*Pi);
							}
						}else {
							if(u<0.){
								v = new PdVector(Raio+raio*Math.cos(t),Raio*u-m_aa*6*Pi,raio*Math.sin(t)-4*Pi);
							}else {
								v = new PdVector(Math.cos(u)*(Raio+raio*Math.cos(t)),Math.sin(u)*(Raio+raio*Math.cos(t))-m_aa*6*Pi,raio*Math.sin(t)-4*Pi);
							}
						}
											
						cilindro[ind].setVertex(indV,v); indV++;
					}
				}
				
				if(m_a<=0.5){
					cilindro[ind].makeQuadrConn(numXLine,numYLine);
				}else {
					cilindro[ind].makeQuadrConn(numYLine,numXLine);
				}
				int nInd = ind;
				
				cilindro[ind].showTransparency(true);
				cilindro[ind].setTransparency(facesFig[nInd].getTransparency());
				cilindro[ind].showBoundaries(facesFig[nInd].isShowingBoundaries());
				cilindro[ind].setGlobalBndColor(facesFig[nInd].getGlobalBndColor());
				cilindro[ind].setGlobalBndSize(facesFig[nInd].getGlobalBndSize());
				cilindro[ind].showElements(facesFig[nInd].isShowingElements());
				cilindro[ind].showEdges(facesFig[nInd].isShowingEdges());
				cilindro[ind].showElementColors(true);
				cilindro[ind].setGlobalElementColor(facesFig[nInd].getGlobalElementColor());
				cilindro[ind].setVisible(facesFig[nInd].isVisible());
				cilindro[ind].update(cilindro[ind]); ind++;
			}
		}
	}*/
	
	/**Método para transformar um rectângulo num cilindro e depois num toro.*/
	static void rectCilToro(PgElementSet cilindro,double m_a,double raio,double Raio,int numXLine,int numYLine,boolean mostraFaces,boolean mostraArestas){
		double m_aa;
		double t1;
		double t2;
		double larg = 2*Pi;
		if(m_a<=0.5){
			m_aa = 2*m_a;
			t1 = -larg; t2 = 0;
		}else {
			m_aa = 2*m_a-1;
			t1 = 0; t2 = larg;
		}
		double u1 = 2*(m_aa-1)*Pi;
		double u2 = 2*Pi*m_aa;
		double[] ang	= {u1,u2};
		double[] compr	= {t1,t2};
		
		
		PdVector v;
		cilindro.setNumVertices(numXLine*numYLine);
		int indV = 0;
		if(m_a<=0.5){
			for(int k=0;k<numXLine;k++){
				double u = ( ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
				for(int l=0;l<numYLine;l++){
					double t	= (compr[1]-compr[0])*l/(numYLine-1)+compr[0];
					if(u<0.01){
						v = new PdVector(Raio+raio,Raio*t+2*Raio*Pi,raio*u-m_aa*2*raio*Pi+2*raio*Pi);
					}else {
						v = new PdVector(Raio+raio*Math.cos(u),Raio*t+2*Raio*Pi,raio*Math.sin(u)-m_aa*2*raio*Pi+2*raio*Pi);
					}
					cilindro.setVertex(indV,v); indV++;
				}
			}
			cilindro.makeQuadrConn(numXLine,numYLine);
		}else {
			for(int k=0;k<numYLine;k++){
				double u = (ang[1]-ang[0])*k/(numYLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
				for(int l=0;l<numXLine;l++){
					double t	= (+compr[1]-compr[0])*l/(numXLine-1)+compr[0];
				
					if(u<0.){
						v = new PdVector(Raio+raio*Math.cos(t),Raio*u-m_aa*2*Raio*Pi+2*Raio*Pi,raio*Math.sin(t)-2*raio*Pi+2*raio*Pi);
					}else {
						v = new PdVector(Math.cos(u)*(Raio+raio*Math.cos(t)),Math.sin(u)*(Raio+raio*Math.cos(t))-m_aa*2*Raio*Pi+2*Raio*Pi,raio*Math.sin(t)-2*raio*Pi+2*raio*Pi);
					}
					cilindro.setVertex(indV,v); indV++;
				}
			}
			cilindro.makeQuadrConn(numYLine,numXLine);
		}
		
		cilindro.showElements(mostraFaces);
		cilindro.showEdges(mostraArestas);
		cilindro.showSmoothElementColors(true);
		cilindro.showSmoothLighting(true);
		cilindro.showElementBackColors(false);
		cilindro.update(cilindro);
	}
	
	
	/**Método para transformar nas partes de um rectângulo nas partes de um cilindro e depois nas partes de um toro.*/
	static void rectCilToros(PvDisplayIf ab,PgElementSet[] cilindro,PdVector[] normal,PgElementSet[] facesFig,int valorM,int valorN,double m_a,double raio,double Raio,int numXLine,int numYLine,boolean update){
		double m_aa;
		double t1;
		double t2;
		double larg = 2*Pi;
		double vM,vN;
		if(m_a<=0.5){
			m_aa = 2*m_a;
			t1 = -larg; t2 = 0;
			vM = valorM; vN = valorN;
		}else {
			m_aa = 2*m_a-1;
			t1 = 0; t2 = larg;
			vM = valorN; vN = valorM;
		}
		double u1 = 2*(m_aa-1)*Pi;
		double u2 = 2*Pi*m_aa;
		double uDelta = (u2-u1)/vM;
		double tDelta = (t2-t1)/vN;
		
		double[] ang	= {u1,u1};
		double[] compr	= {t1,t1};
		PdVector ptoIntCili = new PdVector(0.,0.,0.);
		
		int ind	= 0; PdVector v;
		for(int i=0;i<vM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+uDelta;
			compr[1] = t1; 
			for(int j=0;j<vN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+tDelta;
				cilindro[ind].setNumVertices(numXLine*numYLine);
				
				int indV = 0;
				if(m_a<=0.5){
					int[] aa= {i,j};
					ind = parOrdInd(aa,(int) vM,(int) vN);
				}else {
					int[] aa= {j,i};
					ind = parOrdInd(aa,(int) vN,(int) vM);
				}
				
				if(m_a<=0.5){
					for(int k=0;k<numXLine;k++){
						double u = ( ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
						for(int l=0;l<numYLine;l++){
							double t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
							if(u<0.01){
								v = new PdVector(Raio+raio,Raio*t+2*Raio*Pi,raio*u-m_aa*2*raio*Pi+2*raio*Pi);
								ptoIntCili = new PdVector(0.,0.6+2*Raio*Pi,0.6+2*Raio*Pi+2*raio*Pi);
							}else {
								v = new PdVector(Raio+raio*Math.cos(u),Raio*t+2*Raio*Pi,raio*Math.sin(u)-m_aa*2*raio*Pi+2*raio*Pi);
								ptoIntCili = new PdVector(Raio,+2*Raio*Pi,-m_aa*2*raio*Pi+2*raio*Pi);
							}
							
							cilindro[ind].setVertex(indV,v); indV++;
						}
					}
				}else {
					for(int l=0;l<numYLine;l++){
						double t	= (+compr[1]-compr[0])*l/(numYLine-1)+compr[0];
						for(int k=0;k<numXLine;k++){
						
							double u = (-ang[1]+ang[0])*k/(numXLine-1)+ang[1];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
							
							if(u<0.){
								v = new PdVector(Raio+raio*Math.cos(t),Raio*u-m_aa*2*Raio*Pi+2*Raio*Pi,raio*Math.sin(t)-2*raio*Pi+2*raio*Pi);
								ptoIntCili = new PdVector(Raio,Raio*ang[0]-m_aa*2*Raio*Pi+2*Raio*Pi,-2*raio*Pi+2*raio*Pi);
							}else {
								v = new PdVector(Math.cos(u)*(Raio+raio*Math.cos(t)),Math.sin(u)*(Raio+raio*Math.cos(t))-m_aa*2*Raio*Pi+2*Raio*Pi,raio*Math.sin(t)-2*raio*Pi+2*raio*Pi);
								ptoIntCili = new PdVector(Math.cos(ang[0])*Raio,Math.sin(ang[0])*Raio-m_aa*2*Raio*Pi+2*Raio*Pi,-2*raio*Pi+2*raio*Pi);
							}
							cilindro[ind].setVertex(indV,v); indV++;
						}
					}
				}
				cilindro[ind].makeQuadrConn(numXLine,numYLine);
				//cilindro[ind].showElements(true);
				if(update){cilindro[ind].update(cilindro[ind]);}
				int nInd = ind;
				
				cilindro[ind].showTransparency(true);
				cilindro[ind].setTransparency(Puzzle3D.transpMin);
				cilindro[ind].showBoundaries(facesFig[nInd].isShowingBoundaries());
				cilindro[ind].setGlobalBndColor(Puzzle3D.corArestas);
				cilindro[ind].setGlobalBndSize(Puzzle3D.sizeArestas);
				cilindro[ind].showElements(facesFig[nInd].isShowingElements());
				cilindro[ind].showEdges(facesFig[nInd].isShowingEdges());
				cilindro[ind].showElementColors(true);
				cilindro[ind].showSmoothElementColors(true);
				cilindro[ind].showSmoothLighting(true);
				cilindro[ind].showElementBackColors(false);
				cilindro[ind].setGlobalElementColor(facesFig[nInd].getGlobalElementColor());
				cilindro[ind].setVisible(facesFig[nInd].isVisible());
				PdVector[] vert	= {cilindro[ind].getVertex(0),cilindro[ind].getVertex(numYLine-1),cilindro[ind].getVertex(numXLine*numYLine-1-(numYLine-1)),cilindro[ind].getVertex(numXLine*numYLine-1)};
				normal[ind]	= vNormal(vert,ptoIntCili);
				 //ind++;
			}
		}
		//PgPointSet p = new PgPointSet(3); p.setNumVertices(1);p.setVertex(0,new PdVector(0,0,0));ab.addGeometry(p);
	}				
	
	/**Método para transformar um rectângulo num cilindro e depois numa garrafa de klein.*/
	static void rectCilGK(PdVector trans,PdVector dir,PgElementSet cilindro,double m_a,double raio,double Raio,int numXLine,int numYLine,boolean mostraFaces,boolean mostraArestas){
		double m_aa,t1,t2,larg = 2*Pi;
		if(m_a<=0.5){
			m_aa = 2*m_a;
			t1 = -larg; t2 = 0;
		}else {
			m_aa = 2*m_a-1;
			t1 = 0; t2 = larg;
		}
		double u1 = 2*(m_aa-1)*Pi;
		double u2 = 2*Pi*m_aa;
		double[] ang	= {u1,u2};
		double[] compr	= {t1,t2};
		cilindro.setNumVertices(numXLine*numYLine);
		int indV = 0;
		PdVector v; PdVector transl = new PdVector(-13*Pi,-33*Pi,+2*raio*Pi);
		if(m_a<=0.5){
			for(int k=0;k<numYLine;k++){
				double u = (-ang[1]+ang[0])*k/(numYLine-1)+ang[1];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
				for(int l=0;l<numXLine;l++){
					double t	= (compr[1]-compr[0])*l/(numXLine-1)+compr[0];
					if(u<0.01){
						v = new PdVector(Raio+raio-6*t,-16*t,raio*(u)-m_aa*4*Pi);//new PdVector(Raio+raio-6*u,-16*u,raio*t-m_aa*4*Pi);
						v = somaVect(rotacaoVect(v,dir,Pi/2),trans);
					}else {
						v = new PdVector(Raio+raio*Math.cos(u)-6*t,-16*t,raio*Math.sin(u)-m_aa*4*Pi);
						v = somaVect(rotacaoVect(v,dir,Pi/2),trans);
					}
					cilindro.setVertex(indV,somaVect(v,transl)); indV++;
				}
			}
			cilindro.makeQuadrConn(numYLine,numXLine);
		}else {
			for(int k=0;k<numXLine;k++){
				double u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
				for(int l=0;l<numYLine;l++){
					double t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
					if(u<0.){
						v = new PdVector(Raio+raio*Math.cos(Pi/2-t)-6*u+12*m_aa*Pi,-16*u+32*m_aa*Pi,raio*Math.sin(Pi/2-t)-4*Pi);
					}else {
						double a = (raio+Raio)/(2*Raio); double b = (-raio-Raio)/(raio-Raio);
						double uu = 2*Pi-u;
						double bb = Pi/2*(1 - Math.cos(uu/2-Pi/2)*Math.cos(uu/2-Pi/2));
						double x,y,z;
						if(uu<=2*Pi&&uu>Pi){
							x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(t+Pi+bb);
							y = 16*Math.sin(uu);
						}else {
							x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(uu)*Math.cos(t+bb);
							y = 16*Math.sin(uu)+a*Raio*(1-Math.cos(uu)/b)*Math.sin(uu)*Math.cos(t+bb);
						}
						z = a*Raio*(1-Math.cos(uu)/b)*Math.sin(t+bb);
						v = new PdVector(x+m_aa*12*Pi,y+m_aa*32*Pi,z-4*Pi);
					}
					cilindro.setVertex(indV,somaVect(v,transl)); indV++;
				}
			}
			cilindro.makeQuadrConn(numXLine,numYLine);
		}
		cilindro.showElements(mostraFaces);
		cilindro.showEdges(mostraArestas);
		cilindro.showSmoothElementColors(true);
		cilindro.showSmoothLighting(true);
		cilindro.showElementBackColors(false);
		cilindro.update(cilindro); 
	}

	/**Método para transformar as partes de um rectângulo nas correspondentes de um cilindro e depois nas correspondentes de uma garrafa de klein.*/
	static void rectCilGKs(PvDisplayIf ab,PdVector trans,PdVector dir,PgElementSet[] cilindro,PdVector[] normal,PgElementSet[] facesFig,double valorM,double valorN,double m_a,double raio,double Raio,int numXLine,int numYLine,boolean update){
		double m_aa,t1,t2,vM,vN,larg = 2*Pi;
		if(m_a<=0.5){
			m_aa = 2*m_a;	t1 = -larg; t2 = 0; vM = valorN; vN = valorM;
		}else {
			m_aa = 2*m_a-1;	t1 = 0; t2 = larg;	vM = valorM; vN = valorN;
		}
		double u1 = 2*(m_aa-1)*Pi, u2 = 2*Pi*m_aa, uDelta = (u2-u1)/vM, tDelta = (t2-t1)/vN;
		double[] ang	= {u1,u1}, compr	= {t1,t1};
		double u;
		PdVector ptoIntGK = new PdVector(0,0,0); PdVector transl = new PdVector(-13*Pi,-33*Pi,+2*raio*Pi);
		int ind	= 0;
		for(int i=0;i<vM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+uDelta; compr[1] = t1; 
			for(int j=0;j<vN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+tDelta;
				cilindro[ind].setNumVertices(numXLine*numYLine);
				int indV = 0;
				if(m_a<=0.5){
					int[] aa= {j,(int) (vM-1-i)}; ind = parOrdInd(aa,(int) vN,(int) vM);
				}else {
					int[] aa= {i,j};	ind = parOrdInd(aa,(int) vM,(int) vN);
				}
				PdVector v;
				
				if(m_a<=0.5){
					for(int l=0;l<numYLine;l++){
						double t	= (compr[1]-compr[0])*l/(numYLine-1)+compr[0];
						for(int k=0;k<numXLine;k++){
							u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
							if(u<0.01){
								v = new PdVector(Raio+raio-6*t,-16*t,raio*u-m_aa*2*raio*Pi);//new PdVector(Raio+raio-6*u,-16*u,raio*t-m_aa*4*Pi);
								v = somaVect(rotacaoVect(v,dir,Pi/2),trans);
								PdVector pto = new PdVector(0.1,0.1,0.1);
								ptoIntGK	= somaVect(transl,somaVect(rotacaoVect(pto,dir,Pi/2),trans));
							}else {
								v = new PdVector(Raio+raio*Math.cos(u)-6*t,-16*t,raio*Math.sin(u)-m_aa*2*raio*Pi);
								v = somaVect(rotacaoVect(v,dir,Pi/2),trans);
								PdVector pto = new PdVector(Raio-6*compr[0],-16*compr[0],-2*raio*Pi);
								ptoIntGK	= somaVect(transl,somaVect(rotacaoVect(pto,dir,Pi/2),trans));
							}
							
							cilindro[ind].setVertex(indV,somaVect(v,transl)); indV++;
						}
					}
				}else {
					for(int k=0;k<numXLine;k++){
						u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
						for(int l=0;l<numYLine;l++){
							double t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
							if(u<0.){
								v = new PdVector(Raio+raio*Math.cos(Pi/2-t)-6*u+12*m_aa*Pi,-16*u+32*m_aa*Pi,raio*Math.sin(Pi/2-t)-2*raio*Pi);
								ptoIntGK	= new PdVector(Raio-6*ang[0]+12*m_aa*Pi,-16*ang[0]+32*m_aa*Pi,-2*raio*Pi);
							}else {
								double a = (raio+Raio)/(2*Raio); double b = (-raio-Raio)/(raio-Raio);
								double uu = 2*Pi-u;
								double bb = Pi/2*(1 - Math.cos(uu/2-Pi/2)*Math.cos(uu/2-Pi/2));
								double x, y, z, bx, by;
								if(uu<=2*Pi&&uu>Pi){
									x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(t+Pi+bb);
									y = 16*Math.sin(uu);
									bx = 6*Math.cos(2*Pi-ang[0])*(1+Math.sin(2*Pi-ang[0]));
									by = 16*Math.sin(2*Pi-ang[0]);
								}else {
									x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(uu)*Math.cos(t+bb);
									y = 16*Math.sin(uu)+a*Raio*(1-Math.cos(uu)/b)*Math.sin(uu)*Math.cos(t+bb);
									bx = 6*Math.cos(2*Pi-ang[0])*(1+Math.sin(2*Pi-ang[0]));
									by = 16*Math.sin(2*Pi-ang[0]);
								}
								z = a*Raio*(1-Math.cos(uu)/b)*Math.sin(t+bb);
								v = new PdVector(x+m_aa*12*Pi,y+m_aa*32*Pi,z-2*raio*Pi);
								if((1.5*Pi>=ang[0]&&1.5*Pi<=ang[1])){
									ptoIntGK	= new PdVector(+0,1,0);
								}else {
									ptoIntGK	= new PdVector(bx+m_aa*12*Pi,by+m_aa*32*Pi,-2*raio*Pi);
								}
								
							}
							cilindro[ind].setVertex(indV,somaVect(v,transl)); indV++;
						}
					}
					ptoIntGK = somaVect(ptoIntGK,transl);
				}
				cilindro[ind].makeQuadrConn(numXLine,numYLine);
				if(update){cilindro[ind].update(cilindro[ind]); }
				int nInd = ind;
					
				cilindro[ind].showTransparency(true);
				cilindro[ind].setTransparency(Puzzle3D.transpMin);
				cilindro[ind].showBoundaries(facesFig[nInd].isShowingBoundaries());
				cilindro[ind].setGlobalBndColor(Puzzle3D.corArestas);
				cilindro[ind].setGlobalBndSize(Puzzle3D.sizeArestas);
				cilindro[ind].showElements(facesFig[nInd].isShowingElements());
				cilindro[ind].showEdges(facesFig[nInd].isShowingEdges());
				cilindro[ind].showElementColors(true);
				cilindro[ind].showSmoothElementColors(true);
				cilindro[ind].showSmoothLighting(true);
				cilindro[ind].showElementBackColors(false);
				cilindro[ind].setGlobalElementColor(facesFig[nInd].getGlobalElementColor());
				cilindro[ind].setVisible(facesFig[nInd].isVisible());
				PdVector[] vert	= {cilindro[ind].getVertex(0),cilindro[ind].getVertex(numYLine-1),cilindro[ind].getVertex(numXLine*numYLine-1-(numYLine-1)),cilindro[ind].getVertex(numXLine*numYLine-1)};
				normal[ind]	= vNormal(vert,ptoIntGK);
				//ind++;
			}
			
			//PgPointSet p = new PgPointSet(3); p.setNumVertices(1);p.setVertex(0,new PdVector(0,0,0));ab.addGeometry(p);
		}
		
	}
	
	
	/*static void rectCilGK(PgElementSet[] cilindro,PgElementSet[] facesFig,int valorM,int valorN,double m_a,double raio,double Raio,int numXLine,int numYLine){
		double m_aa;
		double t1;
		double t2;
		double larg = 2*Pi;
		if(m_a<=0.5){
			m_aa = 2*m_a;
			t1 = -larg; t2 = 0;
		}else {
			m_aa = 2*m_a-1;
			t1 = 0; t2 = larg;
		}
		double u1 = 2*(m_aa-1)*Pi;
		double u2 = 2*Pi*m_aa;
		double[] ang	= {u1,u1};
		double uDelta = (u2-u1)/valorM;
		double[] compr	= {t1,t1};
		double tDelta = (t2-t1)/valorN;
			
		int ind	= 0;
		for(int i=0;i<valorM;i++){
			ang[0] = ang[1]; ang[1] = ang[1]+uDelta;
			compr[1] = t1; 
			for(int j=0;j<valorN;j++){
				compr[0] = compr[1]; compr[1] = compr[1]+tDelta;
					
				cilindro[ind].setNumVertices(numXLine*numYLine);
					
				int indV = 0;
				for(int k=0;k<numXLine;k++){
					
					for(int l=0;l<numYLine;l++){
						
						PdVector v;
						if(m_a<=0.5){
							double u = (-ang[1]+ang[0])*k/(numXLine-1)+ang[1];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
							double t	= (-compr[1]+compr[0])*l/(numYLine-1)+compr[1];
							if(u<0.01){
								v = new PdVector(raio+Raio-6*t,-16*t,Raio*u-m_aa*4*Pi);//new PdVector(Raio+raio-6*u,-16*u,raio*t-m_aa*4*Pi);
							}else {
								v = new PdVector(raio+Raio*Math.cos(u)-6*t,-16*t,Raio*Math.sin(u)-m_aa*4*Pi);
							}
						}else {
							double u = (ang[1]-ang[0])*k/(numXLine-1)+ang[0];//Varia entre {u, 2 (a - 1) Pi, 2 Pi a}
							double t	= (compr[1]-compr[0])*l/(numYLine-1)+compr[0];
							if(u<0.){
								v = new PdVector(Raio+raio*Math.cos(Pi/2-t)-6*u+12*m_aa*Pi,-16*u+32*m_aa*Pi,raio*Math.sin(Pi/2-t)-4*Pi);
							}else {
								double a = (raio+Raio)/(2*Raio); double b = (-raio-Raio)/(raio-Raio);
								double uu = 2*Pi-u;
								double bb = Pi/2*(1 - Math.cos(uu/2-Pi/2)*Math.cos(uu/2-Pi/2));
								double x,y,z;
								if(uu<=2*Pi&&uu>Pi){
									x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(t+Pi+bb);
									y = 16*Math.sin(uu);
								}else {
									x = 6*Math.cos(uu)*(1+Math.sin(uu))+a*Raio*(1-Math.cos(uu)/b)*Math.cos(uu)*Math.cos(t+bb);
									y = 16*Math.sin(uu)+a*Raio*(1-Math.cos(uu)/b)*Math.sin(uu)*Math.cos(t+bb);
								}
								z = a*Raio*(1-Math.cos(uu)/b)*Math.sin(t+bb);
								v = new PdVector(x+m_aa*12*Pi,y+m_aa*32*Pi,z-4*Pi);
							}
						}
												
						cilindro[ind].setVertex(indV,v); indV++;
					}
				}
					
				cilindro[ind].makeQuadrConn(numXLine,numYLine);
				int nInd = ind;
					
				cilindro[ind].showTransparency(true);
				cilindro[ind].setTransparency(facesFig[nInd].getTransparency());
				cilindro[ind].showBoundaries(facesFig[nInd].isShowingBoundaries());
				cilindro[ind].setGlobalBndColor(facesFig[nInd].getGlobalBndColor());
				cilindro[ind].setGlobalBndSize(facesFig[nInd].getGlobalBndSize());
				cilindro[ind].showElements(facesFig[nInd].isShowingElements());
				cilindro[ind].showEdges(facesFig[nInd].isShowingEdges());
				cilindro[ind].showElementColors(true);
				cilindro[ind].setGlobalElementColor(facesFig[nInd].getGlobalElementColor());
				cilindro[ind].setVisible(facesFig[nInd].isVisible());
				cilindro[ind].update(cilindro[ind]); ind++;
			}
		}
	}*/				
			
	
		/**Para construir um cilindro dado as suas extremidades, P e Q, e raio, e dadas o nº de linhas em ambasa as direcções.*/
		static void computePartesCilindroNumLines(PgElementSet cilindro,PdVector P,PdVector Q,double raio,int numXLine,int numYLine,double[] ang,double[] compr,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean mostraArestasMesmo,Color corArestasMesmo,double sizeArestasMesmo,boolean visivel){
			PdVector PQ	= uv(P,Q);
			PdVector ortog	= vectOrtogonal(PQ,1);ortog	= uni(ortog);
			PdVector w	= cross(PQ,ortog);	w	= uni(w);
									
			cilindro.setNumVertices(numXLine*numYLine);
			cilindro.setNumElements(numXLine+1);
			int ind	= 0;
						
			for(int i=0;i<numXLine;i++){
				double a = (ang[1]-ang[0])*i/(numXLine-1)+ang[0];//Varia entre 0 e 2Pi.
				for(int j=0;j<numYLine;j++){
					double k = (compr[1]-compr[0])*j/(numYLine-1)+compr[0];//Varia entre 0 e 1.
					//Cada ponto do cilindro P+k(Q-P)+raio*cos(a)*u+raio*sin(a)*v, em que u é ortogonal a PQ e v ortogonal a u e a PQ 
					PdVector v = somaVect(somaVect(P,multiVectNum(k,uv(P,Q))),somaVect(multiVectNum(raio*Math.cos(a),ortog),multiVectNum(raio*Math.sin(a),w)));
									
					cilindro.setVertex(ind,v); ind++;
				}
			}
			cilindro.makeQuadrConn(numXLine,numYLine);
			
			cilindro.showTransparency(true);
			cilindro.setTransparency(transp);
			cilindro.showBoundaries(mostraArestas);
			cilindro.setGlobalBndColor(corArestas);
			cilindro.setGlobalBndSize(sizeArestas);
			cilindro.showElements(mostraFaces);
			cilindro.showEdges(mostraArestasMesmo);
			cilindro.setGlobalEdgeColor(corArestasMesmo);
			cilindro.setGlobalEdgeSize(sizeArestasMesmo);
			cilindro.showElementColors(true);
			cilindro.setGlobalElementColor(cor);
			cilindro.setVisible(visivel);
			cilindro.showSmoothElementColors(true);
			cilindro.showSmoothLighting(true);
			cilindro.showElementBackColors(false);
			cilindro.update(cilindro);
		}

	/**Para construir um cilindro dado as suas extremidades, P e Q, e raio, e dadas o nº de linhas em ambasa as direcções.*/
	static void computePartesCilindroNumLinesProp(PgElementSet cilindro,PdVector P,PdVector Q,double raio,int numXLine,int numYLine,double[] ang,double[] compr,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean mostraArestasMesmo,Color corArestasMesmo,double sizeArestasMesmo,boolean visivel){
		cilindro.showTransparency(true);
		cilindro.setTransparency(transp);
		cilindro.showBoundaries(mostraArestas);
		cilindro.setGlobalBndColor(corArestas);
		cilindro.setGlobalBndSize(sizeArestas);
		cilindro.showElements(mostraFaces);
		cilindro.showEdges(mostraArestasMesmo);
		cilindro.setGlobalEdgeColor(corArestasMesmo);
		cilindro.setGlobalEdgeSize(sizeArestasMesmo);
		cilindro.showElementColors(true);
		cilindro.setGlobalElementColor(cor);
		cilindro.setVisible(visivel);
		cilindro.showSmoothElementColors(true);
		cilindro.showSmoothLighting(true);
		cilindro.showElementBackColors(false);
		cilindro.update(cilindro);
	}
		
		/**Para construir um cilindro dado as suas extremidades, P e Q, e raio.*/
		static PdVector[][] computeCoordCilindro(PdVector P,PdVector Q,double raio){
			PdVector PQ	= uv(P,Q);
			PdVector ortog	= vectOrtogonal(PQ,1);
			PdVector w	= cross(PQ,ortog);
					
			int numXLine	= 10;
			int numYLine	= 2;
					
			PdVector[][] faces	= new PdVector[numXLine-1][4];	
			int ind	= 0;
			PdVector[][] v = new PdVector[numXLine][2];
			
			for(int i=0;i<numXLine;i++){
				double a = 2*Pi*i/(numXLine-1);//Varia entre 0 e 2Pi.
				for(int j=0;j<numYLine;j++){
					double k = j/(numYLine-1);//Varia entre 0 e 1.
					//Cada ponto do cilindro P+k(Q-P)+raio*cos(a)*u+raio*sin(a)*v, em que u é ortogonal a PQ e v ortogonal a u e a PQ 
					v[i][j] = somaVect(somaVect(P,multiVectNum(k,uv(P,Q))),somaVect(multiVectNum(raio*Math.cos(a),ortog),multiVectNum(raio*Math.sin(a),w)));
					
				}
			}
			int indV	= 0;
			for(int i=0;i<numXLine-1;i++){
				faces[ind][0] = v[indV][0];	
				faces[ind][1] = v[indV][1];	indV++;
				faces[ind][2] = v[indV][1];	
				faces[ind][3] = v[indV][0];	ind++; 
				
			}
			
			return faces;
		}
				
		


		
		/**Para construir grelhas.*/
		static void computeGrellha(PgElementSet grelha,int xMin,int xMax,int yMin,int yMax,Color corGrelha,double sizeGrelha,Color corFundo){
			grelha.computePlane(xMax-xMin+1,yMax-yMin+1,xMin,yMin,xMax,yMax);
			grelha.setGlobalEdgeColor(corGrelha);//a grelha fica menos preta e mais cinzenta
			grelha.setGlobalElementColor(corFundo);
			grelha.setGlobalEdgeSize(sizeGrelha);
		}
		
		/**Parametrização da Tira de Mobius (fechada)*/
		/*static void computeTiraMoebius(PgElementSet tiraParam,double raio,double altura,double rot,int numXLines,int numYLines,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			double zMin	= -altura/2;
			double zMax	= altura/2;
			int ind		= 0;
			double x;
			double y;
			double z;
				
			tiraParam.setNumVertices(numXLines*numYLines);
			for (double i=0; i<numXLines;i=(i+1)) {
				double u =((2*Math.PI)*i)/(numXLines-1);//Valores a variar entre 0 e 2Pi, podendo ou não haver uma rotação de um ângulo "-Piang" se estiver a deslizar.
				for (double j=0; j<numYLines; j=(j+1)) {
					double v 	= j*(zMax-zMin)/(numYLines-1)+zMin;//Valores a variar entre zMin e zMax 
					x = (raio+v*Math.cos(u/2))*Math.cos(u);
					y = (raio+v*Math.cos(u/2))*Math.sin(u);
					z	= v*Math.sin(v/2);
					tiraParam.setVertex(ind++,x,y,z);			
				}
			}
			tiraParam.makeQuadrConn(numXLines,numYLines);
				
			tiraParam.setGlobalElementColor(cor);
				
			tiraParam.showEdges(mostraArestas);
			tiraParam.showElements(mostraFaces);
			tiraParam.setVisible(visivel);
			tiraParam.update(tiraParam);		
		}*/
		
				
		static void computeTiraMoebius(PgElementSet tiraParam,double raio,double altura,double rot,int numXLines,int numYLines,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			double zMin	= -altura/2;
			double zMax	= altura/2;
			int ind		= 0;
			double x;
			double y;
			double z;
			
			tiraParam.setNumVertices(numXLines*numYLines);
			for (double i=0; i<numXLines;i=(i+1)) {
				double u =((2*Math.PI)*i)/(numXLines-1);//Valores a variar entre 0 e 2Pi, podendo ou não haver uma rotação de um ângulo "-Piang" se estiver a deslizar.
				for (double j=0; j<numYLines; j=(j+1)) {
					double v 	= j*(-zMax+zMin)/(numYLines-1)+zMax;//Valores a variar entre zMax e zMin 
					double xx	= raio*(Math.cos(u)+v*Math.cos(u/2)*Math.cos(u));//Valor da abcissa pela parametrização da Tira de Mobius
					double yy	= raio*(Math.sin(u)+v*Math.cos(u/2)*Math.sin(u));//Valor da ordenada pela parametrização da Tira de Mobius
					x = xx;//Math.cos(rot)*xx-Math.sin(rot)*yy;//Rodar o valor da abcissa 90º em torno do eixo dos zz, a intenção é colocar a tira "sentada" sobre o plano xoz
					y = yy;//raio+Math.sin(rot)*xx+Math.cos(rot)*yy;//Rodar o valor da ordenada 90º em torno do eixo dos zz, a intenção é colocar a tira "sentada" sobre o plano xoz, depois sobe-se ligeiramente a Tira para ainda ficar melhor.
					z = raio*v*Math.sin(u/2);//Valor da cota pela parametrização da Tira, este valor não irá sofrer nenhum rotação, é em torno do seu eixo que é rodada a Tira.
					tiraParam.setVertex(ind++,x,y,z);			
				}
			}
			tiraParam.makeQuadrConn(numXLines,numYLines);
			tiraParam.setGlobalElementColor(cor);
			tiraParam.showEdges(mostraArestas);
			tiraParam.showElements(mostraFaces);
			tiraParam.setVisible(visivel);
			tiraParam.showSmoothElementColors(true);
			tiraParam.showSmoothLighting(true);
			tiraParam.showElementBackColors(false);
			tiraParam.update(tiraParam);		
		}
		
		/**Parametrização de partes da Tira de Mobius (fechada)*/
		/*static void computePartesTiraMoebius(PgElementSet tiraParam,double raio,double altura,int numXLines,int numYLines,double[] angX,double alt,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			double zMin	= -alt/2;
			double zMax	= alt/2;
			int ind		= 0;
			double x;
			double y;
			double z;
					
			tiraParam.setNumVertices(numXLines*numYLines);
			for (double i=0; i<numXLines;i=(i+1)) {
				double u =(angX[1]-angX[0])*i/(numXLines-1)+angX[0];//Valores a variar entre 0 e 2Pi, podendo ou não haver uma rotação de um ângulo "-Piang" se estiver a deslizar.
				for (double j=0; j<numYLines; j=(j+1)) {
					double v 	= j*(zMax-zMin)/(numYLines-1)+zMin;//Valores a variar entre zMin e zMax 
					x = (raio+v*Math.cos(u/2))*Math.cos(u);
					y = (raio+v*Math.cos(u/2))*Math.sin(u);
					z	= v*Math.sin(v/2);
					tiraParam.setVertex(ind++,x,y,z);			
				}
			}
			tiraParam.makeQuadrConn(numXLines,numYLines);
					
			tiraParam.setGlobalElementColor(cor);
					
			tiraParam.showEdges(mostraArestas);
			tiraParam.showElements(mostraFaces);
			tiraParam.setVisible(visivel);
			tiraParam.update(tiraParam);		
		}*/
		
		static void computePartesTiraMoebius(PgElementSet tiraParam,double raio,double altura,double rot,int numXLines,int numYLines,double[] angX,double alt,int indI,int valorN,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			double coeficienteTrans	= ((2*valorN-2)/(valorN-1))*indI-valorN+2;
			
			double zMin	= -altura/2;
			double zMax	= altura/2;
			int ind		= 0;
			double x;
			double y;
			double z;
					
			tiraParam.setNumVertices(numXLines*numYLines);
			for (double i=0; i<numXLines;i=(i+1)) {
				double u =(angX[1]-angX[0])*i/(numXLines-1)+angX[0];//Valores a variar entre 0 e 2Pi, podendo ou não haver uma rotação de um ângulo "-Piang" se estiver a deslizar.
				for (double j=0; j<numYLines; j=(j+1)) {
					double v 	= j*(zMax-zMin)/(numYLines-1)+coeficienteTrans*zMin;//Valores a variar entre zMin e zMax 
					double xx	= raio*(Math.cos(u)+v*Math.cos(u/2)*Math.cos(u));//Valor da abcissa pela parametrização da Tira de Mobius
					double yy	= raio*(Math.sin(u)+v*Math.cos(u/2)*Math.sin(u));//Valor da ordenada pela parametrização da Tira de Mobius
					x = xx;//Math.cos(rot)*xx-Math.sin(rot)*yy;//Rodar o valor da abcissa 90º em torno do eixo dos zz, a intenção é colocar a tira "sentada" sobre o plano xoz
					y = yy;//raio+Math.sin(rot)*xx+Math.cos(rot)*yy;//Rodar o valor da ordenada 90º em torno do eixo dos zz, a intenção é colocar a tira "sentada" sobre o plano xoz, depois sobe-se ligeiramente a Tira para ainda ficar melhor.
					z = raio*v*Math.sin(u/2);//Valor da cota pela parametrização da Tira, este valor não irá sofrer nenhum rotação, é em torno do seu eixo que é rodada a Tira.
					tiraParam.setVertex(ind++,x,y,z);			
				}
			}
			tiraParam.makeQuadrConn(numXLines,numYLines);
			
			tiraParam.showTransparency(true);
			tiraParam.setTransparency(transp);
			tiraParam.setGlobalElementColor(cor);
			tiraParam.showBoundaries(mostraArestas);
			tiraParam.setGlobalBndColor(corArestas);
			tiraParam.setGlobalBndSize(sizeArestas);
			tiraParam.showEdges(false);
			tiraParam.showElements(mostraFaces);
			tiraParam.setVisible(visivel);
			tiraParam.showSmoothElementColors(true);
			tiraParam.showSmoothLighting(true);
			tiraParam.showElementBackColors(false);
			tiraParam.update(tiraParam);		
		}
		
	static void computePartesTiraMoebiusProp(PgElementSet tiraParam,double raio,double altura,double rot,int numXLines,int numYLines,double[] angX,double alt,int indI,int valorN,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
		tiraParam.showTransparency(true);
		tiraParam.setTransparency(transp);
		tiraParam.setGlobalElementColor(cor);
		tiraParam.showBoundaries(mostraArestas);
		tiraParam.setGlobalBndColor(corArestas);
		tiraParam.setGlobalBndSize(sizeArestas);
		tiraParam.showEdges(false);
		tiraParam.showElements(mostraFaces);
		tiraParam.setVisible(visivel);
		tiraParam.showSmoothElementColors(true);
		tiraParam.showSmoothLighting(true);
		tiraParam.showElementBackColors(false);
		tiraParam.update(tiraParam);		
	}
			
		/**Parametrização da Tira de Mobius (fechada)*/
		static void computeGarrafaKlein1(PgElementSet garrafa,double a,double altura,int numXLines,int numYLines,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
			int ind			= 0;
			double x;
			double y;
			double z;
					
			garrafa.setNumVertices(numXLines*numYLines);
			for (double i=0; i<numXLines;i++) {
				double u	= 2*Pi*i/(numXLines-1);//Valores a variar entre 0 e 2Pi.
				for (double j=0; j<numYLines; j++) {
					double v 	= 2*Pi*j/(numYLines-1);//Valores a variar entre 0 e 2Pi.
					double inter	= a+Math.cos(u/2)*Math.sin(v)-Math.sin(u/2)*Math.sin(2*v);
					x = inter*Math.cos(u);
					y = inter*Math.sin(u);
					z = altura*(Math.sin(u/2)*Math.sin(v)+Math.cos(u/2)*Math.sin(2*v));
					/*double inter	= Math.cos(u/2)*(Math.sqrt(2)+Math.cos(v))+Math.sin(u/2)*Math.sin(v)*Math.cos(v);
					x	= Math.cos(u)*inter;
					y	= Math.sin(u)*inter;
					z	= -Math.sin(u/2)*(Math.sqrt(2)+Math.cos(v))+Math.cos(u/2)*Math.sin(v)*Math.cos(v);*/
					garrafa.setVertex(ind++,z,x, y);			
				}
			}
			garrafa.makeQuadrConn(numXLines,numYLines);
					
			garrafa.setGlobalElementColor(cor);
					
			garrafa.showEdges(mostraArestas);
			garrafa.showElements(mostraFaces);
			garrafa.setVisible(visivel);
			garrafa.showSmoothElementColors(true);
			garrafa.showSmoothLighting(true);
			garrafa.showElementBackColors(false);
			garrafa.update(garrafa);		
		}
		
	/**Parametrização da garrafa de klein*/
	static void computeGarrafaKlein(PgElementSet garrafa,double R,double r,int numXLines,int numYLines,Color cor,boolean mostraFaces,boolean mostraArestas,boolean visivel){
		int ind			= 0;
		double x;
		double y;
		double z;
		
		double a	= (r+R)/(2*R);
		double b	= (-r-R)/(r-R);
		double ee ;
		ee = Pi/2;
		garrafa.setNumVertices(numXLines*numYLines);
		for (double i=0; i<numXLines;i++) {
			double u	= -2*Pi*i/(numXLines-1)+2*Pi;//Valores a variar entre 0 e 2Pi.
			double bb	= ee*(1-Math.pow(Math.cos(u/2-Pi/2),2));//ee*(1-Math.pow(2,Math.cos(u/2-Pi/2)));//bb[u_, e_:ee] := e(1 - Cos[u/2 - Pi/2]^2);
			double rad = a*R*(1 - Math.cos(u)/b);
			double bx = 6*Math.cos(u)*(1 + Math.sin(u));
			double by = 16*Math.sin(u);	
			for (double j=0; j<numYLines; j++) {
				double v 	= -2*Pi*j/(numYLines-1)+2*Pi;//Valores a variar entre 0 e 2Pi.
				if(u>Pi&&u<=2*Pi){
					x	= bx+rad*Math.cos(v+Pi+bb);
					y	= by;
				}else {
					x	= bx + rad*Math.cos(u)*Math.cos(v+bb);
					y	= by + rad*Math.sin(u)*Math.cos(v+bb);
				}
				z = rad*Math.sin(v+bb);
				garrafa.setVertex(ind++,x,y,z);			
			}
		}
		garrafa.makeQuadrConn(numXLines,numYLines);
					
		garrafa.setGlobalElementColor(cor);
					
		garrafa.showEdges(mostraArestas);
		garrafa.showElements(mostraFaces);
		garrafa.setVisible(visivel);
		garrafa.showSmoothElementColors(true);
		garrafa.showSmoothLighting(true);
		garrafa.showElementBackColors(false);
		garrafa.update(garrafa);		
	}

	/**Parametrização da Tira de Mobius (fechada)*/
	static void computePartesGarrafaKlein(PgElementSet garrafa,double R,double r,int numXLines,int numYLines,double[] angX,double[] angY,Color cor,Color corArestas,double sizeArestas,double transp,boolean mostraFaces,boolean mostraArestas,boolean visivel){
		int ind	= 0;
		double x;
		double y;
		double z;
		
		double a	= (r+R)/(2*R);
		double b	= (-r-R)/(r-R);
		double ee ;
		ee = Pi/2;//if(numYLines%2!=0){ee = 0;}else {ee = Pi/2;}//ee = If[OddQ[ppv], 0, 2Pi/(4ppv) // N];
		garrafa.setNumVertices(numXLines*numYLines);
		for (double i=0; i<numXLines;i++) {
			double u	= (-angX[1]+angX[0])*i/(numXLines-1)+angX[1];//Valores a variar entre 0 e 2Pi.
			double bb	= ee*(1-Math.pow(Math.cos(u/2-Pi/2),2));//ee*(1-Math.pow(2,Math.cos(u/2-Pi/2)));//bb[u_, e_:ee] := e(1 - Cos[u/2 - Pi/2]^2);
			double rad = a*R*(1 - Math.cos(u)/b);
			double bx = 6*Math.cos(u)*(1 + Math.sin(u));
			double by = 16*Math.sin(u);	
			for (double j=0; j<numYLines; j++) {
				double v 	= (-angY[1]+angY[0])*j/(numYLines-1)+angY[1];//Valores a variar entre 0 e 2Pi.
				if(u>Pi&&u<=2*Pi){
					x	= bx+rad*Math.cos(v+Pi+bb);
					y	= by;
					z 	= rad*Math.sin(v+bb);
				}else {
					x	= bx + rad*Math.cos(u)*Math.cos(v+bb);
					y	= by + rad*Math.sin(u)*Math.cos(v+bb);
					z 	= rad*Math.sin(v+bb);
				}
				
				garrafa.setVertex(ind++,x,y,z);			
			}
		}
		garrafa.makeQuadrConn(numXLines,numYLines);
		
		garrafa.setGlobalElementColor(cor);
		garrafa.showTransparency(true);
		garrafa.setTransparency(transp);
		garrafa.setGlobalElementColor(cor);
		garrafa.showBoundaries(mostraArestas);
		garrafa.setGlobalBndColor(corArestas);
		garrafa.setGlobalBndSize(sizeArestas);
		garrafa.showEdges(false);
		garrafa.showElements(mostraFaces);
		garrafa.setVisible(visivel);
		garrafa.showSmoothElementColors(true);
		garrafa.showSmoothLighting(true);
		garrafa.showElementBackColors(false);
		garrafa.update(garrafa);		
	}
				
	/*......................................................................*/
	
	
	
	
	
	
	/*Funções:*/
	
		/**Soma entre dois vectores.*/
		static PdVector somaVect(PdVector u,PdVector v){
			PdVector soma	= new PdVector(u.m_data[0]+v.m_data[0],u.m_data[1]+v.m_data[1],u.m_data[2]+v.m_data[2]);
			return soma;
		}
		
		/**Diferença entre dois vectores.*/
		static PdVector difVect(PdVector u,PdVector v){
			PdVector diferença	= new PdVector(u.m_data[0]-v.m_data[0],u.m_data[1]-v.m_data[1],u.m_data[2]-v.m_data[2]);
			return diferença;
		}
		

		/**Determinar um vector, de comprimento r, ortogonal ao vector u*/
		static PdVector vectOrtogonal(PdVector u,double r){
			PdVector e1	= new PdVector(1,0,0);//Um dos vectores da base canónica
			PdVector e2	= new PdVector(0,1,0);//Um dos vectores da base canónica
			PdVector uUni	= uni(u);
			PdVector	e;
			if(Math.abs(produtoEscalar(uUni,e1))>0.95){
				e	= e2;
			}else {
				e	= e1;
			}
			PdVector vectorOrtogonal	= multiVectNum(r,uni(difVect(e,multiVectNum(produtoEscalar(uUni,e),uUni))));//=r*uni(e-(e.u)u)
			return vectorOrtogonal;
		}
		
		/**Produto entre um número e um vector.*/
		/*in[x_, r_:1.] := r^2/x;*/
		static PdVector multiVectNum(double u,PdVector v){
			PdVector multiplicacao	= new PdVector(u*v.m_data[0],u*v.m_data[1],u*v.m_data[2]);
			return multiplicacao;
		}
		
		/**Verificar se dois vectore são muito parecidos.*/
		static boolean iguais(PdVector u,PdVector v,double eps){
			boolean saoIguais;
			if(Math.abs(u.m_data[0]-v.m_data[0])<=eps&&Math.abs(u.m_data[1]-v.m_data[1])<=eps&&Math.abs(u.m_data[2]-v.m_data[2])<=eps){
				saoIguais	= true;
			}else {
				saoIguais	= false;
			}
			
			return saoIguais;
		}

		
		/**Vector uv.*/
		static PdVector uv(PdVector u,PdVector v){
			PdVector uv	= new PdVector(-u.m_data[0]+v.m_data[0],-u.m_data[1]+v.m_data[1],-u.m_data[2]+v.m_data[2]);
			return uv;
		}
		
		/**Produto entre um número e um vector.*/
		static PdVector multiNumVect(double u,PdVector v){
			PdVector multiplicacao	= new PdVector(u*v.m_data[0],u*v.m_data[1],u*v.m_data[2]);
			return multiplicacao;
		}
		
		/**Produto escalar entre dois vectores*/
		/*u.v*/
		static double produtoEscalar(PdVector u,PdVector v){
			double produto	= PdVector.dot(u,v);//= u.m_data[0]*v.m_data[0]+u.m_data[1]*v.m_data[1]+u.m_data[2]*v.m_data[2];
			return produto;
		}
		
		/**Produto entre uma matriz e um vector*/
		static PdVector produtoMaVect(PdVector[] m,PdVector v){
			double x	= produtoEscalar(m[0],v);
			double y	= produtoEscalar(m[1],v);
			double z	= produtoEscalar(m[2],v);
			PdVector produto	= new PdVector(x,y,z);
					
			return produto;
		}
		
		
		/**Matriz transposta*/
		static PdVector[] transpose(PdVector[] m){
			PdVector[]	matrizTransp	= new PdVector[3];
			matrizTransp[0]	= new PdVector(m[0].m_data[0],m[1].m_data[0],m[2].m_data[0]);
			matrizTransp[1]	= new PdVector(m[0].m_data[1],m[1].m_data[1],m[2].m_data[1]);
			matrizTransp[2]	= new PdVector(m[0].m_data[2],m[1].m_data[2],m[2].m_data[2]);
			return matrizTransp;
		}
		
		/**Produto entre duas matrizes, sendo que as suas linhas são os vectores fornecidos*/
		static PdVector[] produtoM(PdVector[] m,PdVector[] n){
			PdVector[] produto	= new PdVector[3];
			PdVector[] nT	= transpose(n);//Transposta da matriz n.
			for(int i=0;i<3;i++){
				double x	= produtoEscalar(m[i],nT[0]);
				double y	= produtoEscalar(m[i],nT[1]);
				double z	= produtoEscalar(m[i],nT[2]);
				produto[i]	= new PdVector(x,y,z);
			}
			return produto;
		}
		




		/**ProdutoVectorial entre os vectores u e v.*/
		static PdVector cross(PdVector v,PdVector u){
			/*double u1	= u.m_data[0];
			double u2	= u.m_data[1];
			double u3	= u.m_data[2];
			double v1	= v.m_data[0];
			double v2	= v.m_data[1];
			double v3	= v.m_data[2];
			double x	= u2*v3-v2*u3;
			double y	= u3*v1-v3*u1;
			double z	= u1*v2-v1*u2;
			PdVector prodExt	= new PdVector(x,y,z);*/
			PdVector prodExt;
			prodExt=PdVector.crossNew(v,u);
			return prodExt;
		}
		


		
		
		/**Rotacao um vector u, de um ângulo ang, em torno da recta que passa pela origem e tem como direcção o vector w*/
			/*roda "P" do ângulo "t" sobre recta que passa em "A" e tem a direcção de "eixo":
			ref[w_] :=Module[{vv, uu, ww}, ww = uni[w];
				uu = If[Abs[w.{1., 0., 0.}] < Abs[w.{0., 1., 0.}], {1., 0., 0.}, {0., 1.,0.}]; 
				Transpose[{vv = uni[Cross[ww, uu]], Cross[ww, vv], ww}]];
			rot[w_, t_] := 
				ref[w].{{Cos[t], Sin[t], 0.}, {-Sin[t], Cos[t], 0.}, {0., 0.,1.}}.Transpose[ref[w]];
			rotP[P_, A_, eixo_, ang_] :=(rot[eixo, ang] . (P - A)) + A;*/
		static PdVector rotacaoVect(PdVector u,PdVector w,double ang){
			PdVector ww	= uni(w);
			PdVector e1	= new PdVector(1.,0.,0.);//Um dos vectores da base canónica
			PdVector e2	= new PdVector(0.,1.,0.);//Um dos vectores da base canónica
			PdVector uu;
			if(Math.abs(produtoEscalar(w,e1))<Math.abs(produtoEscalar(w,e2))){
				uu	= e1;
			}else {
				uu	= e2;
			}
			PdVector vv	= uni(cross(ww,uu));
			PdVector[] ref		= new PdVector[3];
			PdVector[] refInter	= new PdVector[3];
			refInter[0]	= vv;
			refInter[1]	= cross(ww,vv);
			refInter[2]	= ww; 
			ref			= transpose(refInter);
			PdVector[] a	= new PdVector[3];
			for(int i=0;i<6;i++){
				a[0]	= new PdVector(Math.cos(ang),Math.sin(ang),0);
				a[1]	= new PdVector(-Math.sin(ang),Math.cos(ang),0);
				
			}
				
			a[2]	= new PdVector(0.,0.,1.);
			PdVector[] rot	= produtoM(produtoM(ref,a),transpose(ref));
				
			PdVector rotP	= somaVect(produtoMaVect(rot,difVect(u,new PdVector(0,0,0))),new PdVector(0,0,0));
			return	rotP;	
		}
		
		/**Método para verificar se um ponto pertence à esfera de centro C e raio r.*/
		static boolean ptoEsf(double x,double y,double z,PdVector C,double r){
			boolean pertence;
			double rel	= Math.pow(x-C.m_data[0],2)+Math.pow(y-C.m_data[1],2)+Math.pow(z-C.m_data[2],2);//Relação entre o pto e a esfera.
			if(rel<=r*r){
				pertence	= true;
			}else {
				pertence	= false;
			}
			return pertence;
		}
		
		/**Método para verificar se um ponto pertence à esfera de centro C e raio r.*/
		static boolean ptoEsfP(PdVector P,PdVector C,double r){
			boolean pertence;
			double rel	= Math.pow(P.m_data[0]-C.m_data[0],2)+Math.pow(P.m_data[1]-C.m_data[1],2)+Math.pow(P.m_data[2]-C.m_data[2],2);//Relação entre o pto e a esfera.
			if(rel<=r*r){
				pertence	= true;
			}else {
				pertence	= false;
			}
			return pertence;
		}
		
		/**Verificar se um ponto P pertence a uma face.*/
		static boolean ptoFace(PdVector P,PdVector[] face){
			boolean pertence	= true;
			return pertence;
		}
		
		/**Função que indica a posição de um ponto (x,y,z) relativamente ao plano ax+by+cz+d=0.*/
		static double f(PdVector N,PdVector P,double x,double y,double z){
			double d	= -PdVector.dot(N,P);//=-produtoEscalar(N,P);
			double k	= N.m_data[0]*x+N.m_data[1]*y+N.m_data[2]*z+d;
			return k;
		}
		
		/**Função que indica a posição de um ponto (x,y,z) relativamente ao plano ax+by+cz+d=0.*/
		static double fD(PdVector N,double d,double x,double y,double z){
			double k	= N.m_data[0]*x+N.m_data[1]*y+N.m_data[2]*z+d;
			return k;
		}
		
		/**Função que indica a posição de um ponto P relativamente ao plano ax+by+cz+d=0.*/
		static double fP(PdVector N,PdVector P,PdVector ponto){
			double d	= -PdVector.dot(N,P);//=-produtoEscalar(N,ponto);
			double k	= (N.m_data[0])*(ponto.m_data[0])+(N.m_data[1])*(ponto.m_data[1])+(N.m_data[2])*(ponto.m_data[2])+d;
			return k;
		}
		
		
		/**Calcular a característica de Euler, dado o nº de vértices, o nº de arestas e o nº de faces.*/
		static double caractEuler(int nV,int nA,int nF){
			double cEuler	= nV-nA+nF;
			return cEuler;
		}
		
		/**Norma de um vector*/
		static double nor(PdVector v){
			double norma	= Math.sqrt(Math.pow(v.m_data[0],2)+Math.pow(v.m_data[1],2)+Math.pow(v.m_data[2],2));
			return norma;	
		}
	
		/**Vector unitário*/
		static PdVector uni(PdVector v){
			PdVector vectorUnitario	= new PdVector(v.m_data[0]/nor(v),v.m_data[1]/nor(v),v.m_data[2]/nor(v));
			return vectorUnitario;	
		}
		
		/**Dá a imagem de um nº x, pela função que transforma um intervalo fechado em outro, em que a é enviado em c, e b é enciado em d.*/
		static double fIntervalo(double x,double a,double b,double c,double d){
			double y;
			if(b-a!=0){
				y = ((d-c)/(b-a))*x+(c*b-a*d)/(b-a);
			}else {
				y=0;
			}
			return y;
		}
		
		
	/*.......................................................*/
	
	
	/*Botões*/
		/**Características básicas de um botão do tipo JButton*/
		static JButton jButton(String legenda,Font tipoLetra,Color corBack,Color corFore,String funcao){
			JButton botao = new JButton (legenda);
			botao.setFont(tipoLetra);
			botao.setToolTipText(funcao);
			botao.setBackground(corBack);
			botao.setForeground(corFore);
			botao.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			botao.setContentAreaFilled(true);
			return botao;
		}
		
		/**Características básicas de um botão do tipo JToggleButton*/
		static JToggleButton jTButton(String legenda,Font tipoLetra,Color corBack,Color corFore,String funcao){
			JToggleButton botao = new JToggleButton (legenda);
			botao.setFont(tipoLetra);
			botao.setToolTipText(funcao);
			botao.setForeground(corFore);
			botao.setBackground(corBack);
			botao.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			botao.isSelected();
			botao.setContentAreaFilled(true);
			return botao;
		}
		
		/**Características básicas de uma Checkbox*/
		static Checkbox checkB(String legenda,Font tipoLetra,Color corBack,Color corFore,boolean estado){
			Checkbox check	=  new Checkbox (legenda);
			check.setBackground(corBack);
			check.setForeground(corFore);
			check.setFont(tipoLetra);
			check.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			check.setState(estado);
			return check;
		}
		
		/**Características básicas de uma Checkbox*/
		static JCheckBox jCheckB(String legenda,String funcao,Font tipoLetra,Color corBack,Color corFore,boolean estado){
			JCheckBox check	=  new JCheckBox (legenda);
			check.setBackground(corBack);
			check.setForeground(corFore);
			check.setToolTipText(funcao);
			check.setFont(tipoLetra);
			check.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			check.setSelected(estado);
			return check;
		}
		
		static JFormattedTextField textFieldInt(int valor,String funcao){
			JFormattedTextField tf	= new JFormattedTextField();
			tf.setValue(new Integer(valor));
			tf.setToolTipText(funcao);
			tf.setColumns(2);
			
			return tf;
		}
		
		static PsPanel painelTextField(JFormattedTextField tf,String tfLegenda,String funcao,Font tipoLetra){
			PsPanel pTF	= new PsPanel();
			pTF.setLayout(new GridLayout(1,2));
			
			JLabel legenda	= new JLabel(tfLegenda);
			legenda.setFont(tipoLetra);
			legenda.setToolTipText(funcao);
			pTF.add(legenda);
			pTF.add(tf);
		
			return pTF;
		}
		
		static JSlider slider(String funcao,int min,int max,int inicio,int minTick,int maxTick,int minStr,int maxStr,Color corBack,Color corFore,Font tipoLetra){
			JSlider slider	= new JSlider(JSlider.HORIZONTAL,min,max,inicio);
			slider.setMajorTickSpacing(maxTick);
			slider.setMinorTickSpacing(minTick);
			slider.setBackground(corBack);
			slider.setForeground(corFore);
			slider.setFont(tipoLetra);
			slider.setPaintTicks(true);
			slider.setPaintLabels(true);
			slider.setToolTipText(funcao);
			slider.getRootPane();
			slider.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			//slider.setBorder(BorderFactory.createEmptyBorder(0,0,10,0));
	  
			Hashtable labelTable = new Hashtable();
			labelTable.put(new Integer( 0 ),  new JLabel((new Integer(minStr)).toString()) );
			labelTable.put(new Integer(max), new JLabel((new Integer(maxStr)).toString()) );
			slider.setLabelTable(labelTable);
	  
			return slider;
		}
		
		static JSlider sliderStr(String funcao,int min,int max,int inicio,int minTick,int maxTick,String minStr,String maxStr,Color corBack,Color corFore,Font tipoLetra){
			JSlider slider	= new JSlider(JSlider.HORIZONTAL,min,max,inicio);
			slider.setMajorTickSpacing(maxTick);
			slider.setMinorTickSpacing(minTick);
			slider.setBackground(corBack);
			slider.setForeground(corFore);
			slider.setFont(tipoLetra);
			slider.setPaintTicks(true);
			slider.setPaintLabels(true);
			slider.setToolTipText(funcao);
			slider.getRootPane();
			slider.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			//slider.setBorder(BorderFactory.createEmptyBorder(0,0,10,0));
	  
			Hashtable labelTable = new Hashtable();
			labelTable.put(new Integer( 0 ),  new JLabel(minStr));
			labelTable.put(new Integer(max), new JLabel(maxStr));
			slider.setLabelTable(labelTable);
	  
			return slider;
		}
		
		static PsPanel painelSlider(JSlider slider,String sliderLegenda,String funcao,Font tipoLetra){
			PsPanel pTF	= new PsPanel();
			//pTF.setLayout(new GridLayout(2,1));
			pTF.setLayout(new BorderLayout());
			
			JLabel legenda	= new JLabel(sliderLegenda,JLabel.CENTER);
			legenda.setAlignmentX(Component.CENTER_ALIGNMENT);
			legenda.setFont(tipoLetra);
			legenda.setToolTipText(funcao);
			PsPanel leg	= new PsPanel();leg.setLayout(new GridLayout(2,1));
			leg.add(legenda);
			pTF.add(leg,BorderLayout.WEST);
			pTF.add(slider,BorderLayout.CENTER);
			
			return pTF;
		}
		
		static PsPanel painelSliderP(PsPanel painel,JSlider slider,String sliderLegenda,String funcao,Font tipoLetra){
			JLabel legenda	= new JLabel(sliderLegenda,JLabel.CENTER);
			legenda.setAlignmentX(Component.CENTER_ALIGNMENT);
			legenda.setFont(tipoLetra);
			legenda.setToolTipText(funcao);
			
			PsPanel pTF	= new PsPanel();
			pTF.setLayout(new GridLayout(2,1));
			pTF.add(painel);
			pTF.add(slider);
			
			return pTF;
		}
		
		static JRadioButton radioB(String nome,String funcao,Font tipoLetra,Color corBack,Color corFore,boolean estado){
			JRadioButton rB	= new JRadioButton(nome);
			rB.setFont(tipoLetra);
			rB.setToolTipText(funcao);
			rB.setBackground(corBack);
			rB.setForeground(corFore);
			rB.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			rB.setSelected(estado);
			
			return rB;
		}
		
		static JLabel label(String nome,Font tipoLetra,Color corBack,Color corFore){
			JLabel rB	= new JLabel(nome);
			rB.setFont(tipoLetra);
			rB.setBackground(corBack);
			rB.setForeground(corFore);
			rB.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
			
			return rB;
		}
		
		static JComboBox comboBox(String[] nomesPossibilidades,int itemSel,String funcao,Font tipoLetra,Color corBack,Color corFore){
			//Create the combo box, select item at index itemSel.
			//Indices start at 0.
			JComboBox combo = new JComboBox(nomesPossibilidades);
			combo.setSelectedIndex(itemSel);
			combo.setToolTipText(funcao);
			combo.setFont(tipoLetra);
			combo.setBackground(corBack);
			combo.setForeground(corFore);
			combo.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
		
		return	combo;
		}
	/*...........................................................*/
	
	
}