FreeCAD / src /Mod /CAM /libarea /Adaptive.hpp

Upload folder using huggingface_hub

985c397 verified 9 months ago

7.9 kB

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

/**************************************************************************
 *   Copyright (c) 2018 Kresimir Tusek <kresimir.tusek@gmail.com>          *
 *                                                                         *
 *   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                                *
 *                                                                         *
 ***************************************************************************/

#include "clipper.hpp"
#include <vector>
#include <list>
#include <time.h>

#ifndef ADAPTIVE_HPP
# define ADAPTIVE_HPP

# ifndef __DBL_MAX__
#  define __DBL_MAX__ 1.7976931348623158e+308
# endif

# ifndef __LONG_MAX__
#  define __LONG_MAX__ 2147483647
# endif

// #define DEV_MODE

# define NTOL 1.0e-7  // numeric tolerance

namespace AdaptivePath
{
using namespace ClipperLib;

enum MotionType
{
    mtCutting = 0,
    mtLinkClear = 1,
    mtLinkNotClear = 2,
    mtLinkClearAtPrevPass = 3
};

enum OperationType
{
    otClearingInside = 0,
    otClearingOutside = 1,
    otProfilingInside = 2,
    otProfilingOutside = 3
};

typedef std::pair<double, double> DPoint;
typedef std::vector<DPoint> DPath;
typedef std::vector<DPath> DPaths;
typedef std::pair<int, DPath> TPath;  // first parameter is MotionType, must use int due to problem
                                      // with serialization to JSON in python

class ClearedArea;

typedef std::vector<TPath> TPaths;

struct AdaptiveOutput
{
    DPoint HelixCenterPoint;
    DPoint StartPoint;
    TPaths AdaptivePaths;
    int ReturnMotionType;  // MotionType enum, problem with serialization if enum is used
};

// used to isolate state -> enable potential adding of multi-threaded processing of separate regions

class Adaptive2d
{
public:
    Adaptive2d();
    double toolDiameter = 5;
    double helixRampTargetDiameter = 0;
    double helixRampMinDiameter = 0;
    double stepOverFactor = 0.2;
    double tolerance = 0.1;
    double stockToLeave = 0;
    bool forceInsideOut = true;
    bool finishingProfile = true;
    double keepToolDownDistRatio = 3.0;  // keep tool down distance ratio
    OperationType opType = OperationType::otClearingInside;

    std::list<AdaptiveOutput> Execute(
        const DPaths& stockPaths,
        const DPaths& paths,
        std::function<bool(TPaths)> progressCallbackFn
    );

# ifdef DEV_MODE
    /*for debugging*/
    std::function<void(double cx, double cy, double radius, int color)> DrawCircleFn;
    std::function<void(const DPath&, int color)> DrawPathFn;
    std::function<void()> ClearScreenFn;
# endif

private:
    std::list<AdaptiveOutput> results;
    Paths inputPaths;
    Paths stockInputPaths;
    int polyTreeNestingLimit = 0;
    long scaleFactor = 100;
    double stepOverScaled = 1;
    long toolRadiusScaled = 10;
    long finishPassOffsetScaled = 0;
    long helixRampMaxRadiusScaled = 0;
    long helixRampMinRadiusScaled = 0;
    double referenceCutArea = 0;
    double optimalCutAreaPD = 0;
    bool stopProcessing = false;
    int current_region = 0;
    clock_t lastProgressTime = 0;

    std::function<bool(TPaths)>* progressCallback = NULL;
    Path toolGeometry;  // tool geometry at coord 0,0, should not be modified

    void ProcessPolyNode(Paths boundPaths, Paths toolBoundPaths);
    bool FindEntryPoint(
        TPaths& progressPaths,
        const Paths& toolBoundPaths,
        const Paths& bound,
        ClearedArea& cleared /*output*/,
        IntPoint& entryPoint /*output*/,
        IntPoint& toolPos,
        DoublePoint& toolDir,
        long& helixRadiusScaled
    );
    bool FindEntryPointOutside(
        TPaths& progressPaths,
        const Paths& toolBoundPaths,
        const Paths& bound,
        ClearedArea& cleared /*output*/,
        IntPoint& entryPoint /*output*/,
        IntPoint& toolPos,
        DoublePoint& toolDir
    );
    double CalcCutArea(
        Clipper& clip,
        const IntPoint& toolPos,
        const IntPoint& newToolPos,
        ClearedArea& clearedArea,
        bool preventConventionalMode = true
    );
    void AppendToolPath(
        TPaths& progressPaths,
        AdaptiveOutput& output,
        const Path& passToolPath,
        ClearedArea& clearedAreaBefore,
        ClearedArea& clearedAreaAfter,
        const Paths& toolBoundPaths
    );
    bool IsClearPath(const Path& path, ClearedArea& clearedArea, double safetyDistanceScaled = 0);
    bool IsAllowedToCutTrough(
        const IntPoint& p1,
        const IntPoint& p2,
        ClearedArea& clearedArea,
        const Paths& toolBoundPaths,
        double areaFactor = 1.5,
        bool skipBoundsCheck = false
    );
    bool MakeLeadPath(
        bool leadIn,
        const IntPoint& startPoint,
        const DoublePoint& startDir,
        const IntPoint& beaconPoint,
        ClearedArea& clearedArea,
        const Paths& toolBoundPaths,
        Path& output
    );

