303 lines
8.9 KiB
C++
303 lines
8.9 KiB
C++
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
/***************************************************************************
|
|
* Copyright (c) 2010 Jürgen Riegel <juergen.riegel@web.de> *
|
|
* *
|
|
* 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 <Base/PlacementPy.h>
|
|
#include <Base/PyWrapParseTupleAndKeywords.h>
|
|
#include <Base/UnitsApi.h>
|
|
|
|
// clang-format off
|
|
// inclusion of the generated files (generated out of WaypointPy.xml)
|
|
#include "WaypointPy.h"
|
|
#include "WaypointPy.cpp"
|
|
// clang-format on
|
|
|
|
|
|
using namespace Robot;
|
|
using namespace Base;
|
|
|
|
// returns a string which represents the object e.g. when printed in python
|
|
std::string WaypointPy::representation() const
|
|
{
|
|
double A, B, C;
|
|
std::stringstream str;
|
|
getWaypointPtr()->EndPos.getRotation().getYawPitchRoll(A, B, C);
|
|
str.precision(5);
|
|
str << "Waypoint [";
|
|
if (getWaypointPtr()->Type == Waypoint::PTP) {
|
|
str << "PTP ";
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::LINE) {
|
|
str << "LIN ";
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::CIRC) {
|
|
str << "CIRC ";
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::WAIT) {
|
|
str << "WAIT ";
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::UNDEF) {
|
|
str << "UNDEF ";
|
|
}
|
|
str << getWaypointPtr()->Name;
|
|
str << " (";
|
|
str << getWaypointPtr()->EndPos.getPosition().x << ","
|
|
<< getWaypointPtr()->EndPos.getPosition().y << ","
|
|
<< getWaypointPtr()->EndPos.getPosition().z;
|
|
str << ";" << A << "," << B << "," << C << ")";
|
|
str << "v=" << getWaypointPtr()->Velocity << " ";
|
|
if (getWaypointPtr()->Cont) {
|
|
str << "Cont ";
|
|
}
|
|
if (getWaypointPtr()->Tool != 0) {
|
|
str << "Tool" << getWaypointPtr()->Tool << " ";
|
|
}
|
|
if (getWaypointPtr()->Base != 0) {
|
|
str << "Tool" << getWaypointPtr()->Base << " ";
|
|
}
|
|
str << "]";
|
|
|
|
return str.str();
|
|
}
|
|
|
|
PyObject* WaypointPy::PyMake(struct _typeobject*, PyObject*, PyObject*) // Python wrapper
|
|
{
|
|
// create a new instance of WaypointPy and the Twin object
|
|
return new WaypointPy(new Waypoint);
|
|
}
|
|
|
|
// constructor method
|
|
int WaypointPy::PyInit(PyObject* args, PyObject* kwd)
|
|
{
|
|
PyObject* pos;
|
|
const char* name = "P";
|
|
const char* type = "PTP";
|
|
PyObject* vel = nullptr;
|
|
PyObject* acc = nullptr;
|
|
int cont = 0;
|
|
int tool = 0;
|
|
int base = 0;
|
|
|
|
static const std::array<const char*, 9>
|
|
kwlist {"Pos", "type", "name", "vel", "cont", "tool", "base", "acc", nullptr};
|
|
|
|
if (!Base::Wrapped_ParseTupleAndKeywords(
|
|
args,
|
|
kwd,
|
|
"O!|ssOiiiO",
|
|
kwlist,
|
|
&(Base::PlacementPy::Type),
|
|
&pos, // the placement object
|
|
&type,
|
|
&name,
|
|
&vel,
|
|
&cont,
|
|
&tool,
|
|
&base,
|
|
&acc
|
|
)) {
|
|
return -1;
|
|
}
|
|
|
|
Base::Placement TempPos = *static_cast<Base::PlacementPy*>(pos)->getPlacementPtr();
|
|
getWaypointPtr()->EndPos = TempPos;
|
|
getWaypointPtr()->Name = name;
|
|
std::string typeStr(type);
|
|
if (typeStr == "PTP") {
|
|
getWaypointPtr()->Type = Waypoint::PTP;
|
|
}
|
|
else if (typeStr == "LIN") {
|
|
getWaypointPtr()->Type = Waypoint::LINE;
|
|
}
|
|
else if (typeStr == "CIRC") {
|
|
getWaypointPtr()->Type = Waypoint::CIRC;
|
|
}
|
|
else if (typeStr == "WAIT") {
|
|
getWaypointPtr()->Type = Waypoint::WAIT;
|
|
}
|
|
else {
|
|
getWaypointPtr()->Type = Waypoint::UNDEF;
|
|
}
|
|
|
|
if (!vel) {
|
|
switch (getWaypointPtr()->Type) {
|
|
case Waypoint::PTP:
|
|
getWaypointPtr()->Velocity = 100;
|
|
break;
|
|
case Waypoint::LINE:
|
|
getWaypointPtr()->Velocity = 2000;
|
|
break;
|
|
case Waypoint::CIRC:
|
|
getWaypointPtr()->Velocity = 2000;
|
|
break;
|
|
default:
|
|
getWaypointPtr()->Velocity = 0;
|
|
}
|
|
}
|
|
else {
|
|
getWaypointPtr()->Velocity = Base::UnitsApi::toDouble(vel, Base::Unit::Velocity);
|
|
}
|
|
getWaypointPtr()->Cont = cont ? true : false;
|
|
getWaypointPtr()->Tool = tool;
|
|
getWaypointPtr()->Base = base;
|
|
if (!acc) {
|
|
getWaypointPtr()->Acceleration = 100;
|
|
}
|
|
else {
|
|
getWaypointPtr()->Acceleration = Base::UnitsApi::toDouble(acc, Base::Unit::Acceleration);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
Py::Float WaypointPy::getVelocity() const
|
|
{
|
|
return Py::Float(getWaypointPtr()->Velocity);
|
|
}
|
|
|
|
void WaypointPy::setVelocity(Py::Float arg)
|
|
{
|
|
getWaypointPtr()->Velocity = (float)arg.operator double();
|
|
}
|
|
|
|
|
|
Py::String WaypointPy::getName() const
|
|
{
|
|
return {getWaypointPtr()->Name};
|
|
}
|
|
|
|
void WaypointPy::setName(Py::String arg)
|
|
{
|
|
getWaypointPtr()->Name = arg.as_std_string("ascii");
|
|
}
|
|
|
|
Py::String WaypointPy::getType() const
|
|
{
|
|
if (getWaypointPtr()->Type == Waypoint::PTP) {
|
|
return Py::String("PTP");
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::LINE) {
|
|
return Py::String("LIN");
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::CIRC) {
|
|
return Py::String("CIRC");
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::WAIT) {
|
|
return Py::String("WAIT");
|
|
}
|
|
else if (getWaypointPtr()->Type == Waypoint::UNDEF) {
|
|
return Py::String("UNDEF");
|
|
}
|
|
else {
|
|
throw Base::TypeError("Unknown waypoint type! Only: PTP,LIN,CIRC,WAIT are supported.");
|
|
}
|
|
}
|
|
|
|
void WaypointPy::setType(Py::String arg)
|
|
{
|
|
std::string typeStr(arg.as_std_string("ascii"));
|
|
if (typeStr == "PTP") {
|
|
getWaypointPtr()->Type = Waypoint::PTP;
|
|
}
|
|
else if (typeStr == "LIN") {
|
|
getWaypointPtr()->Type = Waypoint::LINE;
|
|
}
|
|
else if (typeStr == "CIRC") {
|
|
getWaypointPtr()->Type = Waypoint::CIRC;
|
|
}
|
|
else if (typeStr == "WAIT") {
|
|
getWaypointPtr()->Type = Waypoint::WAIT;
|
|
}
|
|
else {
|
|
throw Base::TypeError("Unknown waypoint type! Only: PTP,LIN,CIRC,WAIT are allowed.");
|
|
}
|
|
}
|
|
|
|
|
|
Py::Object WaypointPy::getPos() const
|
|
{
|
|
return Py::Object(new PlacementPy(new Placement(getWaypointPtr()->EndPos)), true);
|
|
}
|
|
|
|
void WaypointPy::setPos(Py::Object arg)
|
|
{
|
|
Py::Type PlacementType(Base::getTypeAsObject(&(Base::PlacementPy::Type)));
|
|
if (arg.isType(PlacementType)) {
|
|
getWaypointPtr()->EndPos = *static_cast<Base::PlacementPy*>((*arg))->getPlacementPtr();
|
|
}
|
|
}
|
|
|
|
Py::Boolean WaypointPy::getCont() const
|
|
{
|
|
return {getWaypointPtr()->Cont};
|
|
}
|
|
|
|
void WaypointPy::setCont(Py::Boolean arg)
|
|
{
|
|
getWaypointPtr()->Cont = (bool)arg;
|
|
}
|
|
|
|
Py::Long WaypointPy::getTool() const
|
|
{
|
|
return Py::Long((long)getWaypointPtr()->Tool);
|
|
}
|
|
|
|
void WaypointPy::setTool(Py::Long arg)
|
|
{
|
|
long value = static_cast<long>(arg);
|
|
if (value >= 0) {
|
|
getWaypointPtr()->Tool = value;
|
|
}
|
|
else {
|
|
throw Py::ValueError("negative tool not allowed!");
|
|
}
|
|
}
|
|
|
|
Py::Long WaypointPy::getBase() const
|
|
{
|
|
return Py::Long((long)getWaypointPtr()->Base);
|
|
}
|
|
|
|
void WaypointPy::setBase(Py::Long arg)
|
|
{
|
|
long value = static_cast<long>(arg);
|
|
if (value >= 0) {
|
|
getWaypointPtr()->Base = value;
|
|
}
|
|
else {
|
|
throw Py::ValueError("negative base not allowed!");
|
|
}
|
|
}
|
|
|
|
PyObject* WaypointPy::getCustomAttributes(const char* /*attr*/) const
|
|
{
|
|
return nullptr;
|
|
}
|
|
|
|
int WaypointPy::setCustomAttributes(const char* /*attr*/, PyObject* /*obj*/)
|
|
{
|
|
return 0;
|
|
}
|