/*************************************************************************** * Copyright (c) 2007 * * Human Rezaijafari * * This file is part of the FreeCAD CAM 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 Path_Simulate_h #define Path_Simulate_h #include #include #include #include "cutting_tools.h" #include //#include /*! \brief The main class for the path_simulate routine As it's input parameters it takes one respectively two vectors of B-Spline Curves (describing the Tool-Paths for the IBU-simulation), two values a_max and v_max of type double, which stands for the maximum allowable acceleration and velocity of the tool-movement and one value m_step of type double, specifying the step-length of the time-output-vector. As output, it gives one respectively two output-files for the simulation process containing a two-dimensional vector of time vs. velocity which describes the tool-movement. */ class CamExport path_simulate { public: /** @brief Constructor. @param BSplineTop vector of B-Spline-Curves describing the tool- paths of the master-tool @param BSplineBottom vector of B-Spline-Curves describing the tool- paths of the slave-tool @param set a struct which also includes the parameters a_max and v_max */ path_simulate(const std::vector& BSplineTop, const std::vector& BSplineBottom, struct CuttingToolsSettings& set); ~path_simulate(); /** @brief Computes all parameters of the velocity-function for the tool movement along a straight line. @param wirelength length of the straight line */ bool ParameterCalculation_Line(double wirelength); /** @brief Computes all parameters of the velocity-function for the tool movement along a curve-segment. @param wirelength arc-length of the curve-segment */ bool ParameterCalculation_Curve(double wirelength); /** @brief Computes output for the connection-part in xy-direction @param outputstyle false: simulation, true: robot */ bool ConnectPaths_xy(bool outputstyle); /** @brief Computes output for the connection-part in z-direction @param outputstyle false: simulation, true: robot */ bool ConnectPaths_z(bool outputstyle); /** @brief Computes output for the connection-part in all directions for the feature-based-strategy @param tool false: master true: slave @param robo defines outputstyle (false: simulation true: robot) @param connection_type false: in 3-steps true: in 2-steps */ bool ConnectPaths_Feat(bool tool, bool robo, bool connection_type); /** @brief Updates actual parameter sets */ bool UpdateParam(); /** @brief Writes output-vectors to file for the feature-based-strategy @param anOutputFile_1 output-file for the master @param anOutputFile_2 output-file for the slave @param c startindex of the curve-id @param outputstyle false: simulation, true: robot */ bool WriteOutput_Feat(ofstream &anOutputFile_1, ofstream &anOutputFile_2, int &c, bool outputstyle); ///** @brief Write start- and endtime for one tool-path-run (master & slave) */ // bool WriteTimes(); /** @brief Writes output-vectors to file @param anOutputFile output-file @param c @param outputstyle false: simulation, true: robot @param tool false: master, true: slave @param beamfl specifies an additional outputvalue which determines the waiting-status of the tool movement \todo undocumented parameter c */ bool WriteOutputSingle(ofstream &anOutputFile, int &c, bool outputstyle, bool tool, bool beamfl); /** @brief Writes output-vectors to file @param anOutputFile_1 output-file for the master @param nOutputFile_2 output-file for the slave @param c1 startindex of the curve-id for the master @param c2 startindex of the curve-id for the slave @param outputstyle false: simulation, true: robot @param beamfl specifies an additional outputvalue using spring-pretension */ bool WriteOutputDouble(ofstream &anOutputFile_1,ofstream &nOutputFile_2, int &c1, int &c2, bool outputstyle,bool beamfl); /** @brief Main routine for creating the simulation output for a single curve, including the synchronisation of master and slave
CompPath() must have been called before using this function */ bool Gen_Path(); /** @brief Creates outputvectors for the simulation outputfor a single curve @param outputstyle false: simulation, true: robot @param length defines length of the path @param part tells us that we are generating output for a critical part of the curve or not @param curveType \todo undocumented parameter curveType */ bool MakePathSingle(bool outputstyle, double length, bool part, bool curveType); /** @brief Main function of the output-generation for the simulation using the standard-strategy */ bool MakePathSimulate(); /** @brief Main function of the output-generation for the simulation using the feature-based or spiral-based strategy @param flatAreas index-vector specifying the flat areas @param spiral specifies the strategy (true: spiral-based, false: feature-based) */ bool MakePathSimulate_Feat(const std::vector &flatAreas, bool spiral); /** @brief Main function of the output-generation for the robot using the standard-strategy*/ bool MakePathRobot(); /** @brief Main function of the output-generation for the robot using the feature-based-strategy */ bool MakePathRobot_Feat(const std::vector &flatAreas); /** @brief computes path-correction after a tool-path-run @param b false: master, true: slave */ bool Correction(bool b); /** @brief Adds additional time-values to the output-vector of the waiting tool for synchronisation */ bool TimeCorrection(); /** @brief Returns the next curve-index for the feature-based-strategy */ int Detect_FeatCurve(bool tool); private: /** @brief curve-vector for the master-tool*/ std::vector m_BSplineTop; /** @brief curve-vector for the slave-tool*/ std::vector m_BSplineBottom; /** @brief actual start-point for the connection-part*/ std::vector m_StartPnts1; /** @brief actual end-point for the connection-part*/ std::vector m_StartPnts2; // Base::Builder3D m_log; /** @brief output-vector for the master including velocity-values for the simulation-process */ std::vector< std::vector > m_Output; /** @brief output-vector for the slave including velocity-values for the simulation-process*/ std::vector< std::vector > m_Output2; /** @brief output-vector for the master including a point-set for the robot*/ std::vector m_Output_robo1; /** @brief output-vector for the slave including a point-set for the robot*/ std::vector m_Output_robo2; /** @brief additional output-vector of the master-tool for the robot output including values 0 and 1 */ std::vector RoboFlag_Master; /** @brief additional output-vector of the slave-tool for the robot output including values 0 and 1 */ std::vector RoboFlag_Slave; /** @brief output-vector for the master including a time-set conform to m_Output respectively m_Output_robo1*/ std::vector m_Output_time; /** @brief output-vector for the slave including a time-set conform to m_Output2 respectively m_Output_robo2*/ std::vector m_Output_time2; /** @brief timestep for the simulation-output*/ double m_step; /** @brief pointing to the knot-vector of the current B-spline Curve*/ TColStd_Array1OfReal *m_Knots; /** @brief maximum curvature of current curve*/ double m_curMax; /** @brief external setting-parameters*/ CuttingToolsSettings m_set; /** @brief iterator for the master-curves*/ std::vector::iterator m_it1; /* iterator über inner-paths */ /** @brief iterator for the slave-curves*/ std::vector::iterator m_it2; /* iterator über outer-paths */ /** @brief sheet-thickness */ double m_blech; /** @brief spring-pretension*/ double m_pretension; /** @brief maximum number of output-values per file*/ int m_clip; /** @brief flag specifies if spring-pretension is used or not*/ bool beam; /** @brief flag specifying the used forming-strategy*/ bool m_single; /** @brief flag specifying moving-direction (clockwise vs. anticlockwise) */ bool m_dir; /** @brief vector in which the lengths of the separated curve-segments for the master-tool are stored*/ std::vector > m_length_ma; /** @brief vector in which the lengths of the separated curve-segments for the slave-tool are stored*/ std::vector > m_length_sl; /** @brief vector of acceleration-values regarding to the separated curve segments for the master-tool*/ std::vector > m_accel_ma; /** @brief vector of acceleration-values regarding to the separated curve segments for the slave-tool*/ std::vector > m_accel_sl; /** @brief Matrix of three velocity-values regarding to the curves and curve-segments for the master-tool*/ std::vector > > m_velocity_ma; /** @brief Matrix of three velocity-values regarding to the curves and curve-segments for the slave-tool*/ std::vector > > m_velocity_sl; /** @brief maximum allowable resulting velocity of the tool*/ double m_vmax; /** @brief maximum allowable resulting acceleration of the tool*/ double m_amax; /** @brief pathtolerance which is set (in subject to m_vmax and m_amax) before and after a critical region*/ double m_boundTol; /** @brief acceleration-parameter used in GetVelocity() and GetDistance() */ double m_a; /** @brief three-dimensional vector containing start-, maximum- and end- velocity used in GetVelocity() and GetDistance()*/ double m_v[3]; /** @brief parameter of the velocity-function */ double m_vmid; /** @brief initial start-parameter for the current master- and slave- curves*/ std::vector m_StartParam; /** @brief timeparameter of the velocity-function*/ double m_t0; /** @brief timeparameter of the velocity-function*/ double m_t1; /** @brief timeparameter of the velocity-function*/ double m_t2; /** @brief timeparameter of the velocity-function*/ double m_T; /** @brief timeparameter of the velocity-function*/ double m_del_t; /* t_0 - starttime, T - endtime, del_t - timestep */ /** @brief returns absolute velocity at the time-value t */ double GetVelocity(double time); /** @brief returns arc-length of the current tool-path at the time-value t*/ double GetDistance(double t); /** @brief determines connection-strategy for both tools*/ bool CheckConnect(); /** @brief determines connection-strategy for the specified tool @param tool false: master, true: slave */ bool CheckConnect(bool tool); /** @brief determines critical bounds of the current curve for the specified tool @param tool false: master, true: slave @param knots \todo undocumented parameter knots */ std::vector > CompBounds(bool tool, std::vector knots); /** @brief Generates output for the current tool-path*/ bool CompPath(bool tool); /** @brief determines which tool should wait (feature-based-stategy only)*/ bool StartingTool(); /** @brief vector containing start- and end-times for the master-curves*/ std::vector > m_PathTimes_Master; /** @brief vector containing start- and end-times for the slave-curves*/ std::vector > m_PathTimes_Slave; // std::vector m_times_tmp; // std::vector m_velo_tmp; /** @brief flag specifying current connection-type*/ bool m_conn; /** @brief flag specifying if a feature-based-strategy is used*/ bool m_Feat; }; #endif //Path_Simulate_h