Visitor.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 VISITOR_H
#define VISITOR_H

namespace MeshCore {

class MeshFacet;
class MeshKernel;
class MeshFacetVisitor;
class PlaneFit;

class MeshExport MeshFacetVisitor
{
public:
    MeshFacetVisitor(void) { }
    virtual ~MeshFacetVisitor(void) { }
    virtual bool Visit (const MeshFacet &rclFacet, const MeshFacet &rclFrom, unsigned long ulFInd,
                        unsigned long ulLevel) = 0;

    virtual bool AllowVisit (const MeshFacet& rclFacet, const MeshFacet& rclFrom, 
                             unsigned long ulFInd, unsigned long ulLevel,
                             unsigned short neighbourIndex)
    {
        return true;
    }
};

class MeshExport MeshSearchNeighbourFacetsVisitor : public MeshFacetVisitor
{
public:
    MeshSearchNeighbourFacetsVisitor (const MeshKernel &rclMesh, float fRadius, unsigned long ulStartFacetIdx);
    virtual ~MeshSearchNeighbourFacetsVisitor () {}
    inline bool Visit (const MeshFacet &rclFacet, const MeshFacet &rclFrom, unsigned long ulFInd, unsigned long ulLevel);
    inline std::vector<unsigned long> GetAndReset (void);

protected:
    const MeshKernel& _rclMeshBase; 
    Base::Vector3f    _clCenter; 
    float  _fRadius; 
    unsigned long _ulCurrentLevel;
    bool _bFacetsFoundInCurrentLevel;
    std::vector<unsigned long>  _vecFacets; 
};

inline bool MeshSearchNeighbourFacetsVisitor::Visit (const MeshFacet &rclFacet, const MeshFacet &rclFrom,
                                                     unsigned long ulFInd, unsigned long ulLevel)
{
    if (ulLevel > _ulCurrentLevel) {
        if (_bFacetsFoundInCurrentLevel == false)
            return false;
        _ulCurrentLevel = ulLevel;
        _bFacetsFoundInCurrentLevel = false;
    }

    for (int i = 0; i < 3; i++) {
        if (Base::Distance(_clCenter, _rclMeshBase.GetPoint(rclFacet._aulPoints[i])) < _fRadius) {
            _vecFacets.push_back(ulFInd);
            _bFacetsFoundInCurrentLevel = true;
            return true;
        }
    }

    return true;
}

class MeshExport MeshTopFacetVisitor : public MeshFacetVisitor
{
public:
    MeshTopFacetVisitor (std::vector<unsigned long> &raulNB) : _raulNeighbours(raulNB) {}
    virtual ~MeshTopFacetVisitor () {}
    virtual bool Visit (const MeshFacet &rclFacet, const MeshFacet &rclFrom,
                        unsigned long ulFInd, unsigned long)
    {
        _raulNeighbours.push_back(ulFInd);
        return true;
    }

protected:
    std::vector<unsigned long>  &_raulNeighbours; 
};

// -------------------------------------------------------------------------

class MeshPlaneVisitor : public MeshFacetVisitor
{
public:
    MeshPlaneVisitor (const MeshKernel& mesh,
                      unsigned long index,
                      float deviation,
                      std::vector<unsigned long> &indices);
    virtual ~MeshPlaneVisitor ();
    bool AllowVisit (const MeshFacet& face, const MeshFacet&, 
                     unsigned long, unsigned long, unsigned short neighbourIndex);
    bool Visit (const MeshFacet & face, const MeshFacet &,
                unsigned long ulFInd, unsigned long);

protected:
    const MeshKernel& mesh;
    std::vector<unsigned long>  &indices;
    Base::Vector3f basepoint;
    Base::Vector3f normal;
    float max_deviation;
    PlaneFit* fitter;
};

// -------------------------------------------------------------------------

class MeshExport MeshPointVisitor
{
public:
    MeshPointVisitor(void) { }
    virtual ~MeshPointVisitor(void) { }
    virtual bool Visit (const MeshPoint &rclPoint, const MeshPoint &rclFrom,
                        unsigned long ulPInd, unsigned long ulLevel) = 0;
};

} // namespace MeshCore

#endif // VISITOR_H