AF2Rule.hpp

Go to the documentation of this file.

/*
 * AF2Rule.hpp
 *
 * \brief An AF2Rule defines a two-dimensional pattern for advancing the front
 * of a two-dimensional advancing front algorithm.
 *
 * The pattern consists of a number of existing edges and existing vertices,
 * a free zone definition, new vertices, new edges, and new faces.
 * In order for the advancing algorithm to apply the pattern, there must
 * be edges and points on the advancing front in the neighborhood
 * of some baseline edge that match the defined existing edges and existing
 * vertices of the pattern.  Depending on the particular binding of
 * existing edges and vertices to edges and points in the neighborhood,
 * as well as the quality level, the free zone definition will define
 * a free zone.  This free zone must not contain any of the neighborhood's
 * points or intersect any of its edges, or the algorithm will not apply
 * the pattern.
 *
 * There is also a maximum quality defined on the rule.  If the baseline
 * edge is currently of higher quality than the specified maximum quality,
 * i.e., if the quality level number is smaller than the defined maximum
 * quality level number, then the rule may not be applied.
 *
 * If the pattern can be successfully applied, then applying the pattern
 * involves adding the new vertices, new edges, and new faces of the pattern
 * to the mesh.  Since there may be several different ways to apply
 * the pattern or several different patterns that could be applied,
 * each potential successful application of the pattern is handed off
 * to a visitor for processing.  The rule makes no guarantee that
 * the new faces are not inverted, and the visitor should verify any
 * desired properties before committing the results to the mesh.
 */
#ifndef AF2RULE_HPP
#define AF2RULE_HPP

// C++
#include <list>
#include <map>
#include <string>

// MeshKit
#include "meshkit/AF2Edge2D.hpp"
#include "meshkit/AF2FreeZoneDef.hpp"
#include "meshkit/AF2Neighborhood.hpp"
#include "meshkit/AF2Point2D.hpp"
#include "meshkit/AF2RuleAppVisitor.hpp"
#include "meshkit/AF2RuleExistEdge.hpp"
#include "meshkit/AF2RuleExistVertex.hpp"
#include "meshkit/AF2RuleNewEdge.hpp"
#include "meshkit/AF2RuleNewFace.hpp"
#include "meshkit/AF2RuleNewVertex.hpp"

class AF2Rule
{
  private:

    const std::string ruleName;
    const unsigned int maxQualityLevel;
    const unsigned int numExVertices, numExEdges;
    const AF2FreeZoneDef* const freeZoneDef;
    const unsigned int numNewVertices, numNewEdges, numNewFaces;
    const AF2RuleExistVertex** exVertices;
    const AF2RuleExistEdge** exEdges;
    const AF2RuleNewVertex** newVertices;
    const AF2RuleNewEdge** newEdges;
    const AF2RuleNewFace** newFaces;
    unsigned int numExIsoVertices;
    const AF2RuleExistVertex** exIsoVertices;

    void applyRuleStageTwo(AF2Neighborhood const & ngbhd,
        unsigned int matchQuality, AF2RuleAppVisitor & visitor,
        std::map<const AF2RuleExistVertex*,
        std::list<const AF2Point2D*>*>* const & matchingVerticesMap,
        AF2Binding & binding) const;

    void applyRuleStageThree(AF2Neighborhood const & ngbhd,
        unsigned int matchQuality, AF2RuleAppVisitor & visitor,
        AF2Binding const & binding) const;

    std::map<const AF2RuleExistEdge*, std::list<const AF2Edge2D*>*>*
        findPotentialEdgeMatches(AF2Neighborhood const & ngbhd,
        unsigned int matchQuality) const;

    std::map<const AF2RuleExistVertex*, std::list<const AF2Point2D*>*>*
        findPotentialVertexMatches(AF2Neighborhood const & ngbhd,
        unsigned int matchQuality) const;

    void checkExEndpointsAndFindIsolatedVertices();

    bool isMatchingEdge(AF2Edge2D const & edge,
        AF2RuleExistEdge const & ruleEdge, unsigned int matchQuality) const;

    bool isMatchingVertex(AF2Point2D const & point,
        AF2RuleExistVertex const & ruleVertex, unsigned int matchQuality) const;

  public:

    AF2Rule(std::string const & ruleNameArg, unsigned int maxQuality,
        std::list<const AF2RuleExistVertex*> const & ruleVertices,
        const AF2RuleExistEdge* baselineEdge,
        std::list<const AF2RuleExistEdge*> const & otherRuleEdges,
        const AF2FreeZoneDef* freeZoneDef,
        std::list<const AF2RuleNewVertex*> const & ruleNewVertices,
        std::list<const AF2RuleNewEdge*> const & ruleNewEdges,
        std::list<const AF2RuleNewFace*> const & ruleNewFaces);

    ~AF2Rule();

    AF2Rule(const AF2Rule & toCopy);

    AF2Rule& operator=(const AF2Rule & rhs);

    void applyRule(AF2Neighborhood const & ngbhd, unsigned int matchQuality,
        AF2RuleAppVisitor & visitor) const;

    std::string getName() const;
};

#endif