ww.cpp

这是一个用 vc++编写的史密斯圆图软件

#include "stdafx.h"
#include "ww.h"
#include "math.h"


CPoint dsmith::Bigger(CPoint cxy,CPoint xy,double cw,double ch){
	CPoint temp;
	temp.x=(long)((xy.x-cxy.x)*m_a+cw/2);
	temp.y=(long)((xy.y-cxy.y)*m_a+ch/2);
	return temp;
}

double dsmith::GetR(CPoint cxy){
	double H,R;
	H=(cxy.y-m_dy)*(cxy.y-m_dy)/((m_dx+m_r-cxy.x)*m_r)+(m_dx-cxy.x)/m_r;
    R=(1-H)/(1+H);
	return R;
}

double dsmith::GetX(CPoint cxy){
	double X;
	X=2*m_r/((cxy.x-(m_dx+m_r))*(cxy.x-(m_dx+m_r))/(m_dy-cxy.y)-cxy.y+m_dy);
	return X;
}

circle dsmith::GetRCircle(double R){
	circle c;
	c.xy.x=long(m_dx+R/(1+R)*m_r);
	c.xy.y=long(m_dy);
	c.radio=m_r/(1+R);
	return c;
}

circle dsmith::GetXCircle(double X){
	circle c;
	c.xy.x=long(m_dx+m_r);
	c.xy.y=long(m_dy-m_r/X);
	c.radio=m_r/X;
	return c;
}

double dsmith::GetDistance(CPoint cxy){
	double dis;
	dis=sqrt((cxy.x-m_dx)*(cxy.x-m_dx)+(cxy.y-m_dy)*(cxy.y-m_dy));
	return dis;
}

CRect dsmith::DrawRCircle(CDC* pdc,double R){
	circle cir;
	CRect rect;
	cir=GetRCircle(R);
	rect.right=long(cir.xy.x+cir.radio);
	rect.left=long(cir.xy.x-cir.radio);
	rect.bottom=long(cir.xy.y+cir.radio);
	rect.top=long(cir.xy.y-cir.radio);
	return rect;
}

CRect dsmith::DrawXCircle(CDC* pdc,double X){
	circle cir;
	CRect rect;
	cir=GetXCircle(X);
	rect.right=long(cir.xy.x+cir.radio);
	rect.left=long(cir.xy.x-cir.radio);
	rect.bottom=long(cir.xy.y+cir.radio);
	rect.top=long(cir.xy.y-cir.radio);
    return rect;
}

CPoint dsmith::GetXCircleEnd(double X){
	CPoint cp(long(m_dx+m_r*(X*X-1)/(X*X+1)),long(m_dy-m_r*2*X/(X*X+1)));
	return cp;
}
	

bool dsmith::DrawBackGround(CDC* pDC,CRect rect)
{
//	CClient* pDC(this);
	CPen penR(PS_DOT,1,RGB(255,0,0));
	CPen penX(PS_DOT,1,RGB(0,255,0));
	pDC->SelectObject(&penR);
    
	CRect r;
//	if (m_dx>m_dy) {r.left=long(m_dx-m_r);r.top=0;r.right=long(m_dx+m_r);}
//	else {r.top=long(m_dy-m_r);r.bottom=long(m_dy+m_r);}
	CPoint cpr(long(m_dx+m_r),(long) m_dy);
	CPoint cpl(long(m_dx-m_r),(long) m_dy);
	pDC->Arc(rect,cpr,cpr);
	//if(m_R) {
		pDC->Arc(DrawRCircle(pDC,1),cpr,cpr);
		pDC->Arc(DrawRCircle(pDC,0.35),cpr,cpr);
		pDC->Arc(DrawRCircle(pDC,2.5),cpr,cpr);
        pDC->SelectObject(&penX);
	    pDC->Arc(DrawXCircle(pDC,1),GetXCircleEnd(1),cpr);
     	pDC->Arc(DrawXCircle(pDC,-1),cpr,GetXCircleEnd(-1));
	    pDC->Arc(DrawXCircle(pDC,0.5),GetXCircleEnd(0.5),cpr);
     	pDC->Arc(DrawXCircle(pDC,-0.5),cpr,GetXCircleEnd(-0.5));
	    pDC->Arc(DrawXCircle(pDC,0.5),GetXCircleEnd(5),cpr);
     	pDC->Arc(DrawXCircle(pDC,-0.5),cpr,GetXCircleEnd(-5));
        pDC->MoveTo(cpl);
		pDC->LineTo(cpr);//}
    return true;
}

