FreeCAD / src /Mod /Mesh /App /Core /Helpers.h

Upload folder using huggingface_hub

985c397 verified 9 months ago

5.62 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

/***************************************************************************
 *   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_HELPERS_H
#define MESH_HELPERS_H

#include "Elements.h"


namespace MeshCore
{

/**
 * Helper class for points.
 */
struct MeshExport MeshHelpPoint
{
    inline void Set(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt);

    inline bool operator<(const MeshHelpPoint& rclObj) const;
    inline bool operator==(const MeshHelpPoint& rclObj) const;

    FacetIndex Index() const
    {
        return _ulInd >> 2;
    }

    FacetIndex Corner() const
    {
        return _ulInd & 3;
    }

    MeshPoint _clPt;
    FacetIndex _ulInd {FACET_INDEX_MAX};
};

/**
 * Helper class for list of points.
 */
struct MeshPointBuilder: public std::vector<MeshHelpPoint>
{
    inline void Add(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt);
};

/**
 * Helper class for edges.
 */
struct MeshExport MeshHelpBuilderEdge
{
    FacetIndex Side() const
    {
        return _ulFIndex & 3;
    }

    FacetIndex Index() const
    {
        return _ulFIndex >> 2;
    }

    inline void Set(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd);

    inline bool operator<(const MeshHelpBuilderEdge& rclObj) const;

    inline bool operator==(const MeshHelpBuilderEdge& rclObj) const;


    inline bool operator!=(const MeshHelpBuilderEdge& rclObj) const;

    FacetIndex _ulFIndex;   // facet index
    PointIndex _aulInd[2];  // point index
};

/**
 * Helper class to build up list of edges.
 */
struct MeshEdgeBuilder: public std::vector<MeshHelpBuilderEdge>
{
    using _TIterator = std::vector<MeshHelpBuilderEdge>::iterator;
    inline void Add(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd);
};

inline void MeshHelpPoint::Set(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt)
{
    _ulInd = (ulFacet << 2) | ulCorner;
    _clPt = rclPt;
}

inline bool MeshHelpPoint::operator<(const MeshHelpPoint& rclObj) const
{
    if (_clPt.x == rclObj._clPt.x) {
        if (_clPt.y == rclObj._clPt.y) {
            return _clPt.z < rclObj._clPt.z;
        }
        else {
            return _clPt.y < rclObj._clPt.y;
        }
    }
    else {
        return _clPt.x < rclObj._clPt.x;
    }
}

inline bool MeshHelpPoint::operator==(const MeshHelpPoint& rclObj) const
{
    return Base::DistanceP2(_clPt, rclObj._clPt) < MeshDefinitions::_fMinPointDistanceP2;
}

inline void MeshPointBuilder::Add(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt)
{
    MeshHelpPoint clObj;
    clObj.Set(ulCorner, ulFacet, rclPt);
    push_back(clObj);
}

inline void MeshHelpBuilderEdge::Set(
    PointIndex ulInd1,
    PointIndex ulInd2,
    FacetIndex ulSide,
    FacetIndex ulFInd
)
{
    if (ulInd1 < ulInd2) {
        _aulInd[0] = ulInd1;
        _aulInd[1] = ulInd2;
    }
    else {
        _aulInd[0] = ulInd2;
        _aulInd[1] = ulInd1;
    }
    _ulFIndex = (ulFInd << 2) | ulSide;
}

inline bool MeshHelpBuilderEdge::operator<(const MeshHelpBuilderEdge& rclObj) const
{
    if (_aulInd[0] == rclObj._aulInd[0]) {
        return _aulInd[1] < rclObj._aulInd[1];
    }
    else {
        return _aulInd[0] < rclObj._aulInd[0];
    }
}

inline bool MeshHelpBuilderEdge::operator==(const MeshHelpBuilderEdge& rclObj) const
{
    return (_aulInd[0] == rclObj._aulInd[0]) && (_aulInd[1] == rclObj._aulInd[1]);
}

inline bool MeshHelpBuilderEdge::operator!=(const MeshHelpBuilderEdge& rclObj) const
{
    return (_aulInd[0] != rclObj._aulInd[0]) || (_aulInd[1] != rclObj._aulInd[1]);
}


inline void MeshEdgeBuilder::Add(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd)
{
    MeshHelpBuilderEdge clObj {};
    clObj.Set(ulInd1, ulInd2, ulSide, ulFInd);
    push_back(clObj);
}

}  // namespace MeshCore

