/*
 *	Drawer
 *
 *	Canvas for showing attributes of designed antenna 
 *
 *	Meirong He
 *	EEE Department
 *	University of Sheffield
 *	July 2005
 */

import java.awt.*;
import java.awt.event.*;

public class Drawer extends Canvas {
	
	private Dimension size;
	private Graphics gs;
	private int border,xMin,yMin,xMax,yMax,xDelta,yDelta;
	private int minimumDB=-30;     //Bottom limit in dB
	
	public void paint (Graphics g) {
		size=getSize();
		border=size.width/15;
		xMin=border;yMin=border;
		xMax=size.width-border;
		yMax=size.height-border;	
		clear();
	}
	
	public void clear() {
		gs=getGraphics();
		gs.setColor(Color.pink);
		gs.fillRect(0,0,size.width-1, size.height-1);
		gs.setColor(Color.white);
		gs.fillRect(border, border, size.width-2*border, size.height-2*border);
	}
	
	public void drawArrayFactor(ArrayFactor power) {
		
		xDelta=xMax-xMin;
		yDelta=yMax-yMin;
		
		double top=0.0;
		for (int j=0; j<power.N; j++) 	top=top+Math.abs(power.I[j].modu);
		top=20.0*Math.log(top)/Math.log(10);
		
		System.out.println("top="+top+" DB");
		System.out.println("at 0 degree="+power.getAmplitude(0));
		System.out.println("at 45 degree="+power.getAmplitude(45*Math.PI/180));
		System.out.println("at 90 degree="+power.getAmplitude(90*Math.PI/180));
		System.out.println("at 180 degree="+power.getAmplitude(180*Math.PI/180));
							//Printing in command window to check correctness of ploting

		double xRange=Math.PI;
		double yRange=top-minimumDB;
		double xZero=xMin*1.0;
		double yZero=yMax+minimumDB*yDelta/yRange;
		
		gs=getGraphics();
		gs.setColor(Color.black);
		gs.drawString("Power(dB) vs. field point angle(degree)", (int)(xMin+xDelta/20.0),(int)(yMin-border/3.0));
		
		int yLevels=(int)((top-minimumDB)/5.0);
		double yStep=yDelta*5.0/yRange;
		for (int j=0; j<=yLevels; j++) {
			gs.setColor(Color.gray);
			gs.drawLine((int)xZero,(int)(yMin+j*yStep), xMax, (int)(yMin+j*yStep));
			gs.setColor(Color.black);
			gs.drawString(""+5*j, (int)(border/2.5), (int)(yMin+j*yStep+5));	
		}							//Draw y coordinates and labels
		
		double xStep=xDelta*45.0/180.0;
		for (int k=0; k<=(int)(180/45); k++) {
			gs.setColor(Color.gray);
			gs.drawLine((int)(k*xStep+xMin),yMin,(int)(k*xStep+xMin),yMax);
			gs.setColor(Color.black);
			gs.drawString(""+45*k,(int)(k*xStep+xMin-8),(int)(yMax+border/2.5));
		}							//Draw x coordinates and labels
		
		
		gs.setColor(Color.blue);
		double dy, yMaxValue=power.getAmplitude(0);
		int xStart=(int)xZero;
		int yStart=Math.min(yMax,(int)(yZero-power.getAmplitude(0)*yDelta/yRange));
		int xDueTop=0, xPt=xStart, yPt=yStart;
		
		for (int dx=0; dx<=180; dx++) {
			dy=power.getAmplitude(dx*Math.PI/180.0);
			if (dy<=minimumDB) dy=minimumDB;
			xPt=(int)(xZero+dx*xDelta/180.0);
			yPt=(int)(yZero-dy*yDelta/yRange);
			gs.drawLine(xStart,yStart,xPt,yPt);
			xStart=xPt;
			yStart=yPt;	
			
			yMaxValue=Math.max(yMaxValue, dy);
			if (yMaxValue==dy) xDueTop=dx;
								//Find out max value and its position
		}
		
		int x3dbLeft=xDueTop, x3dbRight=xDueTop;
		double v3db=top-3, vLeft=top, vRight=top;
		
		do {
			x3dbLeft=x3dbLeft-1;	
			vLeft=power.getAmplitude(x3dbLeft*Math.PI/180.0);			
		}while((vLeft-v3db)>0.000001 && x3dbLeft>=0);
		
		do{	
			x3dbRight++;
			vRight=power.getAmplitude(x3dbRight*Math.PI/180.0);	
		}while((vRight-v3db)>0.000001 && x3dbRight<=180);
		
		int beamWidth3db=x3dbRight-x3dbLeft;
		String db3="BW: "+beamWidth3db +" degree";
		gs.drawString(db3, (int)(xMin+x3dbRight*xDelta/180),(int)(yZero-v3db*yDelta/yRange));
								//Find out 3dB beam width
		
	}
	