    bool ResolveLinkPath(
        const IntPoint& startPoint,
        const IntPoint& endPoint,
        ClearedArea& clearedArea,
        Path& output
    );

    friend class EngagePoint;  // for CalcCutArea

    void CheckReportProgress(TPaths& progressPaths, bool force = false);
    void AddPathsToProgress(
        TPaths& progressPaths,
        const Paths paths,
        MotionType mt = MotionType::mtCutting
    );
    void AddPathToProgress(TPaths& progressPaths, const Path pth, MotionType mt = MotionType::mtCutting);
    void ApplyStockToLeave(Paths& inputPaths);

private:  // constants for fine tuning
    const double MIN_STEP_CLIPPER = 16.0;
    const int MAX_ITERATIONS = 10;
    const double AREA_ERROR_FACTOR = 0.05;     /* how precise to match the cut area to optimal,
                                                  reasonable value: 0.05 = 5%*/
    const size_t ANGLE_HISTORY_POINTS = 3;     // used for angle prediction
    const int DIRECTION_SMOOTHING_BUFLEN = 3;  // gyro points - used for angle smoothing


    const double MIN_CUT_AREA_FACTOR = 0.1
        * 16;  // used for filtering out of insignificant cuts (should be < ENGAGE_AREA_THR_FACTOR)
    const double ENGAGE_AREA_THR_FACTOR = 0.5 * 16;  // influences minimal engage area
    const double ENGAGE_SCAN_DISTANCE_FACTOR = 0.2;  // influences the engage scan/stepping distance

    const double CLEAN_PATH_TOLERANCE = 1.41;            // should be >1
    const double FINISHING_CLEAN_PATH_TOLERANCE = 1.41;  // should be >1

