MeshKernel.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2005 Imetric 3D GmbH                                    *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  is distributed in the hope that it will be useful,      *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef MESH_KERNEL_H
#define MESH_KERNEL_H

#include <assert.h>
#include <iostream>

#include "Elements.h"
#include "Helpers.h"

#include <Base/BoundBox.h>
#include <Base/Vector3D.h>
#include <Base/Matrix.h>

namespace Base{
  class Polygon2D;
  class ViewProjMethod;
}

namespace MeshCore {

// forward declarations
class MeshFacetIterator;
class MeshPointIterator;
class MeshGeomFacet;
class MeshFacet;
class MeshFacetVisitor;
class MeshPointVisitor;
class MeshFacetGrid;


class MeshExport MeshKernel
{
public:
    MeshKernel (void);
    MeshKernel (const MeshKernel &rclMesh);
    ~MeshKernel (void)
    { Clear(); }


    void Write (std::ostream &rclOut) const;
    void Read (std::istream &rclIn);


    unsigned long CountFacets (void) const
    { return (unsigned long)(_aclFacetArray.size()); }
    unsigned long CountEdges (void) const;
    // Returns the number of points
    unsigned long CountPoints (void) const
    { return (unsigned long)(_aclPointArray.size()); }
    unsigned int GetMemSize (void) const
    { return _aclPointArray.size() * sizeof(MeshPoint) +
           _aclFacetArray.size() * sizeof(MeshFacet); }
    const Base::BoundBox3f& GetBoundBox (void) const
    { return _clBoundBox; }

    void RecalcBoundBox (void);

    inline MeshPoint GetPoint (unsigned long ulIndex) const;

    std::vector<Base::Vector3f> CalcVertexNormals() const;

    inline MeshGeomFacet GetFacet (unsigned long ulIndex) const;
    inline MeshGeomFacet GetFacet (const MeshFacet &rclFacet) const;

    inline void GetFacetPoints (unsigned long ulFaIndex, unsigned long &rclP0, 
                                unsigned long &rclP1, unsigned long &rclP2) const;
    std::vector<unsigned long> GetFacetPoints(const std::vector<unsigned long>&) const;
    inline void GetFacetNeighbours (unsigned long ulIndex, unsigned long &rulNIdx0, 
                                    unsigned long &rulNIdx1, unsigned long &rulNIdx2) const;

    std::vector<unsigned long> HasFacets (const MeshPointIterator &rclIter) const;

    bool IsValid (void) const
    { return _bValid; }

    const MeshPointArray& GetPoints (void) const { return _aclPointArray; }

    const MeshFacetArray& GetFacets (void) const { return _aclFacetArray; }
    MeshFacetArray GetFacets(const std::vector<unsigned long>&) const;

    void GetEdges (std::vector<MeshGeomEdge>&) const;

    float GetSurface() const;
    float GetSurface( const std::vector<unsigned long>& aSegment ) const;
    float GetVolume () const;
    bool HasOpenEdges() const;
    bool HasNonManifolds() const;
    bool HasSelfIntersections() const;

    unsigned long VisitNeighbourFacets (MeshFacetVisitor &rclFVisitor, unsigned long ulStartFacet) const;
    unsigned long VisitNeighbourFacetsOverCorners (MeshFacetVisitor &rclFVisitor, unsigned long ulStartFacet) const;

    unsigned long VisitNeighbourPoints (MeshPointVisitor &rclPVisitor, unsigned long ulStartPoint) const; 

    MeshFacetIterator FacetIterator() const;
    MeshPointIterator PointIterator() const;

