Degeneration.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_DEGENERATION_H
#define MESH_DEGENERATION_H

#include <bitset>
#include <string>
#include <vector>

#include "Evaluation.h"
#include "Definitions.h"

namespace MeshCore {

class MeshKernel;
class MeshGeomFacet;
class MeshFacetIterator;

class MeshExport MeshEvalInvalids : public MeshEvaluation
{
public:
  MeshEvalInvalids (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalInvalids () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixInvalids : public MeshValidation
{
public:
  MeshFixInvalids (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixInvalids () { }
  bool Fixup ();
};

class MeshExport MeshEvalDuplicatePoints : public MeshEvaluation
{
public:
  MeshEvalDuplicatePoints (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalDuplicatePoints () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixDuplicatePoints : public MeshValidation
{
public:
  MeshFixDuplicatePoints (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixDuplicatePoints () { }
  bool Fixup ();
};

class MeshExport MeshEvalDuplicateFacets : public MeshEvaluation
{
public:
  MeshEvalDuplicateFacets (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalDuplicateFacets () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixDuplicateFacets : public MeshValidation
{
public:
  MeshFixDuplicateFacets (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixDuplicateFacets () { }
  bool Fixup ();
};

class MeshExport MeshEvalDegeneratedFacets : public MeshEvaluation
{
public:
  MeshEvalDegeneratedFacets (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalDegeneratedFacets () { }
  bool Evaluate ();
  unsigned long CountEdgeTooSmall (float fMinEdgeLength) const;
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixDegeneratedFacets : public MeshValidation
{
public:
  MeshFixDegeneratedFacets (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixDegeneratedFacets () { }
  bool Fixup ();
  unsigned long RemoveEdgeTooSmall (float fMinEdgeLength = MeshDefinitions::_fMinPointDistance,
                                    float fMinEdgeAngle  = MeshDefinitions::_fMinEdgeAngle);
};

class MeshExport MeshEvalDeformedFacets : public MeshEvaluation
{
public:
  MeshEvalDeformedFacets (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalDeformedFacets () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixDeformedFacets : public MeshValidation
{
public:
  MeshFixDeformedFacets (MeshKernel &rclM, float fAngle) : MeshValidation( rclM ), fMaxAngle(fAngle) { }
  ~MeshFixDeformedFacets () { }
  bool Fixup ();

private:
  float fMaxAngle;
};

class MeshExport MeshEvalFoldsOnSurface : public MeshEvaluation
{
public:
    MeshEvalFoldsOnSurface (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
    ~MeshEvalFoldsOnSurface() {}

    bool Evaluate();
    std::vector<unsigned long> GetIndices() const;

private:
    std::vector<unsigned long> indices;
};

class MeshExport MeshFixFoldsOnSurface : public MeshValidation
{
public:
    MeshFixFoldsOnSurface (MeshKernel &rclM) : MeshValidation( rclM ) { }
    ~MeshFixFoldsOnSurface() {}

    bool Fixup();
};

class MeshExport MeshEvalFoldsOnBoundary : public MeshEvaluation
{
public:
    MeshEvalFoldsOnBoundary (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
    ~MeshEvalFoldsOnBoundary() {}

    bool Evaluate();
    std::vector<unsigned long> GetIndices() const;

private:
    std::vector<unsigned long> indices;
};

class MeshExport MeshFixFoldsOnBoundary : public MeshValidation
{
public:
    MeshFixFoldsOnBoundary (MeshKernel &rclM) : MeshValidation( rclM ) { }
    ~MeshFixFoldsOnBoundary() {}

    bool Fixup();
};

class MeshExport MeshEvalFoldOversOnSurface : public MeshEvaluation
{
public:
    MeshEvalFoldOversOnSurface (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
    ~MeshEvalFoldOversOnSurface() {}

    bool Evaluate();
    std::vector<unsigned long> GetIndices() const
    { return this->indices; }

private:
    std::vector<unsigned long> indices;
};

class MeshExport MeshEvalBorderFacet : public MeshEvaluation
{
public:
  MeshEvalBorderFacet (const MeshKernel &rclB, std::vector<unsigned long>& f)
    : MeshEvaluation(rclB), _facets(f) {}
  virtual ~MeshEvalBorderFacet () {}
  bool Evaluate();

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

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

class MeshExport MeshEvalRangeFacet : public MeshEvaluation
{
public:
  MeshEvalRangeFacet (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalRangeFacet () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixRangeFacet : public MeshValidation
{
public:
  MeshFixRangeFacet (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixRangeFacet () { }
  bool Fixup ();
};

class MeshExport MeshEvalRangePoint : public MeshEvaluation
{
public:
  MeshEvalRangePoint (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalRangePoint () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixRangePoint : public MeshValidation
{
public:
  MeshFixRangePoint (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixRangePoint () { }
  bool Fixup ();
};

class MeshExport MeshEvalCorruptedFacets : public MeshEvaluation
{
public:
  MeshEvalCorruptedFacets (const MeshKernel &rclM) : MeshEvaluation( rclM ) { }
  ~MeshEvalCorruptedFacets () { }
  bool Evaluate ();
  std::vector<unsigned long> GetIndices() const;
};

class MeshExport MeshFixCorruptedFacets : public MeshValidation
{
public:
  MeshFixCorruptedFacets (MeshKernel &rclM) : MeshValidation( rclM ) { }
  ~MeshFixCorruptedFacets () { }
  bool Fixup ();
};

} // namespace MeshCore

#endif // MESH_DEGENERATION_H