Python: Sphere, Cylinder, Color, Rotation

- Node cloning for safe tree handling in python
- Locking support for python interpreter
---------
Co-authored-by: Guenther Sohler <guenther.sohler@photeon.com>

Author: gsohler

CMakeLists.txt

@@ -791,6 +791,7 @@ set(CORE_SOURCES
   src/core/ImportNode.cc
   src/core/LinearExtrudeNode.cc
   src/core/LocalScope.cc
+  src/core/node_clone.cc
   src/core/ModuleInstantiation.cc
   src/core/NodeDumper.cc
   src/core/NodeVisitor.cc

src/core/node.h

@@ -65,6 +65,7 @@ class AbstractNode : public BaseVisitable, public std::enable_shared_from_this<A
   int idx; // Node index (unique per tree)
 
   std::shared_ptr<const AbstractNode> getNodeByID(int idx, std::deque<std::shared_ptr<const AbstractNode>>& path) const;
+  std::shared_ptr<AbstractNode> clone(void);
 };
 
 class AbstractIntersectionNode : public AbstractNode

src/core/node_clone.cc

@@ -0,0 +1,112 @@
+/*
+ *  OpenSCAD (www.openscad.org)
+ *  Copyright (C) 2009-2011 Clifford Wolf <clifford@clifford.at> and
+ *                          Marius Kintel <marius@kintel.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  As a special exception, you have permission to link this program
+ *  with the CGAL library and distribute executables, as long as you
+ *  follow the requirements of the GNU GPL in regard to all of the
+ *  software in the executable aside from CGAL.
+ *
+ *  This program 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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "src/geometry/linalg.h"
+#include "src/geometry/GeometryUtils.h"
+#include "src/core/primitives.h"
+#include "src/core/TransformNode.h"
+#include "src/core/RotateExtrudeNode.h"
+#include "src/core/LinearExtrudeNode.h"
+#include "src/core/CgalAdvNode.h"
+#include "src/core/CsgOpNode.h"
+#include "src/core/ColorNode.h"
+#include "src/core/RoofNode.h"
+#include "src/core/RenderNode.h"
+#include "src/core/SurfaceNode.h"
+#include "src/core/TextNode.h"
+#include "src/core/OffsetNode.h"
+#include "src/core/ProjectionNode.h"
+#include "src/core/ImportNode.h"
+
+std::vector<ModuleInstantiation *> modinsts_list;
+
+#define NodeCloneFunc(T) std::shared_ptr<T> clone_what(const T *node) {\
+       	ModuleInstantiation *inst = new ModuleInstantiation(node->modinst->name() ,\
+	node->modinst->arguments, node->modinst->location());\
+	modinsts_list.push_back(inst); \
+       	auto clone = std::make_shared<T>(*node);\
+       	clone->modinst = inst; \
+	return clone;\
+}
+
+#define NodeCloneUse(T) { const T *node = dynamic_cast<const T *>(this); if((node) != nullptr) clone=clone_what(node); }
+NodeCloneFunc(CubeNode)
+NodeCloneFunc(SphereNode)
+NodeCloneFunc(CylinderNode)
+NodeCloneFunc(PolyhedronNode)
+NodeCloneFunc(SquareNode)
+NodeCloneFunc(CircleNode)
+NodeCloneFunc(PolygonNode)
+NodeCloneFunc(TransformNode)
+NodeCloneFunc(ColorNode)
+NodeCloneFunc(RotateExtrudeNode)
+NodeCloneFunc(LinearExtrudeNode)
+NodeCloneFunc(CsgOpNode)
+NodeCloneFunc(CgalAdvNode)
+NodeCloneFunc(RoofNode)
+NodeCloneFunc(RenderNode)
+NodeCloneFunc(SurfaceNode)
+NodeCloneFunc(TextNode)
+NodeCloneFunc(OffsetNode)
+NodeCloneFunc(ProjectionNode)
+NodeCloneFunc(GroupNode)
+NodeCloneFunc(ImportNode)
+
+std::shared_ptr<AbstractNode> AbstractNode::clone(void)
+{
+	std::shared_ptr<AbstractNode> clone=nullptr;
+	NodeCloneUse(CubeNode)
+	NodeCloneUse(SphereNode)
+	NodeCloneUse(CylinderNode)
+	NodeCloneUse(PolyhedronNode)
+	NodeCloneUse(SquareNode)
+	NodeCloneUse(CircleNode)
+	NodeCloneUse(PolygonNode)
+	NodeCloneUse(TransformNode)
+	NodeCloneUse(ColorNode)
+	NodeCloneUse(RotateExtrudeNode)
+	NodeCloneUse(LinearExtrudeNode)
+	NodeCloneUse(CsgOpNode)
+	NodeCloneUse(CgalAdvNode)
+	NodeCloneUse(RoofNode)
+	NodeCloneUse(RenderNode)
+	NodeCloneUse(SurfaceNode)
+	NodeCloneUse(TextNode)
+	NodeCloneUse(OffsetNode)
+	NodeCloneUse(ProjectionNode)
+	NodeCloneUse(GroupNode)
+	NodeCloneUse(ImportNode)
+	if(clone != nullptr) {
+		clone->idx = idx_counter++;
+		clone->children.clear();
+		for(const auto &child: this->children) {
+			clone->children.push_back(child->clone());
+		}
+		return clone;
+	}
+	std::cout << "Type not defined for clone :" << typeid(this).name() << "\n\r";
+	return std::shared_ptr<AbstractNode>(this);
+}

src/gui/CGALWorker.cc

@@ -13,6 +13,10 @@
 #include "utils/printutils.h"
 #include "utils/exceptions.h"
 
+#ifdef ENABLE_PYTHON
+#include "python/python_public.h"
+#endif
+
 CGALWorker::CGALWorker()
 {
   this->tree = nullptr;
@@ -29,13 +33,19 @@ CGALWorker::~CGALWorker()
 
 void CGALWorker::start(const Tree& tree)
 {
+#ifdef ENABLE_PYTHON
+  python_unlock();
+#endif
   this->tree = &tree;
   this->thread->start();
 }
 
 void CGALWorker::work()
 {
   // this is a worker thread: we don't want any exceptions escaping and crashing the app.
+#ifdef ENABLE_PYTHON
+  python_lock();
+#endif
   std::shared_ptr<const Geometry> root_geom;
   try {
     GeometryEvaluator evaluator(*this->tree);
@@ -59,7 +69,9 @@ void CGALWorker::work()
   } catch (...) {
     LOG(message_group::Error, "Rendering cancelled by unknown exception.");
   }
-
+ #ifdef ENABLE_PYTHON
+  python_unlock();
+ #endif
   emit done(root_geom);
   thread->quit();
 }

src/gui/MainWindow.cc

@@ -1505,7 +1505,11 @@ void MainWindow::saveBackup()
   }
 
   if (!this->tempFile) {
-    this->tempFile = new QTemporaryFile(backupPath.append(basename + "-backup-XXXXXXXX.scad"));
+    QString suffix="scad";
+#ifdef ENABLE_PYTHON
+    if(this->python_active) suffix="py";
+#endif
+    this->tempFile = new QTemporaryFile(backupPath.append(basename + "-backup-XXXXXXXX." + suffix));
   }
 
   if ((!this->tempFile->isOpen()) && (!this->tempFile->open())) {
@@ -1825,6 +1829,10 @@ bool MainWindow::trust_python_file(const std::string& file,  const std::string&
     this->trusted_edit_document_name = file;
     return true;
   }
+  if(content.rfind("from openscad import",0) == 0) { // 1st character already typed
+    this->trusted_edit_document_name=file;
+    return true;
+  }
 
   if (settings.contains(setting_key)) {
     QString str = settings.value(setting_key).toString();
@@ -2155,6 +2163,9 @@ void MainWindow::cgalRender()
 
 void MainWindow::actionRenderDone(const std::shared_ptr<const Geometry>& root_geom)
 {
+#ifdef ENABLE_PYTHON
+  python_lock();	
+#endif
   progress_report_fin();
   if (root_geom) {
     std::vector<std::string> options;

src/gui/TabManager.cc

@@ -470,6 +470,11 @@ void TabManager::setTabModified(EditorInterface *edt)
 void TabManager::openTabFile(const QString& filename)
 {
   par->setCurrentOutput();
+#ifdef ENABLE_PYTHON
+  if(boost::algorithm::ends_with(filename, ".py")) {
+    std::string templ="from openscad import *\n";	  
+  } else
+#endif  
   editor->setPlainText("");
 
   QFileInfo fileinfo(filename);