bool dsmith::DrawRXCircle(CDC* pdc,CPoint point,CRect rect)
{
	CPoint cp(0,0);
	CPoint cpl(long(m_dx-m_r),(long) m_dy);
	CPoint cpr(long(m_dx+m_r),(long)m_dy);

	if(m_r>GetDistance(point) ){
		    	
		if((point!=cp && m_mouse && !m_onrbuttondown && !m_onlbuttondown)){
		    CPen pen(PS_SOLID,1,RGB(255,255,255));
		    pdc->SelectObject(pen);
			if(m_R){
			    pdc->Arc(DrawRCircle(pdc,m_re),cpr,cpr);
			}
			if(m_X){
			    if(m_x>0) pdc->Arc(DrawXCircle(pdc,m_x),GetXCircleEnd(m_x),cpr);
			    else if(m_x<0) pdc->Arc(DrawXCircle(pdc,m_x),cpr,GetXCircleEnd(m_x));
				else {pdc->MoveTo(cpl);pdc->LineTo(cpr);}
			}
			if(m_F){
			    pdc->Arc(DrawFCircle(pdc,m_f*m_r),m_point,m_point);
			}
			if(m_Q){
				if(m_point.y<m_dy) pdc->Arc(DrawQCircle(pdc,m_ql,m_point),cpr,cpl);
				else if(m_point.y>m_dy) pdc->Arc(DrawQCircle(pdc,m_ql,m_point),cpl,cpr);
				else {
					pdc->MoveTo(cpl);
					pdc->LineTo(cpr);
				}
			}
		}

		if(m_onrbuttondown && points_first!=NULL){
		    CPen pen(PS_SOLID,1,RGB(255,255,255));
		    pdc->SelectObject(pen);
			if(points_last->m_R){
			    pdc->Arc(DrawRCircle(pdc,GetR(points_last->point)),cpr,cpr);
			}
			if(points_last->m_X){
			    if(GetX(points_last->point)>0) pdc->Arc(DrawXCircle(pdc,GetX(points_last->point)),GetXCircleEnd(GetX(points_last->point)),cpr);
			    else if(GetX(points_last->point)<0) pdc->Arc(DrawXCircle(pdc,GetX(points_last->point)),cpr,GetXCircleEnd(GetX(points_last->point)));
				else {pdc->MoveTo(cpl);pdc->LineTo(cpr);}
			}
			if(points_last->m_F){
			    pdc->Arc(DrawFCircle(pdc,GetF(points_last->point)*m_r),point,point);
			}
			if(points_last->m_Q){
				if(points_last->point.y<m_dy) pdc->Arc(DrawQCircle(pdc,GetQ(points_last->point),points_last->point),cpr,cpl);
				else if(points_last->point.y>m_dy) pdc->Arc(DrawQCircle(pdc,GetQ(points_last->point),points_last->point),cpl,cpr);
				else {
					pdc->MoveTo(cpl);
					pdc->LineTo(cpr);
				}
			}
			if(points_first!=NULL && points_last!=NULL && points_first==points_last) {
				free(points_last);
				points_first=points_last=NULL;
			}
			else if(points_first!=NULL && points_last!=NULL) {
				points_last=points_last->prior;
				free(points_last->next);
				points_last->next=NULL;
			}
		}

		if(m_onlbuttondown){
	    	if(points_first==NULL) {
		    	points_first=points_last=(smithpoint *) new smithpoint;
		    	points_first->next=points_last->next=NULL;
				points_first->prior=NULL;
			}
	    	else {
		    	points_last->next=(smithpoint *) new smithpoint;
		    	points_last->next->prior=points_last;
		    	points_last=points_last->next;
		     	points_last->next=NULL;
			}
		    points_last->m_F=m_F;
		    points_last->m_Q=m_Q;
		    points_last->m_R=m_R;
		    points_last->m_X=m_X;
		    points_last->point=point;
		}

		if(!m_onlbuttondown && !m_onrbuttondown) m_point=point;
		m_re=GetR(point);
		m_x=GetX(point);
		m_f=GetF(point);
		m_ql=GetQ(point);

        DrawBackGround(pdc,rect);
		if((m_mouse || m_onlbuttondown )&& !m_onrbuttondown){
	    	if(m_R){
        	    CPen penRC(PS_SOLID,1,RGB(0,0,255));
	    	    pdc->SelectObject(penRC);
                pdc->Arc(DrawRCircle(pdc,m_re),cpr,cpr);
			}	
			if(m_X){
        	    CPen penXC(PS_SOLID,1,RGB(0,192,255));
			    pdc->SelectObject(penXC);
				if(m_x>0) pdc->Arc(DrawXCircle(pdc,m_x),GetXCircleEnd(m_x),cpr);
			    else if(m_x<0) pdc->Arc(DrawXCircle(pdc,m_x),cpr,GetXCircleEnd(m_x));
				else {pdc->MoveTo(cpl);pdc->LineTo(cpr);}
			}
		    if(m_F){
			    m_swr=(1+m_f)/(1-m_f);
                CPen penF(PS_SOLID,1,RGB(0,255,192));
			    pdc->SelectObject(penF);
			    pdc->Arc(DrawFCircle(pdc,m_f*m_r),point,point);
			}
		    if(m_Q){
			    CPen penQ(PS_SOLID,1,RGB(0,192,192));
			    pdc->SelectObject(penQ);
			    if(point.y<m_dy) pdc->Arc(DrawQCircle(pdc,m_ql,point),cpr,cpl);
			    else if (point.y>m_dy) pdc->Arc(DrawQCircle(pdc,m_ql,point),cpl,cpr);
				else {
					pdc->MoveTo(cpr);
					pdc->LineTo(cpl);
				}
			}
		}
		else {
		}
	}
	return true;

}

