Vector自定义排序规则 实现多边形顺时针排序

[yilin57]

我想对存储在Vector中的自定义类型元素进行排序，用了仿函数来定义排序规则，即实现对多边形的顶点进行顺时针排序，小坐标的数据可以正常排序，换大坐标的大数据量，排序失效。

之前报错：invalid < ，之后通过将涉及两浮点数比较大小的部分改为：fabs（A-B）<FLT_EPSILON后，不提示该错误！
但排序仿函数失效！
问题：
是浮点数精度引起的呢？还是本身排序规则中返回true或者false的时候不符合标准库规范？这两种考虑，都试着改了很多次，还是不知道到底什么原因。

相关代码如下：

...
std::sort(V1.m_voronoi_cell.begin(), V1.m_voronoi_cell.end(), sort_vector_op(V1.m_pt));
...

class sort_vector_op
{
public:
	sort_vector_op(c2ga::normalizedPoint center_point)
	{
		float biao_gan_x = center_point.m_c[0];
		float biao_gan_y = center_point.m_c[1]+100;
		float m_ni = 0.5*(biao_gan_x*biao_gan_x + biao_gan_y*biao_gan_y);
		p0 = c2ga::normalizedPoint(c2ga::normalizedPoint_e1_e2_ni_nof1_0,biao_gan_x, biao_gan_y, m_ni);

		float m_Origin_x = center_point.m_c[0];
		float m_Origin_y = center_point.m_c[1];
		m_ni = 0.5*(m_Origin_x*m_Origin_x + m_Origin_y*m_Origin_y);
		m_Origin = c2ga::normalizedPoint(c2ga::normalizedPoint_e1_e2_ni_nof1_0, center_point.m_c[0], center_point.m_c[1], m_ni);
	}

	bool operator()( const m_voronoi &arg1,const m_voronoi &arg2 )const
	{
		c2ga::normalizedPoint V1 = arg1.vertex;
		c2ga::normalizedPoint V2 = arg2.vertex;

		c2ga::normalizedPoint pV1 = Minus(m_Origin, V1);
		c2ga::normalizedPoint pV2 = Minus(m_Origin, V2);
		c2ga::normalizedPoint bp  = Minus(m_Origin, p0);
		e2ga::vector V_A ;
		V_A.set(e2ga::vector_e1_e2,pV1.e1(),pV1.e2());
		e2ga::vector V_B ;
		V_B.set(e2ga::vector_e1_e2,pV2.e1(),pV2.e2());
		e2ga::vector OUT_bp;
		OUT_bp.set(e2ga::vector_e1_e2,bp.e1(),bp.e2());

		// note [1/7/2011 Eline]
		//e2ga::mv MV_Oa = e2ga::op(OUT_bp,V_A);
		//e2ga::mv MV_Ob = e2ga::op(OUT_bp,V_B);
		//float OA = MV_Oa.m_c[0];
		//float OB = MV_Ob.m_c[0];//取bivector不确定是取第几个，应该就是这个~
		// end_note [1/7/2011 Eline]

		e2ga::mv MV_a = unit_e(OUT_bp)<< unit_e(V_A);
		e2ga::mv MV_b = unit_e(OUT_bp)<< unit_e(V_B);
		float A = MV_a.m_c[0];
		float B = MV_b.m_c[0];

		//两点同在右边
		if (( fabs(V1.m_c[0] - m_Origin.m_c[0]) > FLT_EPSILON) && (fabs(V2.m_c[0] - m_Origin.m_c[0]) > FLT_EPSILON))
		{
			
			//if (A > B)
			////if (fabs(A - B) > FLT_EPSILON)
			//{
			//	return true;
			//}
			//else
			//{
			//	return false;
			//}
			// note [1/7/2011 Eline]

			return MV_a.m_c[0] > MV_b.m_c[0];
		}
		//两点同在左边
		else if((fabs(V1.m_c[0] - m_Origin.m_c[0]) < FLT_EPSILON) && (fabs(V2.m_c[0] - m_Origin.m_c[0]) < FLT_EPSILON))
		{
			//if (A > B || A == B)
			////if (fabs(A - B) > FLT_EPSILON || fabs(A - B) == FLT_EPSILON)
			//{
			//	return false;
			//}
			//else
			//{
			//	return true;
			//}
			// note [1/7/2011 Eline]

			return MV_a.m_c[0] < MV_b.m_c[0];
		}
		//两个点在不同象限

		//第一个点在第一象限
		if ((fabs(V1.e1()-m_Origin.e1())> FLT_EPSILON)&& (fabs(V1.e2() - m_Origin.e2()) < FLT_EPSILON))	
		{
			return true;
		}
		//第二个点在第一象限
		else if ((fabs(V2.e1()-m_Origin.e1()) > FLT_EPSILON)&& (fabs(V2.e2() - m_Origin.e2())< FLT_EPSILON))
		{
			return false;
		}
		//第一个点在第四象限
		else if ((fabs(V1.e1()-m_Origin.e1()) > FLT_EPSILON) && (fabs(V1.e2()- m_Origin.e2()) < FLT_EPSILON))
		{
			return true;
		}
		//第二个点在第四象限
		else if ((fabs(V2.e1()-m_Origin.e1())>FLT_EPSILON) && (fabs(V2.e2()-m_Origin.e2()) < FLT_EPSILON))
		{
			return false;
		}
		//第一个点在第三象限
		else if ((fabs(V1.e1()-m_Origin.e1()) < FLT_EPSILON) && (fabs(V1.e2()-m_Origin.e2()) < FLT_EPSILON))
		{
			return true;
		}
		//第二个点在第三象限
		else if ((fabs(V2.e1()-m_Origin.e1()) < FLT_EPSILON) && (fabs(V2.e2()-m_Origin.e2()) < FLT_EPSILON))
		{
			return false;
		}
		//第一个点在第二象限
		else if ((fabs(V1.e1()-m_Origin.e1()) < FLT_EPSILON) && (fabs(V1.e2()-m_Origin.e2()) > FLT_EPSILON))
		{
			return true;
		}
		//第二个点在第二象限
		else
		{
			return false;
		}
	}

public:
	c2ga::normalizedPoint p0;	//base

	c2ga::normalizedPoint m_Origin;
}; 

[yilin57]

在线等

[zy020118]

fabs（A-B）<FLT_EPSILON这个的作用是判断两个数是否相等，和 A < B 不一样吧

[yilin57]

不一样么？不是相当于A-B<0么？

[zy020118]

fabs求浮点数x的绝对值，所以肯定是不一样的

[yilin57]

我弄错了，先把这个改过来！

[yilin57]

成功！谢谢你！自己太马虎了。。。不过浮点数比大小精度问题这个还是要来深究一下~先谢过啦

[zy020118]

FLT_EPSILON本质意义是定义的大于0的最小正数，所以考虑精度问题时，比较浮点数A和B等价如下
A == B ==> fabs(A - B) < FLT_EPSILON
A < B ==> (B - A) >= FLT_EPSILON
A > B ==> (A - B) >= FLT_EPSILON