imageprocess.cpp

CT工作站具有打印报告、病历管理、图像处理专家词库等功能

				if (m_end.x > m_start.x)
					m_end.x = m_start.x + abs(m_end.y - m_start.y);
				else
					m_end.x = m_start.x - abs(m_end.y - m_start.y);
			}
			else
			{
				if (m_end.y > m_start.y)
					m_end.y = m_start.y + abs(m_end.x - m_start.x);
				else
					m_end.y = m_start.y - abs(m_end.x - m_start.x);
			}
		}

		dc->MoveTo(m_start);
		dc->LineTo(m_end.x,m_start.y);
		dc->LineTo(m_end.x,m_end.y);
		dc->LineTo(m_start.x,m_end.y);
		dc->LineTo(m_start);

		dc->SelectObject(oldpen);
		break;
	case ACTION_ARROW:
		oldpen	= dc->SelectObject(&pen);
		dc->SetROP2(R2_XORPEN);

		dc->MoveTo(m_start);
		dc->LineTo(m_end);

		dc->MoveTo(m_start);
		dc->LineTo(m_pointa);

		dc->MoveTo(m_start);
		dc->LineTo(m_pointb);

		m_end = point;

		dc->MoveTo(m_start);
		dc->LineTo(m_end);

		
		GetArrow(m_start,m_end,m_pointa,m_pointb);
		dc->MoveTo(m_start);
		dc->LineTo(m_pointa);

		dc->MoveTo(m_start);
		dc->LineTo(m_pointb);
		dc->SelectObject(oldpen);
		break;
	case ACTION_CROSS:
		oldpen	= dc->SelectObject(&pen);
		dc->SetROP2(R2_XORPEN);

		dc->MoveTo(m_end.x,m_end.y - CROSS_LENGTH);
		dc->LineTo(m_end.x,m_end.y + CROSS_LENGTH + 1);
		dc->MoveTo(m_end.x - CROSS_LENGTH,m_end.y);
		dc->LineTo(m_end.x + CROSS_LENGTH + 1,m_end.y);

		m_end	= point;

		dc->MoveTo(m_end.x,m_end.y - CROSS_LENGTH);
		dc->LineTo(m_end.x,m_end.y + CROSS_LENGTH + 1);
		dc->MoveTo(m_end.x - CROSS_LENGTH,m_end.y);
		dc->LineTo(m_end.x + CROSS_LENGTH + 1,m_end.y);
		
		dc->SelectObject(oldpen);
		break;
	case ACTION_TEXT:
		break;
	}
	DeleteObject(&pen);
	ReleaseDC(dc);

	CDialog::OnMouseMove(nFlags, point);
}

void
ImageProcess::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	DrawImg();
}

void
ImageProcess::refresh(char *newpath )
{
	INT		i;
	CHAR	xfilename[256];
	FILE*	fp	= NULL;

	for	(i = 1; i <= imgNum; i++)	mpp[i]->Close();
	if	(NULL != newpath)			path	= _T(newpath);

	imgNum	= 1;
	for	(i= 0; i < 100; i++)		mpp[i]	= new	CPic;

	while	(imgNum < 100)
	{
		sprintf(xfilename, "%s%d.jpg", path.GetBuffer(200), imgNum);
		fp	= fopen(xfilename, "rb");
		
		if	(NULL != fp)
		{
			mpp[imgNum]->loadjpgGry(xfilename);
			mpp[imgNum]->SetImageID(imgNum);
			fclose(fp);
			imgNum++;
		}
		else	break;
	}

	imgNum--;
//	DispStyle	= 1;

	if	(imgNum > 0)
	{
		cp			= mpp[1];
		curPicNum	= 1;
		TopPicNum	= 1;
	}
	else
	{
		cp			= NULL;
		curPicNum	= 0;
		TopPicNum	= 0;
	}

	mouseAction = 0;
}

void ImageProcess::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{
	int max,min;
	m_vs.GetScrollRange(&min,&max);	
	switch(nSBCode)
	{
	case SB_BOTTOM:
			 m_vs.SetScrollPos(max);
			 SetVs();
			 break;
	case SB_ENDSCROLL :
			 break;
	case SB_LINEDOWN : 
			m_vs.SetScrollPos(m_vs.GetScrollPos()+1);
			SetVs();
			 break;
	case SB_LINEUP  :
			m_vs.SetScrollPos(m_vs.GetScrollPos()-1);
			SetVs();
			 break;
	case SB_PAGEDOWN:  
			m_vs.SetScrollPos(m_vs.GetScrollPos()+2);
			SetVs();
		break;
	case SB_PAGEUP :
			m_vs.SetScrollPos(m_vs.GetScrollPos()-2);
			SetVs();
		break;
	case SB_THUMBPOSITION:
	case SB_THUMBTRACK:
			//int max,min;
			//m_vs.GetScrollRange(&min,&max);
			m_vs.SetScrollPos(nPos);
			SetVs();
		break;
	case SB_TOP :
		 m_vs.SetScrollPos(min);
		 SetVs();
		 break;
	}

	//CDialog::OnVScroll(nSBCode, nPos, pScrollBar);
}

