grid_segmentation.cpp

这是一个GPS相关的程序

					if( SegmentA >0 )	// <0=Border, 0=noch undefined, >0=iSegment
					{
						if( SegmentB == 0 )
						{
							SegmentB	= SegmentA;
						}
						else if( SegmentB != SegmentA )
						{
							iConnect	= Segments[SegmentA-1]->Get_Segment(SegmentB);

							if( iConnect==0 )
							{
								aVal	= Segments[SegmentA-1]->Get_Value();
								bVal	= Segments[SegmentB-1]->Get_Value();

								if( fabs(aVal - bVal) < Threshold)
								{
									if( aVal < bVal )
									{
										Segment_Change(SegmentA,SegmentB);
									}
									else
									{
										Segment_Change(SegmentB,SegmentA);
										SegmentB	= SegmentA;
									}
								}
								else
								{
									iConnect	= nConnects--;
									Segments[SegmentA-1]->Set_Segment(SegmentA,iConnect);
									Segments[SegmentB-1]->Set_Segment(SegmentB,iConnect);
								}
							}

							break;
						}
					}
				}

				pSegments->Set_Value(x,y, iConnect ? iConnect : SegmentB);
			}
		}

		Get_Junctions();
	}
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
bool CGrid_Segmentation::Get_Initials(void)
{
	bool	bSegment;
	int		x, y, ix, iy, i;
	long	n;
	double	d;

	nSegments	= 0;
	Segments	= NULL;

	//-----------------------------------------------------
	for(n=0; n<Get_NCells() && Set_Progress_NCells(n); n++)
	{
		pGrid->Get_Sorted(n,x,y);

		if( Get_System()->is_InGrid(x,y,1) )
		{
			d			= pGrid->asDouble(x,y);
			bSegment	= true;

			for(i=0; i<8; i++)
			{
				ix	= Get_System()->Get_xTo(i,x);
				iy	= Get_System()->Get_yTo(i,y);

				if( Get_System()->is_InGrid(ix,iy,1) )
				{
					if( d < pGrid->asDouble(ix,iy) )
						bSegment	= false;
				}
			}

			//---------------------------------------------
			if( bSegment )
			{
				nSegments++;
				pSegments->Set_Value(x,y, nSegments);
				Segments				= (CSegment **)SG_Realloc(Segments,nSegments * sizeof(CSegment *));
				Segments[nSegments-1]	= (CSegment  *)new CSegment(nSegments,d,x,y);
			}
		}
	}

	return( nSegments > 1 );
}

//---------------------------------------------------------
void CGrid_Segmentation::Get_Junctions(void)
{
	int		x, y, ix, iy, i,
			p, p1, p2;

	//-----------------------------------------------------
	for(y=0; y<Get_NY() && Set_Progress(y); y++)
	{
		for(x=0; x<Get_NX(); x++)
		{
			if( pSegments->asInt(x,y) < 0 )
			{
				p1	= p2	= 0;

				for(i=0; i<8; i++)
				{
					ix	= Get_System()->Get_xTo(i,x);
					iy	= Get_System()->Get_yTo(i,y);

					p	= !Get_System()->is_InGrid(ix,iy) ? 1 : pSegments->asInt(ix,iy);

					if( p > 0 )
					{
						if(!p1)
						{
							p1	= p;
						}
						else if(p1!=p)
						{
							if(!p2)
							{
								p2	= p;
							}
							else if(p2!=p)
							{
								pSegments->Set_Value(x,y,-1);
								break;
							}
						}
					}
				}
			}
		}
	}
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
void CGrid_Segmentation::Segment_Change(int iFrom, int iTo)
{
	bool	bContinue;
	int		ax, ay, bx, by, x, y;

	//-----------------------------------------------------
	ax	= bx	= Segments[iFrom-1]->Get_xSeed();
	ay	= by	= Segments[iFrom-1]->Get_ySeed();

	do
	{
		bContinue	= false;

		for(x=ax; x<=bx; x++)
		{
			if(Segment_Change(x,ay,iFrom,iTo))
				bContinue		= true;

			if(Segment_Change(x,by,iFrom,iTo))
				bContinue		= true;
		}

		for(y=ay; y<=by; y++)
		{
			if(Segment_Change(ax,y,iFrom,iTo))
				bContinue		= true;

			if(Segment_Change(bx,y,iFrom,iTo))
				bContinue		= true;
		}

		if(ax>0)
			ax--;
		if(ay>0)
			ay--;
		if(bx<Get_NX()-1)
			bx++;
		if(by<Get_NY()-1)
			by++;
	}
	while( bContinue );
}

//---------------------------------------------------------
inline bool CGrid_Segmentation::Segment_Change(int x, int y, int iFrom, int iTo)
{
	if( pSegments->asInt(x,y) == iFrom )
	{
		pSegments->Set_Value(x,y,iTo);
		return( true );
	}

	return( false );
}


///////////////////////////////////////////////////////////
//														 //
//														 //
//														 //
///////////////////////////////////////////////////////////

//---------------------------------------------------------
void CGrid_Segmentation::UnPrepareNoBorders(void)
{
	bool	bRepeat, bRoger;
	int		x, y, i, ix, iy, nRepeats;

	nRepeats	= 0;

	do
	{
		bRepeat	= false;

		for(y=0; y<Get_NY(); y++)
		{
			for(x=0; x<Get_NX(); x++)
			{
				if( pSegments->asInt(x,y) < 0 )
				{
					bRoger	= false;

					for(i=0; i<8; i++)
					{
						ix	= Get_System()->Get_xTo(i,x);
						iy	= Get_System()->Get_yTo(i,y);

						if(Get_System()->is_InGrid(ix,iy))
						{
							if( pSegments->asInt(ix,iy) > 0 )
							{
								pSegments->Set_Value(x,y,pSegments->asInt(ix,iy));
								bRoger	= true;
								break;
							}
						}
					}

					if(!bRoger)
						bRepeat	= true;
				}
			}
		}
	}
	while( bRepeat && nRepeats++ < 10 );
}

//---------------------------------------------------------
void CGrid_Segmentation::UnPrepareBorders(void)
{
	bool	bKill;
	int		x, y, i, ix, iy, z;

	for(y=0; y<Get_NY(); y++)
	{
		for(x=0; x<Get_NX(); x++)
		{
			if( pSegments->asInt(x,y) < 0 )
			{
				z		= -1;
				bKill	= true;

				for(i=0; i<8; i++)
				{
					ix	= Get_System()->Get_xTo(i,x);
					iy	= Get_System()->Get_yTo(i,y);

					if( Get_System()->is_InGrid(ix,iy) )
					{
						if( pSegments->asInt(ix,iy) > 0 )
						{
							if( z < 0 )
							{
								z	= pSegments->asInt(ix,iy);
							}
							else if( z != pSegments->asInt(ix,iy) )
							{
								bKill	= false;
								break;
							}
						}
					}
				}

				pSegments->Set_Value(x,y, z > 0 && bKill ? z : -1);
			}
		}
	}
}