	public void drawGeometry(ArrayFactor power) {
		
		xDelta=Math.min(xMax-xMin,yMax-yMin);
		yDelta=xDelta;
		
		double top=0.0;
		for (int j=0; j<power.N; j++) 	top=top+power.I[j].modu;
		top=20.0*Math.log(top)/Math.log(10);
		
		double xRange=2*(top-minimumDB);
		double yRange=xRange;
		double xZero=xMin+(xMax-xMin)/2;
		double yZero=yMin+(yMax-yMin)/2;
		gs=getGraphics();
		gs.setColor(Color.black);
		gs.drawString("Geometry radiation pattern vs. field point angle (degree)", xMin,(int)(yMin-border/4.0));
		gs.drawString("0", (int)(xMin+(xMax-xMin)/2.0+2), yMin+10);
		gs.drawString("90", xMax-15, (int)(yMin+(yMax-yMin)/2.0-2));
		gs.drawString("+-180", (int)(xMin+(xMax-xMin)/2.0+2), yMax-2);
		gs.drawString("-90", xMin+2, (int)(yMin+(yMax-yMin)/2.0-2));
		gs.drawLine((int)xMin,(int)yZero,xMax,(int)yZero);
		gs.drawLine((int)xZero,yMin,(int)xZero,yMax);
							//Put position information
		
		gs.setColor(Color.blue);
		
		int xStart=(int)xZero, yStart=(int)yZero, xPt=(int)xZero, yPt=(int)yZero;
		
		for (int dx=-180; dx<180+1; dx++) {
			double dy=power.getAmplitude(dx*Math.PI/180.0);
			if (dy<=minimumDB) dy=minimumDB;
			xPt=(int)(xZero+(dy-minimumDB)*Math.sin(dx*Math.PI/180.0)*xDelta/xRange);
			yPt=(int)(yZero-(dy-minimumDB)*Math.cos(dx*Math.PI/180.0)*yDelta/yRange);
			
			gs.drawLine(xStart,yStart,xPt,yPt);
			xStart=xPt;
			yStart=yPt;		
		}
							//Draw geomitrical radiation pattern
	}
	
	public void drawFeedingNet(double[][] sectl, int N, int V) {
		
		gs=getGraphics();
		
		boolean odd;
		int P=N;
		double xStart=xMin+border/2; 
		double yStart, yStop, yStartStep, yEndStep, xStep=0;
		
		gs.setColor(Color.black);
		gs.drawString("Feeding line lengths (mm)", (int)(xMin+(xMax-xMin)/5.0),(int)(yMin-border/3.0));
		
		if(N==1 || N==0) {
			gs.drawLine((int)(xMin+(xMax-xMin)/3.0), (int)(yMin+(yMax-yMin)/2.0),(int)(xMin+(xMax-xMin)*2/3.0), (int)(yMin+(yMax-yMin)/2.0));
			gs.drawString("No need of feeding net",(int)(xMin+(xMax-xMin)/3.0), (int)(yMin+(yMax-yMin)/2.0));
		}
		else xStep=(xMax-xMin-2*border/2)/V;
							//Exclude N=1 and N=0 when no feeding network needed.
		
		for (int k=0; k<V; k++) {
			
			yStartStep=(yMax-yMin)/P; 
			yEndStep=(yMax-yMin)/(int)Math.ceil(P/2.0);
			yStart=yMin+yStartStep/2;
			yStop=yMin+yEndStep/2;
		
			odd=P%2!=0;
			
			for (int i=0; i<P; i++) {
				
				if(odd) {
					if(i==2) 
						yStop=yStop+yEndStep;
					else if (i>2)
						yStop=yStop+(0.5-0.5*Math.pow(-1,i))*yEndStep;	
				}
				else {
					if(i!=0)
					yStop=yStop+(0.5+0.5*Math.pow(-1,i))*yEndStep;				
				}
				
				gs.drawLine((int)xStart, (int)yStart, (int)(xStart+xStep), (int)yStop);	
				double length=(int)(sectl[i][k]*1000000+0.5)/1000.0;
				gs.drawString(""+length, (int)(xStart+xStep/3.0), (int)(yStart+(yStop-yStart)/2.0-3));
				yStart=yStart+yStartStep;
			}	
			
			xStart=xStart+xStep;
			P=(int)Math.ceil(P/2.0);
		}
							//Draw feeding net work with line length
	}
	