    MeshKernel& operator += (const MeshGeomFacet &rclSFacet);
    void AddFacet(const MeshGeomFacet &rclSFacet);
    MeshKernel& operator += (const std::vector<MeshGeomFacet> &rclFAry);
    void AddFacets(const std::vector<MeshGeomFacet> &rclFAry);
    unsigned long AddFacets(const std::vector<MeshFacet> &rclFAry);
    unsigned long AddFacets(const std::vector<MeshFacet> &rclFAry,
                            const std::vector<Base::Vector3f>& rclPAry);
    void Merge(const MeshKernel& rKernel);
    void Merge(const MeshPointArray& rPoints, const MeshFacetArray& rFaces);
    bool DeleteFacet (const MeshFacetIterator &rclIter);
    bool DeleteFacet (unsigned long ulInd);
    void DeleteFacets (const std::vector<unsigned long> &raulFacets);
    bool DeletePoint (const MeshPointIterator &rclIter);
    bool DeletePoint (unsigned long ulInd);
    void DeletePoints (const std::vector<unsigned long> &raulPoints);
    void RebuildNeighbours (void);
    void Clear (void);
    MeshKernel& operator = (const std::vector<MeshGeomFacet> &rclFAry);
    MeshKernel& operator = (const MeshKernel &rclMesh);
    void Assign(const MeshPointArray& rPoints, const MeshFacetArray& rFaces, bool checkNeighbourHood=false);
    void Adopt(MeshPointArray& rPoints, MeshFacetArray& rFaces, bool checkNeighbourHood=false);
    void Swap(MeshKernel& mesh);
    void operator *= (const Base::Matrix4D &rclMat);
    void Transform (const Base::Matrix4D &rclMat);
    inline void MovePoint (unsigned long ulPtIndex, const Base::Vector3f &rclTrans);
    inline void SetPoint (unsigned long ulPtIndex, const Base::Vector3f &rPoint);
    inline void SetPoint (unsigned long ulPtIndex, float x, float y, float z);
    void Smooth(int iterations, float d_max);
    void CutFacets (const MeshFacetGrid& rclGrid, const Base::ViewProjMethod *pclP, const Base::Polygon2D& rclPoly, 
                    bool bCutInner, std::vector<MeshGeomFacet> &raclFacets);
    void CutFacets (const MeshFacetGrid& rclGrid, const Base::ViewProjMethod* pclP, const Base::Polygon2D& rclPoly, 
                    bool bCutInner, std::vector<unsigned long> &raclCutted);

protected:
    void RebuildNeighbours (unsigned long);
    void RemoveInvalids ();
    void ErasePoint (unsigned long ulIndex, unsigned long ulFacetIndex, bool bOnlySetInvalid = false);

    inline void AdjustNormal (MeshFacet &rclFacet, const Base::Vector3f &rclNormal);
    inline Base::Vector3f GetNormal (const MeshFacet &rclFacet) const;
    inline Base::Vector3f GetGravityPoint (const MeshFacet &rclFacet) const;