void
ImageProcess::DrawImg()
{
	if	(imgNum < 1)	return;
	
	CRect	rf;
	CDC*	xdc;
	
	switch	(DispStyle)
	{
	case 1:
		xdc	=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[curPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	case 2:
		xdc=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[TopPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[2].GetDC();
		ff[2].GetWindowRect(&rf);
		mpp[TopPicNum+1]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	case 3:
		xdc=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[TopPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[2].GetDC();
		ff[2].GetWindowRect(&rf);
		mpp[TopPicNum+1]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	case 4:
		xdc=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[TopPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[2].GetDC();
		ff[2].GetWindowRect(&rf);
		mpp[TopPicNum+1]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[3].GetDC();
		ff[3].GetWindowRect(&rf);
		mpp[TopPicNum+2]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[4].GetDC();
		ff[4].GetWindowRect(&rf);
		mpp[TopPicNum+3]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	case 6:
		xdc=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[TopPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[2].GetDC();
		ff[2].GetWindowRect(&rf);
		mpp[TopPicNum+1]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[3].GetDC();
		ff[3].GetWindowRect(&rf);
		mpp[TopPicNum+2]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[4].GetDC();
		ff[4].GetWindowRect(&rf);
		mpp[TopPicNum+3]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[5].GetDC();
		ff[5].GetWindowRect(&rf);
		mpp[TopPicNum+4]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[6].GetDC();
		ff[6].GetWindowRect(&rf);
		mpp[TopPicNum+5]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	case 9:
		xdc=ff[1].GetDC();
		ff[1].GetWindowRect(&rf);
		mpp[TopPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[2].GetDC();
		ff[2].GetWindowRect(&rf);
		mpp[TopPicNum+1]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[3].GetDC();
		ff[3].GetWindowRect(&rf);
		mpp[TopPicNum+2]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[4].GetDC();
		ff[4].GetWindowRect(&rf);
		mpp[TopPicNum+3]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[5].GetDC();
		ff[5].GetWindowRect(&rf);
		mpp[TopPicNum+4]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[6].GetDC();
		ff[6].GetWindowRect(&rf);
		mpp[TopPicNum+5]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[7].GetDC();
		ff[7].GetWindowRect(&rf);
		mpp[TopPicNum+6]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[8].GetDC();
		ff[8].GetWindowRect(&rf);
		mpp[TopPicNum+7]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		xdc=ff[9].GetDC();
		ff[9].GetWindowRect(&rf);
		mpp[TopPicNum+8]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch);
		ReleaseDC(xdc);
		break;
	}

	if	(1 != DispStyle)
	{
		xdc		= ff[curPicNum - TopPicNum + 1].GetDC();
		mpp[curPicNum]->DrawBMP(xdc, 0, 0, rf.Width(), rf.Height(), stretch, true);
		ReleaseDC(xdc);
	}
}

void ImageProcess::SetVs()
{
	int oldcurpic = curPicNum;
	int pos=m_vs.GetScrollPos();
	switch(DispStyle)
	{
	case 1:
		curPicNum=TopPicNum=pos;
		break;
	case 2:
		TopPicNum = 2*pos-1;
		if( TopPicNum > imgNum ) TopPicNum=((imgNum-1)>0)?(imgNum-1):1;
		curPicNum = 2*pos-1;
		if( curPicNum > imgNum ) curPicNum=((imgNum-1)>0)?(imgNum-1):1;
		break;
	case 3:
		TopPicNum = 2*pos-1;
		if( TopPicNum > imgNum ) TopPicNum=((imgNum-1)>0)?(imgNum-1):1;
		curPicNum = 2*pos-1;
		if( curPicNum > imgNum ) curPicNum=((imgNum-1)>0)?(imgNum-1):1;
		break;
	case 4:
		TopPicNum = 4*pos-3;
		if( TopPicNum > imgNum ) TopPicNum=((imgNum-3)>0)?(imgNum-3):1;
		curPicNum = 4*pos-3;
		if( curPicNum > imgNum ) curPicNum=((imgNum-3)>0)?(imgNum-3):1;
		break;
	case 6:
		TopPicNum = 6*pos-5;
		if( TopPicNum > imgNum ) TopPicNum=((imgNum-5)>0)?(imgNum-5):1;
		curPicNum = 6*pos-5;
		if( curPicNum > imgNum ) curPicNum=((imgNum-5)>0)?(imgNum-5):1;
		break;
	case 9:
		TopPicNum = 9*pos-8;
		if( TopPicNum > imgNum ) TopPicNum=((imgNum-8)>0)?(imgNum-8):1;
		curPicNum = 9*pos-8;
		if( curPicNum > imgNum ) curPicNum=((imgNum-8)>0)?(imgNum-8):1;
		break;
	}
	if(oldcurpic != curPicNum)
	{
		char scurp[10];
		sprintf(scurp,"%d",curPicNum);
		GetDlgItem(IDC_CURPIC)->SetWindowText(scurp);
		DrawImg();
		CDC *xdc=ff[curPicNum-TopPicNum+1].GetDC();
		CRect rf;
		ff[1].GetWindowRect(&rf);
		mpp[curPicNum]->DrawBMP(xdc,0 ,0 ,rf.Width(),rf.Height(),stretch,true);
		ReleaseDC(xdc);
	}
}

void ImageProcess::OnChangeCurpic() 
{
	int	old	= atoi(m_curPic);
	if	(old != 0) 
	{
		mark->Save();
//		meas->SaveFile();
	}
	UpdateData();
	int n=atoi(m_curPic);
	
	mark	= &(mpp[n]->mark);
	meas	= &(mpp[n]->meas);

	int w,h,x,y;
	CRect rwx;
	ff[1].GetWindowRect(&rwx);
	w = rwx.Width(); h = rwx.Height();
	x=y=0;
	if(w>mpp[curPicNum]->m_width  && h>mpp[curPicNum]->m_height)
	{
		x+=(w-mpp[curPicNum]->m_width )/2;
		y+=(h-mpp[curPicNum]->m_height)/2;
		w=mpp[curPicNum]->m_width ;
		h=mpp[curPicNum]->m_height;
	}
	else
	{
		float t1,t2;
		t1=(float)w/(float)h;
		t2=(float)mpp[curPicNum]->m_width /(float)mpp[curPicNum]->m_height;
		if(t1>t2)
		{
			x+=(w-t2*h)/2;
			w = t2*h;
		}
		else
		{
			y+=(h-w/t2)/2;
			h = w/t2;
		}
	}
	m_width = w;
	m_height = h ;
	left =(rwx.Width() - m_width)/2;
	top = (rwx.Height() -m_height)/2;
	
	if(old != n)
	{
		((CBxtDlg*)AfxGetMainWnd())->dispconbri->SendMessage(WX_DSPCHGCURPIC,atoi(m_curPic),0);
	}

//	mm=_T(tt);
	
	// TODO: Add your control notification handler code here
	
}

bool ImageProcess::SelectNone()
{
	KillTimer(3);
	if (m_selitem && m_hilight)
	{
		OnTimer(3);
	}
	m_selitem = NULL;
	return false;
}

bool ImageProcess::ReDrawItem()
{
	return	false;
/*
	if(DispStyle!=1)return true;
	CDC *dc = GetDC();
	item *p;
	CPoint p_start,p_end;
	CPen pen,*oldpen;
	pen.CreatePen (PS_SOLID,1,RGB(255,0,0));
	dc->SetTextColor(RGB(255,0,0));
	oldpen	= dc->SelectObject(&pen);
	for (p = (mark->m_itemhead)->next; p != NULL; p = p->next)
	{
		p_start.x	= long(p->x0 * m_width+left);
		p_start.y	= long(p->y0 * m_height+top);
		p_end.x		= long(p->x1 * m_width+left);
		p_end.y		= long(p->y1 * m_height+top);
		switch (p->type)
		{
		case ACTION_ARROW:
			dc->MoveTo(p_start);
			dc->LineTo(p_end);

			GetArrow(p_start,p_end,m_pointa,m_pointb);
			dc->MoveTo(p_start);
			dc->LineTo(m_pointa);

			dc->MoveTo(p_start);
			dc->LineTo(m_pointb);
			break;
		case ACTION_CROSS:
			dc->MoveTo(p_start.x,p_start.y - CROSS_LENGTH);
			dc->LineTo(p_start.x,p_start.y + CROSS_LENGTH + 1);
			dc->MoveTo(p_start.x - CROSS_LENGTH,p_start.y);
			dc->LineTo(p_start.x + CROSS_LENGTH + 1,p_start.y);
			break;
		case ACTION_TEXT:
			dc->SetBkMode(TRANSPARENT);
			dc->TextOut(p_start.x,p_start.y,p->word);
			break;
		}
	}
	dc->SelectObject(&oldpen);
	ReleaseDC(dc);
	DeleteObject(&pen);
	
	return true;
*/
}

bool ImageProcess::GetArrow(CPoint start,CPoint end,CPoint &pa,CPoint &pb)
{
//	End -> Start

	int l2,dx,dy;
	double angle;

	dx = end.x - start.x;
	dy = end.y - start.y;
	l2 = dx * dx + dy * dy;

	angle = -atan2(dy,dx);
	if (angle < 0) angle = 2 * PI + angle;
	//m_angle = angle;

	pa.x = long(start.x + ARROW_LENGTH * cos(angle + ARROW_ANGLE));
	pa.y = long(start.y - ARROW_LENGTH * sin(angle + ARROW_ANGLE));

	pb.x = long(start.x + ARROW_LENGTH * cos(angle - ARROW_ANGLE));
	pb.y = long(start.y - ARROW_LENGTH * sin(angle - ARROW_ANGLE));

	return true;
}

void ImageProcess::OnTimer(UINT nIDEvent) 
{
	CDC *dc;

	if (4 == nIDEvent)
	{
		dc	= GetDC();
		if (m_action	!= ACTION_MEASDELETE)
		{
			KillTimer(4);
			meas->SelFlash(dc,TRUE);
			meas->SelectNone();
		}
		else
			meas->SelFlash(dc);
		ReleaseDC(dc);
	}
	else if(nIDEvent==3)
	{
		if (m_selitem == NULL) return;
		item *p = m_selitem;
		CPoint start(long(p->x0 * m_width+left),long(p->y0 * m_height)+top);
		CPoint end(long(p->x1 * m_width+left),long(p->y1 * m_height)+top);

		dc = GetDC();
		m_hilight = !m_hilight;

		dc->SetBkMode(TRANSPARENT);
		CPen pen(PS_SOLID,1,RGB(255,0,255)),*oldpen;
		if (m_hilight) 
		{
			oldpen=dc->SelectObject(&pen);
			dc->SetTextColor(RGB(0,0,255));
		}
		switch (m_selitem->type)
		{
		case ACTION_ARROW:
			dc->MoveTo(start);
			dc->LineTo(end);

			GetArrow(start,end,m_pointa,m_pointb);
			dc->MoveTo(start);
			dc->LineTo(m_pointa);

			dc->MoveTo(start);
			dc->LineTo(m_pointb);
			break;
		case ACTION_CROSS:
			dc->MoveTo(start.x,start.y - CROSS_LENGTH);
			dc->LineTo(start.x,start.y + CROSS_LENGTH + 1);
			dc->MoveTo(start.x - CROSS_LENGTH,start.y);
			dc->LineTo(start.x + CROSS_LENGTH + 1,start.y);
			break;
		case ACTION_TEXT:
			dc->TextOut(start.x,start.y,p->word);
			break;
		}
		if (m_hilight) 
			dc->SelectObject(oldpen);
		DeleteObject(&pen);
		ReleaseDC(dc);
	}
	CDialog::OnTimer(nIDEvent);
}

BOOL ImageProcess::DestroyWindow() 
{
	for(int i=1;i<imgNum;i++)
		mpp[i]->Close();
	return CDialog::DestroyWindow();
}

float ImageProcess::GetAngle()
{
	float d1,d2,d3,cosalpha,alpha;
	
	m_anglep3.x	-= (m_anglep2.x - m_anglep1.x);
	m_anglep3.y	-= (m_anglep2.y - m_anglep1.y);

	d1	= (m_anglep0.x - m_anglep1.x) * (m_anglep0.x - m_anglep1.x) +
		  (m_anglep0.y - m_anglep1.y) * (m_anglep0.y - m_anglep1.y);

	d2	= (m_anglep3.x - m_anglep1.x) * (m_anglep3.x - m_anglep1.x) +
		  (m_anglep3.y - m_anglep1.y) * (m_anglep3.y - m_anglep1.y);

	d3	= (m_anglep3.x - m_anglep0.x) * (m_anglep3.x - m_anglep0.x) +
		  (m_anglep3.y - m_anglep0.y) * (m_anglep3.y - m_anglep0.y);

	cosalpha = 0.5 * (d1 + d2 - d3) / sqrt(d1 * d2);
	alpha	= acos(cosalpha);
	return	float(180 * alpha / PI);
}

void ImageProcess::ChgGryWin(WPARAM wParm,LPARAM lParm)
{
	if (cp == NULL) return;
	if (imgNum < 1) return;
	
	cp = mpp[curPicNum];
	
	cp->ReLoad();

	if(lParm==1)
		cp->ChgGryWinW(LOWORD(wParm),HIWORD(wParm));
	else
		cp->ChgGryWin(LOWORD(wParm),HIWORD(wParm));
	
	DrawImg();
}

void ImageProcess::ChgConBri(WPARAM wParm,LPARAM lParm)
{
	if (NULL == cp) return;
	if (imgNum < 1) return;
	
	cp = mpp[curPicNum];
	
	cp->ReLoad();
	cp->ChgConBri(HIWORD(wParm)-128,LOWORD(wParm)-128);
	
	DrawImg();
}