double dsmith::GetF(CPoint point)
{
	m_fr=(point.x-m_dx)/m_r;
	m_fi=(m_dy-point.y)/m_r;
	return (sqrt(m_fr*m_fr+m_fi*m_fi));
}

CRect dsmith::DrawFCircle(CDC *pdc, double F)
{
	CRect rect;
	rect.left=long(m_dx-F);
	rect.top=long(m_dy-F);
	rect.right=long(m_dx+F);
	rect.bottom=long(m_dy+F);
	return rect;
}

double dsmith::GetQ(CPoint point)
{
	double fi,fr;
	fi=(m_dy-point.y)/m_r;
	fr=(point.x-m_dx)/m_r;
    return (sqrt(fi*fi)/(1-fi*fi-fr*fr));
}

CRect dsmith::DrawQCircle(CDC *pdc, double Q,CPoint point)
{
	CRect rect;
	double r=sqrt((1+1/(4*Q*Q))*m_r*m_r);
	double x,y;
	x=m_dx;
	if(point.y>=m_dy) y=m_dy-m_r/(2*Q);
	else y=m_dy+m_r/(2*Q);
	rect.left=long(x-r);
	rect.top=long(y-r);
	rect.right=long(x+r);
    rect.bottom=long(y+r);
	return rect;
}

CComplex CComplex::operator +(CComplex a){
	CComplex b(re+a.re,im+a.im);
	return b;
}

