예제 #1
0
void CCurve::LeftDown(HDC hDC, const POINT& point)
{
	Draw(hDC, TRUE/*bShowSelection*/, TRUE/*bWantHandles*/); // erase old

	ProcessPoint(point);

	if (!CanEditPoint(iCurrent))
		return;
	
	// do not drag past neighbors
	POINT actual;
	AdjustForNeighbors(point, iCurrent, actual);

	Points[iCurrent] = actual;
	Draw(hDC, TRUE/*bShowSelection*/, TRUE/*bWantHandles*/);	// draw new
}
예제 #2
0
ICHullError ICHull::Process()
{
    unsigned int addedPoints = 0;
    if (m_mesh.GetNVertices() < 3) {
        return ICHullErrorNotEnoughPoints;
    }
    if (m_mesh.GetNVertices() == 3) {
        m_isFlat = true;
        CircularListElement<TMMTriangle>* t1 = m_mesh.AddTriangle();
        CircularListElement<TMMTriangle>* t2 = m_mesh.AddTriangle();
        CircularListElement<TMMVertex>* v0 = m_mesh.m_vertices.GetHead();
        CircularListElement<TMMVertex>* v1 = v0->GetNext();
        CircularListElement<TMMVertex>* v2 = v1->GetNext();
        // Compute the normal to the plane
        Vec3<double> p0 = v0->GetData().m_pos;
        Vec3<double> p1 = v1->GetData().m_pos;
        Vec3<double> p2 = v2->GetData().m_pos;
        m_normal = (p1 - p0) ^ (p2 - p0);
        m_normal.Normalize();
        t1->GetData().m_vertices[0] = v0;
        t1->GetData().m_vertices[1] = v1;
        t1->GetData().m_vertices[2] = v2;
        t2->GetData().m_vertices[0] = v1;
        t2->GetData().m_vertices[1] = v2;
        t2->GetData().m_vertices[2] = v2;
        return ICHullErrorOK;
    }
    if (m_isFlat) {
        m_mesh.m_edges.Clear();
        m_mesh.m_triangles.Clear();
        m_isFlat = false;
    }
    if (m_mesh.GetNTriangles() == 0) // we have to create the first polyhedron
    {
        ICHullError res = DoubleTriangle();
        if (res != ICHullErrorOK) {
            return res;
        }
        else {
            addedPoints += 3;
        }
    }
    CircularList<TMMVertex>& vertices = m_mesh.GetVertices();
    // go to the first added and not processed vertex
    while (!(vertices.GetHead()->GetPrev()->GetData().m_tag)) {
        vertices.Prev();
    }
    while (!vertices.GetData().m_tag) // not processed
    {
        vertices.GetData().m_tag = true;
        if (ProcessPoint()) {
            addedPoints++;
            CleanUp(addedPoints);
            vertices.Next();
            if (!GetMesh().CheckConsistancy()) {
                size_t nV = m_mesh.GetNVertices();
                CircularList<TMMVertex>& vertices = m_mesh.GetVertices();
                for (size_t v = 0; v < nV; ++v) {
                    if (vertices.GetData().m_name == sc_dummyIndex) {
                        vertices.Delete();
                        break;
                    }
                    vertices.Next();
                }
                return ICHullErrorInconsistent;
            }
        }
    }
    if (m_isFlat) {
        SArray<CircularListElement<TMMTriangle>*> trianglesToDuplicate;
        size_t nT = m_mesh.GetNTriangles();
        for (size_t f = 0; f < nT; f++) {
            TMMTriangle& currentTriangle = m_mesh.m_triangles.GetHead()->GetData();
            if (currentTriangle.m_vertices[0]->GetData().m_name == sc_dummyIndex || currentTriangle.m_vertices[1]->GetData().m_name == sc_dummyIndex || currentTriangle.m_vertices[2]->GetData().m_name == sc_dummyIndex) {
                m_trianglesToDelete.PushBack(m_mesh.m_triangles.GetHead());
                for (int k = 0; k < 3; k++) {
                    for (int h = 0; h < 2; h++) {
                        if (currentTriangle.m_edges[k]->GetData().m_triangles[h] == m_mesh.m_triangles.GetHead()) {
                            currentTriangle.m_edges[k]->GetData().m_triangles[h] = 0;
                            break;
                        }
                    }
                }
            }
            else {
                trianglesToDuplicate.PushBack(m_mesh.m_triangles.GetHead());
            }
            m_mesh.m_triangles.Next();
        }
        size_t nE = m_mesh.GetNEdges();
        for (size_t e = 0; e < nE; e++) {
            TMMEdge& currentEdge = m_mesh.m_edges.GetHead()->GetData();
            if (currentEdge.m_triangles[0] == 0 && currentEdge.m_triangles[1] == 0) {
                m_edgesToDelete.PushBack(m_mesh.m_edges.GetHead());
            }
            m_mesh.m_edges.Next();
        }
        size_t nV = m_mesh.GetNVertices();
        CircularList<TMMVertex>& vertices = m_mesh.GetVertices();
        for (size_t v = 0; v < nV; ++v) {
            if (vertices.GetData().m_name == sc_dummyIndex) {
                vertices.Delete();
            }
            else {
                vertices.GetData().m_tag = false;
                vertices.Next();
            }
        }
        CleanEdges();
        CleanTriangles();
        CircularListElement<TMMTriangle>* newTriangle;
        for (size_t t = 0; t < trianglesToDuplicate.Size(); t++) {
            newTriangle = m_mesh.AddTriangle();
            newTriangle->GetData().m_vertices[0] = trianglesToDuplicate[t]->GetData().m_vertices[1];
            newTriangle->GetData().m_vertices[1] = trianglesToDuplicate[t]->GetData().m_vertices[0];
            newTriangle->GetData().m_vertices[2] = trianglesToDuplicate[t]->GetData().m_vertices[2];
        }
    }
    return ICHullErrorOK;
}