path_simulate.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2007                                                    *
 *   Human Rezaijafari <H.Rezai@web.de>                                    *
 *   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 <Base/Vector3D.h>
#include <Base/Builder3D.h>
#include <TColStd_Array1OfReal.hxx>
#include "cutting_tools.h"
#include <sstream>

//#include <Base/Builder3D.h>

class CamExport path_simulate
{
public:

    path_simulate(const std::vector<Handle_Geom_BSplineCurve>& BSplineTop,
                  const std::vector<Handle_Geom_BSplineCurve>& BSplineBottom,
                  struct CuttingToolsSettings& set);
    ~path_simulate();

    bool ParameterCalculation_Line(double wirelength);

    bool ParameterCalculation_Curve(double wirelength);

    bool ConnectPaths_xy(bool outputstyle);

    bool ConnectPaths_z(bool outputstyle);

    bool ConnectPaths_Feat(bool tool, bool robo, bool connection_type);

    bool UpdateParam();

    bool WriteOutput_Feat(ofstream &anOutputFile_1, ofstream &anOutputFile_2, int &c, bool outputstyle);

    // bool WriteTimes();

    bool WriteOutputSingle(ofstream &anOutputFile, int &c, bool outputstyle, bool tool, bool beamfl);

    bool WriteOutputDouble(ofstream &anOutputFile_1,ofstream &nOutputFile_2, int &c1, int &c2, bool outputstyle,bool beamfl);
    
    bool Gen_Path();
    
    bool MakePathSingle(bool outputstyle, double length, bool part, bool curveType);

    bool MakePathSimulate();

    bool MakePathSimulate_Feat(const std::vector<float> &flatAreas, bool spiral);

    bool MakePathRobot();

    bool MakePathRobot_Feat(const std::vector<float> &flatAreas);

    bool Correction(bool b);

    bool TimeCorrection();

    int  Detect_FeatCurve(bool tool);

private:
    std::vector<Handle_Geom_BSplineCurve> m_BSplineTop;
    std::vector<Handle_Geom_BSplineCurve> m_BSplineBottom;
    std::vector<gp_Pnt> m_StartPnts1;
    std::vector<gp_Pnt> m_StartPnts2;

    // Base::Builder3D m_log;
    
    std::vector< std::vector<Base::Vector3d> > m_Output;
    std::vector< std::vector<Base::Vector3d> > m_Output2;
    std::vector<Base::Vector3d> m_Output_robo1;
    std::vector<Base::Vector3d> m_Output_robo2;
    std::vector<int> RoboFlag_Master;
    std::vector<int> RoboFlag_Slave;
    std::vector<double> m_Output_time;
    std::vector<double> m_Output_time2;
    double m_step;
    TColStd_Array1OfReal *m_Knots;
    double m_curMax;
    CuttingToolsSettings m_set;

    std::vector<Handle_Geom_BSplineCurve>::iterator m_it1;   /* iterator über inner-paths */
    std::vector<Handle_Geom_BSplineCurve>::iterator m_it2;   /* iterator über outer-paths */
    double m_blech;
    double m_pretension;
    int  m_clip;
    bool beam;
    bool m_single;
    bool m_dir;
    std::vector<std::vector<double> > m_length_ma;
    std::vector<std::vector<double> > m_length_sl;
    std::vector<std::vector<double> > m_accel_ma;
    std::vector<std::vector<double> > m_accel_sl;
    std::vector<std::vector<std::vector<double> > > m_velocity_ma;
    std::vector<std::vector<std::vector<double> > > m_velocity_sl;
    double m_vmax;
    double m_amax;
    double m_boundTol;
    double m_a;
    double m_v[3];
    double m_vmid;
    std::vector<double> m_StartParam;
    double m_t0;
    double m_t1;
    double m_t2;
    double m_T;
    double m_del_t;  /* t_0 - starttime, T - endtime, del_t - timestep */
    double GetVelocity(double time);
    double GetDistance(double t);
    bool CheckConnect();
    bool CheckConnect(bool tool);
    std::vector<std::vector<double> > CompBounds(bool tool, std::vector<double> knots);
    bool CompPath(bool tool);
    bool StartingTool();
    std::vector<std::pair<float,float> > m_PathTimes_Master;
    std::vector<std::pair<float,float> > m_PathTimes_Slave;
    
        // std::vector<double> m_times_tmp;
        // std::vector<double> m_velo_tmp;
    
    bool m_conn;
    bool m_Feat;
};


#endif //Path_Simulate_h