	public void drawTransformer(double[][] Z1, double[][] Z2, double[][] w1, double[][] w2, int N, int V, double L, double R0, double R) {
		
		gs=getGraphics();
		
		String word;
		boolean odd;
		int P=N;
		
		gs.setColor(Color.black);
		gs.drawString("Transformer arm impedances (omh) and widths (mm)", (int)(xMin+(xMax-xMin)/5.0),(int)(yMin-border/3.0));
		
		word="R0="+R0+" omh, R="+R+" omh"; 
		gs.drawString(word, (int)(xMin+(xMax-xMin)/10), (int)(yMin+(yMax-yMin)/20));
		word="Transformer arm length="+(int)(L*10000+0.5)/10.0+" mm";
		gs.drawString(word, (int)(xMin+(xMax-xMin)/10), (int)(yMin+(yMax-yMin)/10));
							//Show relevant information 
		
		double yDown=yMin+(yMax-yMin)/10;
		double xStart=xMin+border/2; 
		double yStart, yStop, yStartStep, yEndStep, xStep=0;
	
		if(N==1 || N==0) {
			gs.drawLine((int)(xMin+(xMax-xMin)/3.0), (int)(yMin+(yMax-yDown)/2.0),(int)(xMin+(xMax-xMin)*2/3.0), (int)(yMin+(yMax-yDown)/2.0));
			gs.drawString("No need of feeding net",(int)(xMin+(xMax-xMin)/3.0), (int)(yMin+(yMax-yDown)/2.0));
		}
		else xStep=(xMax-xMin-2*border/2)/V;
		
		for (int k=0; k<V; k++) {
			
			yStartStep=(yMax-yDown)/P; 
			yEndStep=(yMax-yDown)/(int)Math.ceil(P/2.0);
			yStart=yDown+yStartStep/2;
			yStop=yDown+yEndStep/2;
		
			odd=P%2!=0;
			
			for (int i=0; i<P; i++) {
				
				if(odd) {
					if(i==0) word="Zin="+(int)(Z1[0][k]*10+0.5)/10.0+" w="+(int)(w1[0][k]*10+0.5)/10.0;
					else if(i==1) word="Zin="+(int)(Z2[0][k]*10+0.5)/10.0+" w="+(int)(w2[0][k]*10+0.5)/10.0;
					else if(i==2) {
						yStop=yStop+yEndStep;
						word="Zin=R0";
					}	
					else if (i>2) {	
						if(i%2!=0) word="Zin="+(int)(Z1[(int)Math.ceil(i/2.0)][k]*10.0+0.5)/10.0+" w="+(int)(w1[(int)Math.ceil(i/2.0)][k]*10.0+0.5)/10;
						else word="Zin="+(int)(Z2[(int)Math.ceil(i/2.0)][k]*10+0.5)/10.0+" w="+(int)(w2[(int)Math.ceil(i/2.0)][k]*10+0.5)/10.0;
						yStop=yStop+(0.5-0.5*Math.pow(-1,i))*yEndStep;	
					}
					
				}
				else {
					if(i!=0) yStop=yStop+(0.5+0.5*Math.pow(-1,i))*yEndStep;	
					if(i%2==0)	word="Zin="+(int)(Z1[(int)(i/2.0)][k]*10.0+0.5)/10.0+" w="+(int)(w1[(int)(i/2.0)][k]*10.0+0.5)/10.0;		
					else word="Zin="+(int)(Z2[(int)(i/2.0)][k]*10.0+0.5)/10.0+" w="+(int)(w2[(int)(i/2.0)][k]*10.0+0.5)/10.0;			
				}
				gs.setColor(Color.pink);
				gs.drawLine((int)xStart, (int)yStart, (int)(xStart+xStep), (int)yStop);	
				gs.setColor(Color.blue);
				gs.drawString(word, (int)(xStart+xStep/6.0), (int)(yStart+(yStop-yStart)/2.0));
				yStart=yStart+yStartStep;
			}	
			
			xStart=xStart+xStep;
			P=(int)Math.ceil(P/2.0);
		}	
							//Draw feeding network with transformer arm characteristic impedance and width
	}	
	
}