SpringbackCorrection.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2007                                                    *
 *   Joachim Zettler <Joachim.Zettler@gmx.de>                              *
 *   Human Rezai <Human@web.de>                                            *
 *   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 _SpringbackCorrection_H_
#define _SpringbackCorrection_H_


#include <Mod/Mesh/App/Core/TopoAlgorithm.h>
#include "cutting_tools.h"

class MeshFacet;




# define cMin    15.0
# define toolRad  5.0

struct EdgeStruct
{
    TopoDS_Edge anEdge;
    std::vector<TopoDS_Face> aFace;
    std::vector<gp_Pnt> pntList;
    double MaxOffset;
    double MinOffset;
};

struct MeshPnt
{
    int index;
    double minCurv;
    double maxCurv;
    double error;
    Base::Vector3f pnt;
    Base::Vector3f normal;
};

struct FacePnt
{
    Base::Vector3f pnt;
    std::vector<double> distances;
    std::vector<double> MinEdgeOff;
    std::vector<double> MaxEdgeOff;
};

struct EdgeStruct_Less
{
    bool operator()(const EdgeStruct& _Left, const EdgeStruct& _Right) const
    {

        if (_Left.anEdge.IsSame(_Right.anEdge)) return false;

        return true;
    }
};

struct Edge_Less
{
    bool operator()(const TopoDS_Edge& _Left, const TopoDS_Edge& _Right) const
    {
        return(_Left.HashCode(IntegerLast())<_Right.HashCode(IntegerLast()));
    }
};




struct MeshPntLess
{
    bool operator()(const Base::Vector3f& _Left, const Base::Vector3f& _Right) const
    {
        if ( fabs(_Left.x - _Right.x) > 0.0001 )
            return _Left.x < _Right.x;
        else if ( fabs(_Left.y - _Right.y) > 0.0001)
            return _Left.y < _Right.y;
        else if ( fabs(_Left.z - _Right.z) > 0.0001 )
            return _Left.z < _Right.z;
        return false;

    }
};

class CamExport SpringbackCorrection : public MeshCore::MeshFacetVisitor
{
public:
    SpringbackCorrection();
    SpringbackCorrection(const TopoDS_Shape& aShape, const MeshCore::MeshKernel& aMesh);
    //SpringbackCorrection(const TopoDS_Shape& aShape, const MeshCore::MeshKernel& aMesh, const MeshCore::MeshKernel& bMesh);

    ~SpringbackCorrection();
    bool Load(const MeshCore::MeshKernel& aMesh);
    bool Load(const TopoDS_Shape& aShape);
    bool Load(const TopoDS_Shape& aShape, const MeshCore::MeshKernel& aMesh);
    bool Init();
    bool Init_Setting(struct CuttingToolsSettings& set);

    bool Perform(int deg_Tol, bool out);

    bool SetFixEdges();
    bool CalcCurv();

    std::vector<double> MeshCurvature(const TopoDS_Face& aFace, const MeshCore::MeshKernel& mesh);

    bool GetCurvature(TopoDS_Face aFace);

    //bool MirrorMesh(std::vector<double> error);
    //double LocalCorrection(std::vector<Base::Vector3f> Neib ,std::vector<Base::Vector3f> Normal,
    //                       bool sign, double minScale);
    //double GlobalCorrection(std::vector<Base::Vector3f> Neib ,std::vector<Base::Vector3f> Normal,
    //                        bool sign, int ind);
    
    //std::vector<Base::Vector3f> FillConvex(std::vector<Base::Vector3f> Neib,std::vector<Base::Vector3f> Normals, int n);
    //bool InsideCheck(Base::Vector3f pnt, Base::Vector3f normal, std::vector<Base::Vector3f> Neib);

    //MeshCore::MeshKernel BuildMesh(Handle_Poly_Triangulation aTri, std::vector<Base::Vector3f> TrPoints);
    int GetBoundary(const MeshCore::MeshKernel &mesh, MeshCore::MeshPointArray &meshPnts);
    //bool SmoothCurvature();
    bool SmoothMesh(MeshCore::MeshKernel &mesh, double maxTranslation);
    bool SmoothMesh(MeshCore::MeshKernel &mesh, std::vector<int> indicies, double maxTranslation);
    //bool GetFaceAng(MeshCore::MeshKernel &mesh, int deg_tol);
    std::vector<int> FaceCheck(MeshCore::MeshKernel &mesh, int deg_tol);
    std::vector<int> InitFaceCheck(MeshCore::MeshKernel &mesh, int deg_tol);
    //void ReorderNeighbourList(std::set<MeshCore::MeshPointArray::_TConstIterator> &pnt,
    //                          std::set<MeshCore::MeshFacetArray::_TConstIterator> &face,
    //                          std::vector<unsigned long> &nei,
    //                          unsigned long CurInd);

    bool FacetRegionGrowing(MeshCore::MeshKernel &mesh,
                            std::vector<MeshCore::MeshFacet> &arr,
                            MeshCore::MeshFacetArray &mFacets);

    //bool CorrectScale(double max_zVal);
    bool Visit(const MeshCore::MeshFacet &rclFacet, const MeshCore::MeshFacet &rclFrom, unsigned long ulFInd, unsigned long ulLevel);
        
    bool TransferFaceTriangulationtoFreeCAD(const TopoDS_Face& aFace, MeshCore::MeshKernel& TFaceMesh);
        
    std::vector< std::pair<unsigned long, double> > RegionEvaluate(const MeshCore::MeshKernel &mesh, std::vector<unsigned long> &RegionFacets, std::vector<Base::Vector3f> &normals);
    
    MeshCore::MeshKernel m_Mesh;
    MeshCore::MeshKernel m_Mesh_vis;
    MeshCore::MeshKernel m_Mesh_vis2;
    MeshCore::MeshKernel m_CadMesh;
    std::vector<Base::Vector3f> m_dist_vec;

private:

    TopoDS_Shape m_Shape;
    std::vector<double> m_CurvPos;
    std::vector<double> m_CurvNeg;
    std::vector<double> m_CurvMax;
    std::vector<EdgeStruct> m_EdgeStruct;
    std::vector<unsigned long> m_RingVector;
    std::vector< std::vector<unsigned long> > m_RegionVector;
    std::vector< std::vector<unsigned long> > m_Regions;
    //std::vector<MeshCore::MeshFacet> m_RegionBounds;
    CuttingToolsSettings m_set;
    int m_RingCurrent;
private:
    std::vector<MeshCore::MeshKernel> m_MeshVec;
    MeshCore::MeshKernel MeshRef;
    //MeshCore::MeshKernel m_Mesh2Fit;
    std::vector<Base::Vector3f> m_normals;
    std::vector<double> m_error;
    std::vector<double> m_FaceAng;
    std::vector<MeshPnt> m_MeshStruct;
    std::vector<double> m_Offset;
public:
    std::map<Base::Vector3f,MeshPnt,MeshPntLess > MeshMap;
    std::map<TopoDS_Edge, std::vector<double>, Edge_Less> EdgeMap;

    std::vector<TopoDS_Face> m_FixFaces;
};

#endif