bool SortEdgesForConstructWire(const NCollection_Vector<TopoDS_Edge>& oldedges,  NCollection_Vector<TopoDS_Edge>& newedges, double tol, bool *pClosed, double* pMaxGap)
{
    int i, n, minID, id, id2;
    NCollection_Vector<int> bTaken,  matchedIDs, sortedIDs;
    NCollection_Vector<gp_Pnt> pnts;
    TopExp_Explorer ex;
    std::vector<TopoDS_Edge> edges;
    gp_Pnt pnt, endPnts[2];
    bool bSucc;
    double minDis, otherDis, minminDis;
    Standard_Boolean bDeg;
    TopoDS_Vertex v1, v2;
    TopoDS_Edge degEdge;

    newedges.Clear();
	if(pMaxGap)
		*pMaxGap = 0.0;
    n = oldedges.Length();
    if(n==0)
        return false;

    for(i=0; i<n; ++i)
    {
        TopExp::Vertices(oldedges(i), v1, v2);
        pnts.Append(BRep_Tool::Pnt(v1));
        pnts.Append(BRep_Tool::Pnt(v2));
		bTaken.Append(0);
    }

    endPnts[0] = pnts(0);
    endPnts[1] = pnts(1);
    bTaken(0)=1;
    edges.push_back(oldedges(0));

    while(1)
    {
        bSucc = false;
        minID = -1;
        minminDis=DZ_MAX;
        for(i=0; i<n; ++i)
        {
            if(bTaken(i)!=0)
                continue;
            id = GetMatchTwoPntsPair(pnts(2*i), pnts(2*i+1), endPnts[0], endPnts[1], minDis, otherDis);
            if(minDis<minminDis)
            {
                id2 = id;
                minID = i;
                minminDis = minDis;
            }
        }
        if(minID!=-1 && minminDis<tol)
        {
            bTaken(minID) = 1;
            bSucc = true;
            if(id2==0)
            {
                edges.insert(edges.begin(), oldedges(minID));
                endPnts[0] = pnts(2*minID+1);
            }
            else if(id2==1)
            {
                edges.push_back(oldedges(minID));
                endPnts[1] = pnts(2*minID+1);
            }
            else if(id2==2)
            {
                edges.insert(edges.begin(), oldedges(minID));
                endPnts[0] = pnts(2*minID);
            }
            else if(id2==3)
            {
                edges.push_back(oldedges(minID));
                endPnts[1] = pnts(2*minID);
            }
			if(pMaxGap)
			{
				if(*pMaxGap<minminDis)
					*pMaxGap = minminDis;
			}
        }
        if(!bSucc)
            break;
    }

    if(edges.size()!=oldedges.Length())
        return false;

    if(endPnts[1].Distance(endPnts[0])<tol) //close
    {
        if(pClosed)
            *pClosed = true;
        int startID=-1;
        for(i=0; i<edges.size(); ++i)
        {
            if(oldedges(0).IsSame(edges[i]))
            {
                startID = i;
                break;
            }
        }
        if(startID==-1)
        {
            for(i=0; i<edges.size(); ++i)
                newedges.Append(edges[i]);
        }
        else
        {
			for(i=startID; i<edges.size(); ++i)
				newedges.Append(edges[i]);
			for(i=0; i<startID; ++i)
				newedges.Append(edges[i]);
        }
    }
    else
    {
        if(pClosed)
            *pClosed = false;

        for(i=0; i<edges.size(); ++i)
            newedges.Append(edges[i]);
    }

    return true;
}



int GetMatchTwoPntsPair(const gp_Pnt& b1, const gp_Pnt& e1, const gp_Pnt& b2, const gp_Pnt& e2,
                                       double& minDis, double& otherDis)
{
    double distance[4];
    int index=-1, i;

    distance[0]=b1.SquareDistance(b2);
    distance[1]=b1.SquareDistance(e2);
    distance[2]=e1.SquareDistance(b2);
    distance[3]=e1.SquareDistance(e2);
    minDis = DZ_MAX;
    for(i=0;i<4;++i)
    {
        if(distance[i]<minDis)
        {
            minDis=distance[i];
            index=i;
        }
    }
    otherDis = distance[3-index];

    minDis = sqrt(minDis);
    otherDis = sqrt(otherDis);
    return index;
}