CComplex CComplex::operator +(double a)
{
	CComplex b(re+a,im);
	return b;
}

CComplex CComplex::operator -(CComplex a){
	CComplex b(re-a.re,im-a.im);
	return b;
}

CComplex CComplex::operator *(CComplex a){
	CComplex b(re*a.re-im*a.im,re*a.im+im*a.re);
	return b;
}

CComplex CComplex::operator *(double a)
{
	CComplex b(re*a,im*a);
    return b;
}

CComplex CComplex::operator /(CComplex a){
	CComplex b((re*a.re+im*a.im)/(a.re*a.re+a.im*a.im),(im*a.re-re*a.im)/

(a.re*a.re+a.im*a.im));
	return b;
}

void CComplex::operator =(CComplex a){
	re=a.re;
	im=a.im;
}

void CComplex::operator =(double a){
	re=a;
}

double CComplex::Abs(){
	return sqrt(re*re+im*im);
}


double CShowTrans::SetTl(){
	Tl=(Zl-Zc)/(Zl+Zc);
	return Tl.Abs();
}

double CShowTrans::SetTs(){
	Ts=(Zg-Zc)/(Zg+Zc);
	return Ts.Abs();
}

double CShowTrans::GetY(double time,double x){
	if(sinwave) return GetYSin(time,x);
	else if(dcwave) return GetYDc(time,x);
	else return 0;
}

double CShowTrans::GetYSin(double time,double x){
	int i;
	double y=0;
	for(i=0;omga*time>i*beta*l;i++){
		if(i%2==0){
			if(omga*time-i*beta*l>beta*x) 
				y+=pow(Ts.ab, double (i/2))*pow(Tl.ab,double(i/2))*sin

(omga*time-beta*x-i*beta*l);
			else y=y;
		}
		else {
			if((i+1)*beta*l-omga*time<beta*x) 
				y+=pow(Ts.ab, double ((i-1)/2))*pow(Tl.ab,double

((i+1)/2))*sin(omga*time+beta*x-i*beta*l);
            else y=y;
		}
	}
	return y;
}

double CShowTrans::GetYDc(double time,double x){
	return 0;
}

CPoint dsmith::GetPoint(double r, double x)
{
	CPoint point(long(m_dx+m_r-2*(1+r)*m_r/((1+r)*(1+r)+x*x)),long(m_dy-2*x*m_r/

((1+r)*(1+r)+x*x)));
    return point;
}

bool dsmith::deleteallpoints()
{
	smithpoint * temp;
	while(points_first!=NULL && points_last!=NULL){
		temp=points_last;
		points_last=points_last->prior;
		free(temp);
	}
	return true;
}

circle dsmith::GetGCircle(double G)
{
	circle c;
	c.xy.x=long(m_dx-G/(1+G)*m_r);
	c.xy.y=long(m_dy);
	c.radio=m_r/(1+G);
	return c;
}

CRect dsmith::DrawGCircle(CDC *pdc, double G)
{
	circle cir;
	CRect rect;
	cir=GetRCircle(G);
	rect.right=long(cir.xy.x+cir.radio);
	rect.left=long(cir.xy.x-cir.radio);
	rect.bottom=long(cir.xy.y+cir.radio);
	rect.top=long(cir.xy.y-cir.radio);
	return rect;
}

circle dsmith::GetBCircle(double B)
{
	circle c;
	c.xy.x=long(m_dx+m_r);
	c.xy.y=long(m_dy+m_r/B);
	c.radio=m_r/B;
	return c;
}

CRect dsmith::DrawBCircle(CDC *pdc, double B)
{
	circle cir;
	CRect rect;
	cir=GetXCircle(B);
	rect.right=long(cir.xy.x+cir.radio);
	rect.left=long(cir.xy.x-cir.radio);
	rect.bottom=long(cir.xy.y+cir.radio);
	rect.top=long(cir.xy.y-cir.radio);
    return rect;
}