Common/Exchange/GCodeUtil.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//  Copyright (c) 2007 Celeritive Technologies, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------
#pragma once
#ifndef VOLUMILL_GCODEUTIL_H
#define VOLUMILL_GCODEUTIL_H

#include <Geom/Curve.h>
#include <Exchange/ToolpathRecords.h>
#include <fstream>
#include <vector>

namespace exchange
{
   struct GCodeRecordWriter : public boost::static_visitor<void>
   {
      GCodeRecordWriter (std::ostream& os, int digits, double rapidZ, double zOffset)
         : m_os (os), m_feedrate (0.0), m_shouldWriteFeedrate (true),
         m_lastPt (-1e30, -1e30, -1e30),
         m_rapidZ (rapidZ), m_zOffset (zOffset)
      {
         sprintf (m_format, "%%#.%d%s", digits, "lf");
         m_os.setf (std::ios::showpoint);
      }
      geom::Point2d getArcCenter (const geom::Point2d& startPt, const geom::Point2d& endPt, double radius)
      {
         geom::Vec2d dVec (endPt[0]-startPt[0], endPt[1]-startPt[1]);
         geom::Point2d midPt (0.5 * (startPt[0] + endPt[0]), 0.5 * (startPt[1] + endPt[1]));
         double d = geom::length (dVec);
         dVec /= d;
         double distToCenterSq = std::max (radius * radius - (d * d) / 4, 0.0);
         geom::Point2d center (midPt + sqrt (distToCenterSq) * geom::Vec2d (-dVec[1], dVec[0]));
         return center;
      }
      void operator() (const exchange::RapidMove& rm)
      {
         m_os << "G0";
         writeX (rm.m_endPt[0]);
         writeY (rm.m_endPt[1]);
         writeZ ((rm.m_endPt[2] - m_rapidZ) > util::pointResolution ? rm.m_endPt[2] - m_zOffset : rm.m_endPt[2]);
         m_os << '\n';
      }
      void operator() (const exchange::LinearMove& lm)
      {
         m_os << "G1";
         writeX (lm.m_endPt[0]);
         writeY (lm.m_endPt[1]);
         writeZ (lm.m_endPt[2] - m_zOffset);
         writeF (m_feedrate);
         m_os << '\n';
      }
      void operator() (const exchange::ArcCW& cwArc)
      {
         bool writeIJ = fabs (cwArc.m_endPt[2] - m_lastPt[2]) > 1e-5;
         if (writeIJ)
         {
            geom::Point2d center (getArcCenter (
               geom::Point2d (cwArc.m_endPt[0], cwArc.m_endPt[1]),
               geom::Point2d (m_lastPt[0], m_lastPt[1]),
               cwArc.m_radius));
            double i = center[0] - m_lastPt[0];
            if (fabs (i) < 1e-4)
               i = 0;
            double j = center[1] - m_lastPt[1];
            if (fabs (j) < 1e-4)
               j = 0;
            m_os << "G2";
            writeX (cwArc.m_endPt[0]);
            writeY (cwArc.m_endPt[1]);
            writeZ (cwArc.m_endPt[2] - m_zOffset);
            writeI (i);
            writeJ (j);
         }
         else
         {
            m_os << "G2";
            writeX (cwArc.m_endPt[0]);
            writeY (cwArc.m_endPt[1]);
            writeZ (cwArc.m_endPt[2] - m_zOffset);
            writeR (cwArc.m_radius);
         }
         writeF (m_feedrate);
         m_os << '\n';
      }
      void operator() (const exchange::ArcCCW& ccwArc)
      {
         bool writeIJ = fabs (ccwArc.m_endPt[2] - m_lastPt[2]) > 1e-5;
         if (writeIJ)
         {
            geom::Point2d center (getArcCenter (
               geom::Point2d (m_lastPt[0], m_lastPt[1]),
               geom::Point2d (ccwArc.m_endPt[0], ccwArc.m_endPt[1]),
               ccwArc.m_radius));
            double i = center[0] - m_lastPt[0];
            if (fabs (i) < 1e-4)
               i = 0;
            double j = center[1] - m_lastPt[1];
            if (fabs (j) < 1e-4)
               j = 0;
            m_os << "G3";
            writeX (ccwArc.m_endPt[0]);
            writeY (ccwArc.m_endPt[1]);
            writeZ (ccwArc.m_endPt[2] - m_zOffset);
            writeI (i);
            writeJ (j);
         }
         else
         {
            m_os << "G3";
            writeX (ccwArc.m_endPt[0]);
            writeY (ccwArc.m_endPt[1]);
            writeZ (ccwArc.m_endPt[2] - m_zOffset);
            writeR (ccwArc.m_radius);
         }
         writeF (m_feedrate);
         m_os << '\n';
      }
      void operator() (const exchange::FeedRate& fr)
      {
         if (fabs (m_feedrate - fr.m_feedrate) > 1e-5)
         {
            m_feedrate = fr.m_feedrate;
            m_shouldWriteFeedrate = true;
         }
      }
      void operator() (const exchange::Warning& w)
      {
         m_warningIds.push_back (w.m_warningId);
      }
      void operator() (const exchange::CustomRecord&)
      {
      }
      void writeDouble (double d)
      {
         char s[30];
         sprintf (s, m_format, d);
         // Remove trailing zeros
         int last = strlen (s) - 1;
         for (; last > 0 && s[last] == '0'; --last)
            s[last] = '\0';
         m_os << s;
      }
      void writeX (double x)
      {
         if (fabs (x - m_lastPt[0]) > 1e-5)
         {
            if (fabs (x) < 1e-4)
               x = 0;
            m_os << " X";
            writeDouble (x);
            m_lastPt[0] = x;
         }
      }
      void writeY (double y)
      {
         if (fabs (y - m_lastPt[1]) > 1e-5)
         {
            if (fabs (y) < 1e-4)
               y = 0;
            m_os << " Y";
            writeDouble (y);
            m_lastPt[1] = y;
         }
      }
      void writeZ (double z)
      {
         if (fabs (z - m_lastPt[2]) > 1e-5)
         {
            if (fabs (z) < 1e-4)
               z = 0;
            m_os << " Z";
            writeDouble (z);
            m_lastPt[2] = z;
         }
      }
      void writeI (double i)
      {
         m_os << " I";
         writeDouble (i);
      }
      void writeJ (double j)
      {
         m_os << " J";
         writeDouble (j);
      }
      void writeR (double r)
      {
         m_os << " R";
         writeDouble (r);
      }
      void writeF (double f)
      {
         if (m_shouldWriteFeedrate)
         {
            m_os << " F";
            writeDouble (f);
            m_shouldWriteFeedrate = false;
         }
      }
      geom::Point3d m_lastPt;
      bool m_shouldWriteFeedrate;
      double m_feedrate;
      std::ostream& m_os;
      char m_format[10];
      double m_rapidZ;
      double m_zOffset;
      std::vector<int> m_warningIds;
   };

class GCodeWriter
{
public:
   GCodeWriter (const exchange::ToolpathRecords& records, int digits) : m_records (records), m_digits (digits) {}
   void operator ()(const char* fileName, const std::string& startUp, const std::string& shutDown,
      double rapidZ, double deltaZ, int numberOfCuts)
   {
      std::ofstream os (fileName);
      os << startUp;

      for (int ii=0; ii < numberOfCuts; ++ii)
      {
         GCodeRecordWriter gcrw (os, m_digits, rapidZ, deltaZ * ii);
         for (ToolpathRecords::const_iterator it = m_records.begin(); it != m_records.end(); ++it)
            it->apply_visitor (gcrw);
         if (ii == 0)
            m_warningIds = gcrw.m_warningIds;
      }

      os << shutDown;
   }
   const std::vector<int>& getWarningIds() const { return m_warningIds; }
private:
   const exchange::ToolpathRecords& m_records;
   int m_digits;
   std::vector<int> m_warningIds;
};
}
#endif

---