#endif  // MESH_HELPERS_H

	// SPDX-License-Identifier: LGPL-2.1-or-later

	/***************************************************************************
	* 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_HELPERS_H
	#define MESH_HELPERS_H

	#include "Elements.h"


	namespace MeshCore
	{

	/**
	* Helper class for points.
	*/
	struct MeshExport MeshHelpPoint
	{
	inline void Set(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt);

	inline bool operator<(const MeshHelpPoint& rclObj) const;
	inline bool operator==(const MeshHelpPoint& rclObj) const;

	FacetIndex Index() const
	{
	return _ulInd >> 2;
	}

	FacetIndex Corner() const
	{
	return _ulInd & 3;
	}

	MeshPoint _clPt;
	FacetIndex _ulInd {FACET_INDEX_MAX};
	};

	/**
	* Helper class for list of points.
	*/
	struct MeshPointBuilder: public std::vector<MeshHelpPoint>
	{
	inline void Add(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt);
	};

	/**
	* Helper class for edges.
	*/
	struct MeshExport MeshHelpBuilderEdge
	{
	FacetIndex Side() const
	{
	return _ulFIndex & 3;
	}

	FacetIndex Index() const
	{
	return _ulFIndex >> 2;
	}

	inline void Set(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd);

	inline bool operator<(const MeshHelpBuilderEdge& rclObj) const;

	inline bool operator==(const MeshHelpBuilderEdge& rclObj) const;


	inline bool operator!=(const MeshHelpBuilderEdge& rclObj) const;

	FacetIndex _ulFIndex; // facet index
	PointIndex _aulInd[2]; // point index
	};

	/**
	* Helper class to build up list of edges.
	*/
	struct MeshEdgeBuilder: public std::vector<MeshHelpBuilderEdge>
	{
	using _TIterator = std::vector<MeshHelpBuilderEdge>::iterator;
	inline void Add(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd);
	};

	inline void MeshHelpPoint::Set(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt)
	{
	_ulInd = (ulFacet << 2) \| ulCorner;
	_clPt = rclPt;
	}

	inline bool MeshHelpPoint::operator<(const MeshHelpPoint& rclObj) const
	{
	if (_clPt.x == rclObj._clPt.x) {
	if (_clPt.y == rclObj._clPt.y) {
	return _clPt.z < rclObj._clPt.z;
	}
	else {
	return _clPt.y < rclObj._clPt.y;
	}
	}
	else {
	return _clPt.x < rclObj._clPt.x;
	}
	}

	inline bool MeshHelpPoint::operator==(const MeshHelpPoint& rclObj) const
	{
	return Base::DistanceP2(_clPt, rclObj._clPt) < MeshDefinitions::_fMinPointDistanceP2;
	}

	inline void MeshPointBuilder::Add(FacetIndex ulCorner, FacetIndex ulFacet, const Base::Vector3f& rclPt)
	{
	MeshHelpPoint clObj;
	clObj.Set(ulCorner, ulFacet, rclPt);
	push_back(clObj);
	}

	inline void MeshHelpBuilderEdge::Set(
	PointIndex ulInd1,
	PointIndex ulInd2,
	FacetIndex ulSide,
	FacetIndex ulFInd
	)
	{
	if (ulInd1 < ulInd2) {
	_aulInd[0] = ulInd1;
	_aulInd[1] = ulInd2;
	}
	else {
	_aulInd[0] = ulInd2;
	_aulInd[1] = ulInd1;
	}
	_ulFIndex = (ulFInd << 2) \| ulSide;
	}

	inline bool MeshHelpBuilderEdge::operator<(const MeshHelpBuilderEdge& rclObj) const
	{
	if (_aulInd[0] == rclObj._aulInd[0]) {
	return _aulInd[1] < rclObj._aulInd[1];
	}
	else {
	return _aulInd[0] < rclObj._aulInd[0];
	}
	}

	inline bool MeshHelpBuilderEdge::operator==(const MeshHelpBuilderEdge& rclObj) const
	{
	return (_aulInd[0] == rclObj._aulInd[0]) && (_aulInd[1] == rclObj._aulInd[1]);
	}

	inline bool MeshHelpBuilderEdge::operator!=(const MeshHelpBuilderEdge& rclObj) const
	{
	return (_aulInd[0] != rclObj._aulInd[0]) \|\| (_aulInd[1] != rclObj._aulInd[1]);
	}


	inline void MeshEdgeBuilder::Add(PointIndex ulInd1, PointIndex ulInd2, FacetIndex ulSide, FacetIndex ulFInd)
	{
	MeshHelpBuilderEdge clObj {};
	clObj.Set(ulInd1, ulInd2, ulSide, ulFInd);
	push_back(clObj);
	}

	} // namespace MeshCore

	#endif // MESH_HELPERS_H