    MeshPointArray   _aclPointArray; 
    MeshFacetArray   _aclFacetArray; 
    Base::BoundBox3f _clBoundBox;    
    bool            _bValid; 
    // friends
    friend class MeshPointIterator;
    friend class MeshFacetIterator;
    friend class MeshFastFacetIterator;
    friend class MeshAlgorithm;
    friend class MeshTopoAlgorithm;
    friend class MeshFixNeighbourhood;
    friend class MeshFixDegenerations;
    friend class MeshFixSingleFacet;
    friend class MeshFixInvalids;
    friend class MeshFixDegeneratedFacets;
    friend class MeshFixDuplicatePoints;
    friend class MeshBuilder;
};

inline MeshPoint MeshKernel::GetPoint (unsigned long ulIndex) const
{
    assert(ulIndex < _aclPointArray.size());
    return _aclPointArray[ulIndex];
}

inline MeshGeomFacet MeshKernel::GetFacet (unsigned long ulIndex) const
{
    assert(ulIndex < _aclFacetArray.size());

    const MeshFacet *pclF = &_aclFacetArray[ulIndex];
    MeshGeomFacet  clFacet;

    clFacet._aclPoints[0] = _aclPointArray[pclF->_aulPoints[0]];
    clFacet._aclPoints[1] = _aclPointArray[pclF->_aulPoints[1]];
    clFacet._aclPoints[2] = _aclPointArray[pclF->_aulPoints[2]];
    clFacet._ulProp       = pclF->_ulProp;
    clFacet._ucFlag       = pclF->_ucFlag;
    clFacet.CalcNormal();
    return clFacet;
}

inline MeshGeomFacet MeshKernel::GetFacet (const MeshFacet &rclFacet) const
{
    assert(rclFacet._aulPoints[0] < _aclPointArray.size());
    assert(rclFacet._aulPoints[1] < _aclPointArray.size());
    assert(rclFacet._aulPoints[2] < _aclPointArray.size());

    MeshGeomFacet  clFacet;
    clFacet._aclPoints[0] = _aclPointArray[rclFacet._aulPoints[0]];
    clFacet._aclPoints[1] = _aclPointArray[rclFacet._aulPoints[1]];
    clFacet._aclPoints[2] = _aclPointArray[rclFacet._aulPoints[2]];
    clFacet._ulProp       = rclFacet._ulProp;
    clFacet._ucFlag       = rclFacet._ucFlag;
    clFacet.CalcNormal();
    return  clFacet;
}

inline void MeshKernel::GetFacetNeighbours (unsigned long ulIndex, unsigned long &rulNIdx0,
                                            unsigned long &rulNIdx1, unsigned long &rulNIdx2) const 
{
    assert(ulIndex < _aclFacetArray.size());

    rulNIdx0 = _aclFacetArray[ulIndex]._aulNeighbours[0];
    rulNIdx1 = _aclFacetArray[ulIndex]._aulNeighbours[1];
    rulNIdx2 = _aclFacetArray[ulIndex]._aulNeighbours[2];
}

inline void MeshKernel::MovePoint (unsigned long ulPtIndex, const Base::Vector3f &rclTrans)
{
    _aclPointArray[ulPtIndex] += rclTrans;
}

inline void MeshKernel::SetPoint (unsigned long ulPtIndex, const Base::Vector3f &rPoint)
{
    _aclPointArray[ulPtIndex] = rPoint;
}

inline void MeshKernel::SetPoint (unsigned long ulPtIndex, float x, float y, float z)
{
    _aclPointArray[ulPtIndex].Set(x,y,z);
}

inline void MeshKernel::AdjustNormal (MeshFacet &rclFacet, const Base::Vector3f &rclNormal)
{
    Base::Vector3f clN = (_aclPointArray[rclFacet._aulPoints[1]] - _aclPointArray[rclFacet._aulPoints[0]]) %
                         (_aclPointArray[rclFacet._aulPoints[2]] - _aclPointArray[rclFacet._aulPoints[0]]);
    if ((clN * rclNormal) < 0.0f) {
        rclFacet.FlipNormal();
    }
}

inline Base::Vector3f MeshKernel::GetNormal (const MeshFacet &rclFacet) const
{
    Base::Vector3f clN = (_aclPointArray[rclFacet._aulPoints[1]] - _aclPointArray[rclFacet._aulPoints[0]]) %
                         (_aclPointArray[rclFacet._aulPoints[2]] - _aclPointArray[rclFacet._aulPoints[0]]);
    clN.Normalize();
    return clN;
}

inline Base::Vector3f MeshKernel::GetGravityPoint (const MeshFacet &rclFacet) const
{
    const Base::Vector3f& p0 = _aclPointArray[rclFacet._aulPoints[0]];
    const Base::Vector3f& p1 = _aclPointArray[rclFacet._aulPoints[1]];
    const Base::Vector3f& p2 = _aclPointArray[rclFacet._aulPoints[2]];
    return Base::Vector3f((p0.x+p1.x+p2.x)/3.0f,
                          (p0.y+p1.y+p2.y)/3.0f,
                          (p0.z+p1.z+p2.z)/3.0f);
}

inline void MeshKernel::GetFacetPoints (unsigned long ulFaIndex, unsigned long &rclP0,
                                        unsigned long &rclP1, unsigned long &rclP2) const
{
    assert(ulFaIndex < _aclFacetArray.size());
    const MeshFacet& rclFacet = _aclFacetArray[ulFaIndex];
    rclP0 = rclFacet._aulPoints[0];  
    rclP1 = rclFacet._aulPoints[1];  
    rclP2 = rclFacet._aulPoints[2];  
}


} // namespace MeshCore

#endif // MESH_KERNEL_H