    const long PASSES_LIMIT = __LONG_MAX__;              // limit used while debugging
    const long POINTS_PER_PASS_LIMIT = __LONG_MAX__;     // limit used while debugging
    const clock_t PROGRESS_TICKS = CLOCKS_PER_SEC / 10;  // progress report interval
};
}  // namespace AdaptivePath
#endif

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

	/**************************************************************************
	* Copyright (c) 2018 Kresimir Tusek <kresimir.tusek@gmail.com> *
	* *
	* 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 *
	* *
	***************************************************************************/

	#include "clipper.hpp"
	#include <vector>
	#include <list>
	#include <time.h>

	#ifndef ADAPTIVE_HPP
	# define ADAPTIVE_HPP

	# ifndef __DBL_MAX__
	# define __DBL_MAX__ 1.7976931348623158e+308
	# endif

	# ifndef __LONG_MAX__
	# define __LONG_MAX__ 2147483647
	# endif

	// #define DEV_MODE

	# define NTOL 1.0e-7 // numeric tolerance

	namespace AdaptivePath
	{
	using namespace ClipperLib;

	enum MotionType
	{
	mtCutting = 0,
	mtLinkClear = 1,
	mtLinkNotClear = 2,
	mtLinkClearAtPrevPass = 3
	};

	enum OperationType
	{
	otClearingInside = 0,
	otClearingOutside = 1,
	otProfilingInside = 2,
	otProfilingOutside = 3
	};

	typedef std::pair<double, double> DPoint;
	typedef std::vector<DPoint> DPath;
	typedef std::vector<DPath> DPaths;
	typedef std::pair<int, DPath> TPath; // first parameter is MotionType, must use int due to problem
	// with serialization to JSON in python

	class ClearedArea;

	typedef std::vector<TPath> TPaths;

	struct AdaptiveOutput
	{
	DPoint HelixCenterPoint;
	DPoint StartPoint;
	TPaths AdaptivePaths;
	int ReturnMotionType; // MotionType enum, problem with serialization if enum is used
	};

	// used to isolate state -> enable potential adding of multi-threaded processing of separate regions

	class Adaptive2d
	{
	public:
	Adaptive2d();
	double toolDiameter = 5;
	double helixRampTargetDiameter = 0;
	double helixRampMinDiameter = 0;
	double stepOverFactor = 0.2;
	double tolerance = 0.1;
	double stockToLeave = 0;
	bool forceInsideOut = true;
	bool finishingProfile = true;
	double keepToolDownDistRatio = 3.0; // keep tool down distance ratio
	OperationType opType = OperationType::otClearingInside;

	std::list<AdaptiveOutput> Execute(
	const DPaths& stockPaths,
	const DPaths& paths,
	std::function<bool(TPaths)> progressCallbackFn
	);

	# ifdef DEV_MODE
	/for debugging/
	std::function<void(double cx, double cy, double radius, int color)> DrawCircleFn;
	std::function<void(const DPath&, int color)> DrawPathFn;
	std::function<void()> ClearScreenFn;
	# endif

	private:
	std::list<AdaptiveOutput> results;
	Paths inputPaths;
	Paths stockInputPaths;
	int polyTreeNestingLimit = 0;
	long scaleFactor = 100;
	double stepOverScaled = 1;
	long toolRadiusScaled = 10;
	long finishPassOffsetScaled = 0;
	long helixRampMaxRadiusScaled = 0;
	long helixRampMinRadiusScaled = 0;
	double referenceCutArea = 0;
	double optimalCutAreaPD = 0;
	bool stopProcessing = false;
	int current_region = 0;
	clock_t lastProgressTime = 0;

	std::function<bool(TPaths)>* progressCallback = NULL;
	Path toolGeometry; // tool geometry at coord 0,0, should not be modified

	void ProcessPolyNode(Paths boundPaths, Paths toolBoundPaths);
	bool FindEntryPoint(
	TPaths& progressPaths,
	const Paths& toolBoundPaths,
	const Paths& bound,
	ClearedArea& cleared /output/,
	IntPoint& entryPoint /output/,
	IntPoint& toolPos,
	DoublePoint& toolDir,
	long& helixRadiusScaled
	);
	bool FindEntryPointOutside(
	TPaths& progressPaths,
	const Paths& toolBoundPaths,
	const Paths& bound,
	ClearedArea& cleared /output/,
	IntPoint& entryPoint /output/,
	IntPoint& toolPos,
	DoublePoint& toolDir
	);
	double CalcCutArea(
	Clipper& clip,
	const IntPoint& toolPos,
	const IntPoint& newToolPos,
	ClearedArea& clearedArea,
	bool preventConventionalMode = true
	);
	void AppendToolPath(
	TPaths& progressPaths,
	AdaptiveOutput& output,
	const Path& passToolPath,
	ClearedArea& clearedAreaBefore,
	ClearedArea& clearedAreaAfter,
	const Paths& toolBoundPaths
	);
	bool IsClearPath(const Path& path, ClearedArea& clearedArea, double safetyDistanceScaled = 0);
	bool IsAllowedToCutTrough(
	const IntPoint& p1,
	const IntPoint& p2,
	ClearedArea& clearedArea,
	const Paths& toolBoundPaths,
	double areaFactor = 1.5,
	bool skipBoundsCheck = false
	);
	bool MakeLeadPath(
	bool leadIn,
	const IntPoint& startPoint,
	const DoublePoint& startDir,
	const IntPoint& beaconPoint,
	ClearedArea& clearedArea,
	const Paths& toolBoundPaths,
	Path& output
	);

	bool ResolveLinkPath(
	const IntPoint& startPoint,
	const IntPoint& endPoint,
	ClearedArea& clearedArea,
	Path& output
	);

	friend class EngagePoint; // for CalcCutArea

	void CheckReportProgress(TPaths& progressPaths, bool force = false);
	void AddPathsToProgress(
	TPaths& progressPaths,
	const Paths paths,
	MotionType mt = MotionType::mtCutting
	);
	void AddPathToProgress(TPaths& progressPaths, const Path pth, MotionType mt = MotionType::mtCutting);
	void ApplyStockToLeave(Paths& inputPaths);

	private: // constants for fine tuning
	const double MIN_STEP_CLIPPER = 16.0;
	const int MAX_ITERATIONS = 10;
	const double AREA_ERROR_FACTOR = 0.05; /* how precise to match the cut area to optimal,
	reasonable value: 0.05 = 5%*/
	const size_t ANGLE_HISTORY_POINTS = 3; // used for angle prediction
	const int DIRECTION_SMOOTHING_BUFLEN = 3; // gyro points - used for angle smoothing


	const double MIN_CUT_AREA_FACTOR = 0.1
	* 16; // used for filtering out of insignificant cuts (should be < ENGAGE_AREA_THR_FACTOR)
	const double ENGAGE_AREA_THR_FACTOR = 0.5 * 16; // influences minimal engage area
	const double ENGAGE_SCAN_DISTANCE_FACTOR = 0.2; // influences the engage scan/stepping distance

	const double CLEAN_PATH_TOLERANCE = 1.41; // should be >1
	const double FINISHING_CLEAN_PATH_TOLERANCE = 1.41; // should be >1

	const long PASSES_LIMIT = __LONG_MAX__; // limit used while debugging
	const long POINTS_PER_PASS_LIMIT = __LONG_MAX__; // limit used while debugging
	const clock_t PROGRESS_TICKS = CLOCKS_PER_SEC / 10; // progress report interval
	};
	} // namespace AdaptivePath
	#endif