AF2Algorithm.hpp

Go to the documentation of this file.

/*
 * AF2Algorithm.hpp
 *
 * \brief An AF2Algorithm provides the capability to execute
 * a two-dimensional advancing front algorithm.
 *
 * An AF2Algorithm is an object that executes a two-dimensional advancing
 * front algorithm.  It is constructed with a list of rules.  When the
 * execute method is called, AF2Algorithm enters a loop attempting to
 * advance the front until the front is empty, which means the algorithm
 * has completed successfully, or failure termination criteria have
 * been satisfied.  In the loop, the algorithm selects a baseline edge
 * on the current advancing front.  The neighborhood surrounding that
 * edge is transformed to a two-dimensional coordinate space, and
 * the algorithm attempts to apply each of the rules to that baseline
 * edge in the two-dimensional coordinate space.  If a rule can be
 * applied, the best rule is chosen and the front is advanced.  If no
 * rule can be applied, the baseline edge has its quality decreased
 * so that the next time, if any, that the same baseline edge is chosen,
 * there will be more flexibility in what constitutes a successful
 * application of a rule.
 *
 * The execute method returns an AF2Algorithm result that is either
 * successful or unsuccessful.  If it is successful, it contains lists
 * of all points and faces that are part of the result mesh.
 */
#ifndef AF2ALGORITHM_HPP
#define AF2ALGORITHM_HPP

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

// MOAB
#include "moab/Types.hpp"

// MeshKit
#include "meshkit/AF2AlgorithmResult.hpp"
#include "meshkit/AF2LocalTransformMaker.hpp"
#include "meshkit/AF2Front.hpp"
#include "meshkit/AF2Neighborhood.hpp"
#include "meshkit/AF2Point2D.hpp"
#include "meshkit/AF2Point3D.hpp"
#include "meshkit/AF2Polygon2D.hpp"
#include "meshkit/AF2Polygon3D.hpp"
#include "meshkit/AF2Rule.hpp"

class AF2Algorithm
{
  private:

    const std::list<const AF2Rule*> ruleList;

    void initFront(AF2Front & front, std::list<AF2Point3D*> & pntList,
        unsigned long & pntId,
        const double* coords, unsigned int numPoints,
        const unsigned int* edges, unsigned int numEdges,
        const moab::EntityHandle* vertexHandles) const;

    void processNewFace(const AF2Polygon2D* newFace2D,
        AF2Neighborhood* & ngbhd,
        std::map<const AF2Point2D*, AF2Point3D*> & newPointsMap,
        std::list<const AF2Polygon3D*> & allFaces, AF2Front & front) const;

    void processNewPoint(const AF2Point2D* newPoint2D,
        unsigned long & pntId, AF2Neighborhood* & ngbhd,
        std::map<const AF2Point2D*, AF2Point3D*> & newPointsMap,
        std::list<AF2Point3D*> & allPoints, AF2Front & front) const;

    void release(std::list<AF2Point3D*> & allPoints,
        std::list<const AF2Polygon3D*> & allFaces) const;

    void output_intermediate_result (std::list<AF2Point3D*> & allPoints,
            std::list<const AF2Polygon3D*> & allFaces,int face,  int step) const;

  public:

    AF2Algorithm(const std::list<const AF2Rule*> & ruleListArg);

    ~AF2Algorithm();

    AF2Algorithm(const AF2Algorithm & toCopy);

    AF2Algorithm& operator=(const AF2Algorithm & rhs);

    AF2AlgorithmResult* execute(
        const AF2LocalTransformMaker* const & transformMaker,
        const double* coords, unsigned int numPoints,
        const unsigned int* edges, unsigned int numEdges,
        const moab::EntityHandle* vertexHandles = NULL, int debug = 0) const;
};

#endif