bufferview.cpp

空间分析模型代码 实现缓冲分析和重叠分析下的集中情况

				{
		              m_points_line.Add(point);
	                  l.pStart=m_points_line[m_points_line.GetSize()-2];
					  l.pEnd=m_points_line[m_points_line.GetSize()-1];
					  Line(pDC,l);
					  m_bufferpolygon.Add(l); 
				}
		 }

	}
	
	//处理叠置分析的消息

	if (m_overlap)
	{
	    
		//画点面叠置中的点
		if(m_o_pDrawPoint)
		{
			    m_overlap_ppoints.Add(point);
	            over_ppoints=m_overlap_ppoints.GetSize();
                Invalidate(true);
		}
    	
		//画点面叠置中的面
		if (m_o_pDrawPoly)
		{
            if (m_lBDown==0)
            {
				m_overlap_ppoly.RemoveAll();
				
				Invalidate(true);
				m_lBDown++;
                m_overlap_ppoly.Add(point);
            }   
			else
			{
			   m_overlap_ppoly.Add(point);
               for (int m=1;m<m_overlap_ppoly.GetSize();m++)
               {
				   Line(pDC,m_overlap_ppoly[m-1],m_overlap_ppoly[m]);
               }
			}
		}
		
		//画面面叠置中的面A
		if (drawpolyA)
		{
           if (m_lBDown==0)
            {
				m_overlap_polyA.RemoveAll();
				
				Invalidate(true);
				m_lBDown++;
                m_overlap_polyA.Add(point);
            }   
			else
			{
			   m_overlap_polyA.Add(point);
               for (int m=1;m<m_overlap_polyA.GetSize();m++)
               {
				   Line(pDC,m_overlap_polyA[m-1],m_overlap_polyA[m]);
               }
			}
		}
	    
		//画面面叠置中的面B
		if (drawpolyB)
		{
           if (m_lBDown==0)
            {
				m_overlap_polyB.RemoveAll();
				
				Invalidate(true);
				m_lBDown++;
                m_overlap_polyB.Add(point);
            }   
			else
			{
			   m_overlap_polyB.Add(point);
               for (int m=1;m<m_overlap_polyB.GetSize();m++)
               {
				   Line(pDC,m_overlap_polyB[m-1],m_overlap_polyB[m]);
               }
			}
		}
        
		//画线面面叠置中的线
        if (drawline)
        {
			LINE l;
            if (m_lBDown==0)
				{
                      m_overlap_Lpoints.Add(point);
                      m_lBDown++;
	
				}
	            else
				{
        
		              m_overlap_Lpoints.Add(point);
	                  m_lBDown++;
	
		//DrawBuffer(pDC,m_points[point_num-2],m_points[point_num-1],10);
	               	  //Line(pDC,m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-2],m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-1]);
		              l.pStart=m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-2];
					  l.pEnd=m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-1];
					  Line(pDC,l);
					  m_line.Add(l);
		
				}    
        }
		if (drawpoly)
		{
            LINE l;
			if (m_lBDown==0)
            {
				m_poly.RemoveAll();
				m_overlap_Lpoints.RemoveAll();
				Invalidate(true);
				m_lBDown++;
                m_overlap_Lpoints.Add(point);
            }   
			else
			{
			    m_overlap_Lpoints.Add(point);
               /*for (int m=1;m<m_overlap_Lpoints.GetSize();m++)
               {
				   Line(pDC,m_overlap_Lpoints[m-1],m_overlap_Lpoints[m]);
               }*/			  			   			   
			    l.pStart=m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-2];
			    l.pEnd=m_overlap_Lpoints[m_overlap_Lpoints.GetSize()-1];
			    Line(pDC,l);
			    m_poly.Add(l);
			}
		}
	}
	CScrollView::OnLButtonDown(nFlags, point);
}

void CBufferView::OnBufferPoint() 
{
	// TODO: Add your command handler code here
	RemoveAllOverlap();
	m_buffer=TRUE;
    m_overlap=FALSE;
	m_LBotton_point=TRUE;
    m_LBotton_line=FALSE;
    m_LBotton_polygon=FALSE;
	if (m_bufferline.GetSize()!=0)
		m_bufferline.RemoveAll();
	if(m_bufferpolygon.GetSize()!=0)
    	m_bufferpolygon.RemoveAll();	
    Invalidate(true);
}

void CBufferView::OnBufferLine() 
{
	// TODO: Add your command handler code here
	RemoveAllOverlap();
	m_buffer=TRUE;
    m_overlap=FALSE;
	m_LBotton_point=FALSE;
    m_LBotton_line=TRUE;
    m_LBotton_polygon=FALSE;
	if (m_points_point.GetSize()!=0)
		m_points_point.RemoveAll();
	if(m_bufferpolygon.GetSize()!=0)
    	m_bufferpolygon.RemoveAll();

    Invalidate(true);
}

void CBufferView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
   
   // Invalidate(true);
	CScrollView::OnLButtonDblClk(nFlags, point);
}
void CBufferView::DrawBuffer(CDC *pDC,CPoint pt_f,CPoint pt_b,int r)
{
    CPen pen1(PS_SOLID,1,RGB(255,125,255));
	CBrush brush(RGB(255,125,255));
	//brush=CreateSolidBrush;
	CPoint pt[4];
	int x1,x2,y1,y2;
	double d_x,d_y,x,y;
	double xielv,angle;
	x1=pt_f.x;
	x2=pt_b.x;
	y1=pt_f.y;
	y2=pt_b.y;
    x=pt_b.x-pt_f.x;
    y=pt_b.y-pt_f.y;
	xielv=y/x;
    if (pt_f.x==pt_b.x)
    {
		pt[0].x=pt_f.x-r;
		pt[0].y=pt_f.y;
		pt[1].x=pt_b.x-r;
		pt[1].y=pt_b.y;	
		pt[2].x=pt_b.x+r;
		pt[2].y=pt_b.y;
		pt[3].x=pt_f.x+r;
		pt[3].y=pt_f.y;
    }
	else
	{
		
	    if(xielv<0)
		  m_xielv=-1*xielv;
        else
		  m_xielv=xielv;
		angle=atan(m_xielv);
		d_x=r*sin(angle);
		d_y=r*cos(angle);
		if (xielv>=0)
		{
	    	pt[0].x=pt_f.x+d_x;
		    pt[0].y=pt_f.y-d_y;
    		pt[1].x=pt_b.x+d_x;
    		pt[1].y=pt_b.y-d_y;	
    		pt[2].x=pt_b.x-d_x;
    		pt[2].y=pt_b.y+d_y;
    		pt[3].x=pt_f.x-d_x;
    		pt[3].y=pt_f.y+d_y;          
		}
		else
		{
            pt[0].x=pt_f.x-d_x;
		    pt[0].y=pt_f.y-d_y;
    		pt[1].x=pt_b.x-d_x;
    		pt[1].y=pt_b.y-d_y;	
    		pt[2].x=pt_b.x+d_x;
    		pt[2].y=pt_b.y+d_y;
    		pt[3].x=pt_f.x+d_x;
    		pt[3].y=pt_f.y+d_y; 
		}
	}
	pDC->SelectObject(&brush);
	pDC->SelectObject(&pen1);
	pDC->Polygon(pt,4);
	pDC->Ellipse(x1-r,y1-r,x1+r,y1+r);
	pDC->Ellipse(x2-r,y2-r,x2+r,y2+r);
	DeleteObject(brush);
	DeleteObject(pen1);
}
void CBufferView::Line(CDC *pDC,CPoint pt_f,CPoint pt_b)
{
    pDC->MoveTo(pt_f);
	pDC->LineTo(pt_b);
}
void CBufferView::Line(CDC *pDC,LINE l)
{
    
	Line(pDC,l.pStart,l.pEnd);
	
}
void CBufferView::PointBuffer(CDC *pDC, POINT* lpPoints,int nCount,int r)
{
    CPoint pt;
	for (int i=0;i<nCount;i++)
	{
		pt=*(lpPoints+i);
		int x=pt.x;
	    int y=pt.y;
	    pDC->SelectStockObject(GRAY_BRUSH);
	    pDC->Ellipse(x-r,y-r,x+r,y+r);
	    pDC->SelectStockObject(BLACK_BRUSH);
	    pDC->Ellipse(x-2,y-2,x+2,y+2);
	}
}
bool CBufferView::LineIncert(LINE l1,LINE l2)
{
     double x1,x2,x3,x4,y1,y2,y3,y4,x5,y5;
	 double k1,k2;
	 double c1,c2;
	 x1=l1.pStart.x;
	 y1=l1.pStart.y;
	 x2=l1.pEnd.x;
	 y2=l1.pEnd.y;
	 x3=l2.pStart.x;
	 y3=l2.pStart.y;
	 x4=l2.pEnd.x;
	 y4=l2.pEnd.y;
     //两条都为竖线
	 if((x1==x2)&&(x3==x4))
		 return false;
	 else
	 {
        k1=(y2-y1)/(x2-x1);
		k2=(y4-y3)/(x4-x3);
		if(k1==k2)
			return false;
		else
		{
           c1=(y1*x2-y2*x1)/(x2-x1);
           c2=(y3*x4-y4*x3)/(x4-x3);
		   x5=(c2-c1)/(k1-k2);
		   y5=(c2*k1-c1*k2)/(k1-k2);
           if (((x5-x1)*(x5-x2)<=0)&&((x5-x3)*(x5-x4)<=0))
           {
			   m_pIncert.x=x5;
		       m_pIncert.y=y5;
		       return true;
           }
           else
			   return false;
		}
	 }
}
void CBufferView::LineRgn(CDC *pDC, LINE line,LINE *poly,int nCount) 
{
        CArray<CPoint,CPoint&> p;
		CPoint pt,pt2;
		CRgn Rgn;
        int pb,sm,pb1;
		float x1,y1,x2,y2;
		float xx1,yy1,xx2,yy2;
		LINE l;
		x1=line.pStart.x;       //起始点的X坐标
		x2=line.pEnd.x;         //终点的X坐标  用于确定线段的方向
		y1=line.pStart.y;
		y2=line.pEnd.y;
		for (int i=0;i<nCount-1;i++)
		{
			pt=(*(poly+i)).pStart;
			p.Add(pt);
			pt=(*(poly+i)).pEnd;
            p.Add(pt);
		}
        Rgn.CreatePolygonRgn(p.GetData(),p.GetSize(),ALTERNATE);
		//如果两点都在多边形内
		if ((Rgn.PtInRegion(line.pStart))&&(Rgn.PtInRegion(line.pEnd)))
		{
			pt2=line.pStart;
			m_points.Add(pt2);
			for (int j=0;j<nCount;j++)
				{
                   if (LineIncert(line,*(poly+j)))
                   {
					   m_points.Add(m_pIncert);
                   }
				}
			pt2=line.pEnd;
			m_points.Add(pt2);			
		}
        else
		{
			//return 1;
			if (Rgn.PtInRegion(line.pStart))
			{
				pt2=line.pStart;
				m_points.Add(pt2);
				for (int j=0;j<nCount;j++)
				{
                   if (LineIncert(line,*(poly+j)))
                   {
					   m_points.Add(m_pIncert);
                   }
				}
			}
			else if (Rgn.PtInRegion(line.pEnd))
			{
				pt2=line.pEnd;
                for (int j=0;j<nCount;j++)
				{
                   if (LineIncert(line,*(poly+j)))
                   {
					   m_points.Add(m_pIncert);
                   }
				}
				m_points.Add(pt2);
			}
			else
			{
                for (int j=0;j<nCount;j++)
				{
                   if (LineIncert(line,*(poly+j)))
                   {
					   m_points.Add(m_pIncert);
                   }
				}
			}
			
		}
		if (m_points.GetSize()!=0)
		{
			if ((x1-x2)==0)
			{
				for (int j=1;j<m_points.GetSize();j++)
				{
					yy1=m_points[j-1].y;
					yy2=m_points[j].y;
					if ((yy2-yy1)*(y2-y1)<0)
					{
                        pt2=m_points[j];
						m_points[j]=m_points[j-1];
                        m_points[j-1]=pt2;
					}
				}
			}
			else
			{
                for (int j=1;j<m_points.GetSize();j++)
				{
					xx1=m_points[j-1].x;
					xx2=m_points[j].x;
					if ((xx2-xx1)*(x2-x1)<0)
					{
                        pt2=m_points[j];
						m_points[j]=m_points[j-1];
                        m_points[j-1]=pt2;
					}
				}
			}
			for (int j=1;j<m_points.GetSize();j++)
			{
				pt2.x=(m_points[j].x+m_points[j-1].x)/2;
				pt2.y=(m_points[j].y+m_points[j-1].y)/2;
				if (Rgn.PtInRegion(pt2))
				{
					Line(pDC,m_points[j-1],m_points[j]);
					l.pStart=m_points[j-1];
					l.pEnd=m_points[j];
					m_line_result.Add(l);
				}
			}
		}
        
}
//画线的缓冲区

void CBufferView::LineBuffer(CDC* pDC, POINT* lpPoints,
		const DWORD* lpPolyPoints, int nCount)
{
	int start,end,j;
	CPoint pt_f,pt_b;
	start=1;
	end=0;

    for (int i=0;i<nCount;i++)
	{   
        end+=*(lpPolyPoints+i);
		j=start;
		while (j<end)
		{
            pt_f=*(lpPoints+j-1);
			pt_b=*(lpPoints+j);
            DrawBuffer(pDC,pt_f,pt_b,buffer_rad);
			j++;
		}
		start+=*(lpPolyPoints+i);
        
	}
}

//画多边形