vitalif
/
openscad
mirror of https://github.com/vitalif/openscad
1
0
Fork 0
Code Issues Releases Wiki Activity

Reverted accidental commits 

git-svn-id: http://svn.clifford.at/openscad/trunk@573 b57f626f-c46c-0410-a088-ec61d464b74c
stl_dim
kintel 2010-10-31 01:58:50 +00:00
parent a41eda3afe
commit 1611f6230e
33 changed files with 177 additions and 934 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
openscad.pro
View File

@ -98,22 +98,12 @@ HEADERS += src/CGAL_renderer.h \
src/highlighter.h \
src/module.h \
src/node.h \
src/csgnode.h \
src/dxflinextrudenode.h \
src/dxfrotextrudenode.h \
src/projectionnode.h \
src/importnode.h \
src/openscad.h \
src/polyset.h \
src/printutils.h \
src/value.h \
src/progress.h \
src/editor.h \
src/visitor.h \
src/state.h \
src/traverser.h \
src/nodecache.h \
src/nodedumper.h
src/editor.h
SOURCES += src/openscad.cc \
src/mainwin.cc \
@ -150,9 +140,7 @@ SOURCES += src/openscad.cc \
src/nef2dxf.cc \
src/Preferences.cc \
src/progress.cc \
src/editor.cc \\
src/traverser.cc \
src/nodedumper.cc
src/editor.cc
macx {
HEADERS += src/AppleEvents.h \

43
src/cgaladv.cc
View File

@ -29,8 +29,6 @@
#include "builtin.h"
#include "printutils.h"
#include "cgal.h"
#include "visitor.h"
#include <sstream>
#ifdef ENABLE_CGAL
extern CGAL_Nef_polyhedron3 minkowski3(CGAL_Nef_polyhedron3 a, CGAL_Nef_polyhedron3 b);
@ -54,21 +52,15 @@ public:
class CgaladvNode : public AbstractNode
{
public:
CgaladvNode(const ModuleInstantiation *mi, cgaladv_type_e type) : AbstractNode(mi), type(type) {
convexity = 1;
}
virtual ~CgaladvNode() { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
Value path;
QString subdiv_type;
int convexity, level;
cgaladv_type_e type;
CgaladvNode(const ModuleInstantiation *mi, cgaladv_type_e type) : AbstractNode(mi), type(type) {
convexity = 1;
}
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
virtual CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
@ -136,7 +128,7 @@ void register_builtin_cgaladv()
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron CgaladvNode::renderCSGMesh() const
CGAL_Nef_polyhedron CgaladvNode::render_cgal_nef_polyhedron() const
{
QString cache_id = mk_cache_id();
if (cgal_nef_cache.contains(cache_id)) {
@ -155,11 +147,11 @@ CGAL_Nef_polyhedron CgaladvNode::renderCSGMesh() const
if (v->modinst->tag_background)
continue;
if (first) {
N = v->renderCsgMesh();
N = v->render_cgal_nef_polyhedron();
if (N.dim != 0)
first = false;
} else {
CGAL_Nef_polyhedron tmp = v->renderCsgMesh();
CGAL_Nef_polyhedron tmp = v->render_cgal_nef_polyhedron();
if (N.dim == 3 && tmp.dim == 3) {
N.p3 = minkowski3(N.p3, tmp.p3);
}
@ -232,24 +224,3 @@ QString CgaladvNode::dump(QString indent) const
return dump_cache;
}
std::string CgaladvNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
switch (type) {
case MINKOWSKI:
stream << "minkowski(convexity = " << this->convexity << ")";
break;
case GLIDE:
stream << "glide(path = " << this->path.dump() << ", convexity = " << this->convexity << ")";
break;
case SUBDIV:
stream << "subdiv(level = " << this->level << ", convexity = " << this->convexity << ")";
break;
default:
assert(false);
}
return stream.str();
}

33
src/csgnode.h
View File

@ -1,33 +0,0 @@
#ifndef CSGNODE_H_
#define CSGNODE_H_
#include "node.h"
#include "visitor.h"
#ifdef ENABLE_CGAL
# include "cgal.h"
#endif
enum csg_type_e {
CSG_TYPE_UNION,
CSG_TYPE_DIFFERENCE,
CSG_TYPE_INTERSECTION
};
class CsgNode : public AbstractNode
{
public:
csg_type_e type;
CsgNode(const ModuleInstantiation *mi, csg_type_e type) : AbstractNode(mi), type(type) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
#endif
CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
};
#endif

65
src/csgops.cc
View File

@ -23,13 +23,22 @@
*
*/
#include "csgnode.h"
#include "module.h"
#include "node.h"
#include "csgterm.h"
#include "builtin.h"
#include "printutils.h"
#include <sstream>
#ifdef ENABLE_CGAL
# include "cgal.h"
# include <CGAL/assertions_behaviour.h>
# include <CGAL/exceptions.h>
#endif
enum csg_type_e {
CSG_TYPE_UNION,
CSG_TYPE_DIFFERENCE,
CSG_TYPE_INTERSECTION
};
class CsgModule : public AbstractModule
{
@ -39,6 +48,18 @@ public:
virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
};
class CsgNode : public AbstractNode
{
public:
csg_type_e type;
CsgNode(const ModuleInstantiation *mi, csg_type_e type) : AbstractNode(mi), type(type) { }
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
};
AbstractNode *CsgModule::evaluate(const Context*, const ModuleInstantiation *inst) const
{
CsgNode *node = new CsgNode(inst, type);
@ -52,7 +73,7 @@ AbstractNode *CsgModule::evaluate(const Context*, const ModuleInstantiation *ins
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron CsgNode::renderCSGMesh() const
CGAL_Nef_polyhedron CsgNode::render_cgal_nef_polyhedron() const
{
QString cache_id = mk_cache_id();
if (cgal_nef_cache.contains(cache_id)) {
@ -71,24 +92,24 @@ CGAL_Nef_polyhedron CsgNode::renderCSGMesh() const
if (v->modinst->tag_background)
continue;
if (first) {
N = v->renderCSGMesh();
N = v->render_cgal_nef_polyhedron();
if (N.dim != 0)
first = false;
} else if (N.dim == 2) {
if (type == CSG_TYPE_UNION) {
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
} else if (type == CSG_TYPE_DIFFERENCE) {
N.p2 -= v->renderCSGMesh().p2;
N.p2 -= v->render_cgal_nef_polyhedron().p2;
} else if (type == CSG_TYPE_INTERSECTION) {
N.p2 *= v->renderCSGMesh().p2;
N.p2 *= v->render_cgal_nef_polyhedron().p2;
}
} else if (N.dim == 3) {
if (type == CSG_TYPE_UNION) {
N.p3 += v->renderCSGMesh().p3;
N.p3 += v->render_cgal_nef_polyhedron().p3;
} else if (type == CSG_TYPE_DIFFERENCE) {
N.p3 -= v->renderCSGMesh().p3;
N.p3 -= v->render_cgal_nef_polyhedron().p3;
} else if (type == CSG_TYPE_INTERSECTION) {
N.p3 *= v->renderCSGMesh().p3;
N.p3 *= v->render_cgal_nef_polyhedron().p3;
}
}
v->progress_report();
@ -151,28 +172,6 @@ QString CsgNode::dump(QString indent) const
return dump_cache;
}
std::string CsgNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
switch (this->type) {
case CSG_TYPE_UNION:
stream << "union()";
break;
case CSG_TYPE_DIFFERENCE:
stream << "difference()";
break;
case CSG_TYPE_INTERSECTION:
stream << "intersection()";
break;
default:
assert(false);
}
return stream.str();
}
void register_builtin_csgops()
{
builtin_modules["union"] = new CsgModule(CSG_TYPE_UNION);

56
src/dxflinextrude.cc
View File

@ -23,9 +23,8 @@
*
*/
#include "dxflinextrudenode.h"
#include "module.h"
#include "node.h"
#include "context.h"
#include "printutils.h"
#include "builtin.h"
@ -33,13 +32,11 @@
#include "dxftess.h"
#include "polyset.h"
#include "progress.h"
#include "visitor.h"
#include "openscad.h" // get_fragments_from_r()
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sstream>
#include <QApplication>
#include <QTime>
@ -52,6 +49,24 @@ public:
virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
};
class DxfLinearExtrudeNode : public AbstractPolyNode
{
public:
int convexity, slices;
double fn, fs, fa, height, twist;
double origin_x, origin_y, scale;
bool center, has_twist;
QString filename, layername;
DxfLinearExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
convexity = slices = 0;
fn = fs = fa = height = twist = 0;
origin_x = origin_y = scale = 0;
center = has_twist = false;
}
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
AbstractNode *DxfLinearExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
{
DxfLinearExtrudeNode *node = new DxfLinearExtrudeNode(inst);
@ -76,8 +91,10 @@ AbstractNode *DxfLinearExtrudeModule::evaluate(const Context *ctx, const ModuleI
Value twist = c.lookup_variable("twist", true);
Value slices = c.lookup_variable("slices", true);
if (!file.text.isNull())
if(!file.text.isNull())
node->filename = c.get_absolute_path(file.text);
else
node->filename = file.text;
node->layername = layer.text;
node->height = height.num;
@ -219,7 +236,7 @@ PolySet *DxfLinearExtrudeNode::render_polyset(render_mode_e) const
foreach(AbstractNode * v, children) {
if (v->modinst->tag_background)
continue;
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
}
dxf = new DxfData(N);
@ -327,30 +344,3 @@ QString DxfLinearExtrudeNode::dump(QString indent) const
return dump_cache;
}
std::string DxfLinearExtrudeNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
QString text;
struct stat st;
memset(&st, 0, sizeof(struct stat));
stat(this->filename.toAscii().data(), &st);
stream << "linear_extrude("
"file = \"" << this->filename << "\", "
"cache = \"" << std::hex << (int)st.st_mtime << "." << (int)st.st_size << "\", "
"layer = \"" << this->layername << "\", "
"height = " << std::dec << this->height << ", "
"origin = [ " << this->origin_x << " " << this->origin_y << " ], "
"scale = " << this->scale << ", "
"center = " << (this->center?"true":"false") << ", "
"convexity = " << this->convexity;
if (this->has_twist) {
stream << ", twist = " << this->twist << ", slices = " << this->slices;
}
stream << ", $fn = " << this->fn << ", $fa = " << this->fa << ", $fs = " << this->fs << ")";
return stream.str();
}

30
src/dxflinextrudenode.h
View File

@ -1,30 +0,0 @@
#ifndef DXFLINEXTRUDENODE_H_
#define DXFLINEXTRUDENODE_H_
#include "node.h"
#include "visitor.h"
class DxfLinearExtrudeNode : public AbstractPolyNode
{
public:
DxfLinearExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
convexity = slices = 0;
fn = fs = fa = height = twist = 0;
origin_x = origin_y = scale = 0;
center = has_twist = false;
}
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
int convexity, slices;
double fn, fs, fa, height, twist;
double origin_x, origin_y, scale;
bool center, has_twist;
QString filename, layername;
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
#endif

45
src/dxfrotextrude.cc
View File

@ -23,21 +23,19 @@
*
*/
#include "dxfrotextrudenode.h"
#include "module.h"
#include "node.h"
#include "context.h"
#include "printutils.h"
#include "builtin.h"
#include "polyset.h"
#include "dxfdata.h"
#include "progress.h"
#include "visitor.h"
#include "openscad.h" // get_fragments_from_r()
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sstream>
#include <QTime>
#include <QApplication>
@ -50,6 +48,22 @@ public:
virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
};
class DxfRotateExtrudeNode : public AbstractPolyNode
{
public:
int convexity;
double fn, fs, fa;
double origin_x, origin_y, scale;
QString filename, layername;
DxfRotateExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
convexity = 0;
fn = fs = fa = 0;
origin_x = origin_y = scale = 0;
}
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
AbstractNode *DxfRotateExtrudeModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
{
DxfRotateExtrudeNode *node = new DxfRotateExtrudeNode(inst);
@ -70,8 +84,10 @@ AbstractNode *DxfRotateExtrudeModule::evaluate(const Context *ctx, const ModuleI
Value origin = c.lookup_variable("origin", true);
Value scale = c.lookup_variable("scale", true);
if (!file.text.isNull())
if(!file.text.isNull())
node->filename = c.get_absolute_path(file.text);
else
node->filename = file.text;
node->layername = layer.text;
node->convexity = (int)convexity.num;
@ -120,7 +136,7 @@ PolySet *DxfRotateExtrudeNode::render_polyset(render_mode_e) const
foreach(AbstractNode * v, children) {
if (v->modinst->tag_background)
continue;
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
}
dxf = new DxfData(N);
@ -218,22 +234,3 @@ QString DxfRotateExtrudeNode::dump(QString indent) const
return dump_cache;
}
std::string DxfRotateExtrudeNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
struct stat st;
memset(&st, 0, sizeof(struct stat));
stat(filename.toAscii().data(), &st);
stream << "rotate_extrude("
"file = \"" << this->filename << "\", "
"cache = \"" << std::hex << (int)st.st_mtime << "." << (int)st.st_size << "\", "
"layer = \"" << this->layername << "\", "
"origin = [ " << std::dec << this->origin_x << " " << this->origin_y << " ], "
"scale = " << this->scale << ", "
"convexity = " << this->convexity << ", "
"$fn = " << this->fn << ", $fa = " << this->fa << ", $fs = " << this->fs << ")";
return stream.str();
}

28
src/dxfrotextrudenode.h
View File

@ -1,28 +0,0 @@
#ifndef DXFROTEXTRUDENODE_H_
#define DXFROTEXTRUDENODE_H_
#include "node.h"
#include "visitor.h"
class DxfRotateExtrudeNode : public AbstractPolyNode
{
public:
DxfRotateExtrudeNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
convexity = 0;
fn = fs = fa = 0;
origin_x = origin_y = scale = 0;
}
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
int convexity;
double fn, fs, fa;
double origin_x, origin_y, scale;
QString filename, layername;
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
#endif

60
src/import.cc
View File

@ -23,9 +23,8 @@
*
*/
#include "importnode.h"
#include "module.h"
#include "node.h"
#include "polyset.h"
#include "context.h"
#include "builtin.h"
@ -37,7 +36,12 @@
#include <QFile>
#include <sys/types.h>
#include <sys/stat.h>
#include <sstream>
enum import_type_e {
TYPE_STL,
TYPE_OFF,
TYPE_DXF
};
class ImportModule : public AbstractModule
{
@ -47,6 +51,20 @@ public:
virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
};
class ImportNode : public AbstractPolyNode
{
public:
import_type_e type;
QString filename;
QString layername;
int convexity;
double fn, fs, fa;
double origin_x, origin_y, scale;
ImportNode(const ModuleInstantiation *mi, import_type_e type) : AbstractPolyNode(mi), type(type) { }
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
AbstractNode *ImportModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
{
ImportNode *node = new ImportNode(inst, type);
@ -213,39 +231,3 @@ QString ImportNode::dump(QString indent) const
return dump_cache;
}
std::string ImportNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
QString text;
struct stat st;
memset(&st, 0, sizeof(struct stat));
stat(this->filename.toAscii().data(), &st);
switch (this->type) {
case TYPE_STL:
stream << "import_stl(file = \"" << this->filename << "\", "
"cache = \"" << std::hex << (int)st.st_mtime << "." << (int)st.st_size << "\", "
"convexity = " << std::dec << this->convexity << ")";
break;
case TYPE_OFF:
stream << "import_off(file = \"" << this->filename << "\", "
"cache = \"" << std::hex << (int)st.st_mtime << "." << (int)st.st_size << "\", "
"convexity = " << std::dec << this->convexity << ")";
break;
case TYPE_DXF:
stream << "import_dxf(file = \"" << this->filename << "\", "
"cache = \"" << std::hex << (int)st.st_mtime << "." << (int)st.st_size << "\", "
"layer = \"" << this->layername << "\", "
"origin = [ " << std::dec << this->origin_x << " " << this->origin_y << " ], "
"scale = " << this->scale << ", "
"convexity = " << this->convexity << ", "
"$fn = " << this->fn << ", $fa = " << this->fa << ", $fs = " << this->fs << ")";
break;
default:
assert(false);
}
return stream.str();
}

32
src/importnode.h
View File

@ -1,32 +0,0 @@
#ifndef IMPORTNODE_H_
#define IMPORTNODE_H_
#include "node.h"
#include "visitor.h"
enum import_type_e {
TYPE_STL,
TYPE_OFF,
TYPE_DXF
};
class ImportNode : public AbstractPolyNode
{
public:
ImportNode(const ModuleInstantiation *mi, import_type_e type) : AbstractPolyNode(mi), type(type) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
import_type_e type;
QString filename;
QString layername;
int convexity;
double fn, fs, fa;
double origin_x, origin_y, scale;
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
#endif

2
src/mainwin.cc
View File

@ -1126,7 +1126,7 @@ void MainWindow::actionRenderCGAL()
progress_report_prep(root_node, report_func, pd);
try {
this->root_N = new CGAL_Nef_polyhedron(root_node->renderCSGMesh());
this->root_N = new CGAL_Nef_polyhedron(root_node->render_cgal_nef_polyhedron());
}
catch (ProgressCancelException e) {
PRINT("Rendering cancelled.");

63
src/node.cc
View File

@ -29,9 +29,7 @@
#include "csgterm.h"
#include "progress.h"
#include "polyset.h"
#include "visitor.h"
#include <QRegExp>
#include <sstream>
int AbstractNode::idx_counter;
@ -47,21 +45,6 @@ AbstractNode::~AbstractNode()
delete v;
}
Response AbstractNode::accept(const class State &state, Visitor &visitor) const
{
return visitor.visit(state, *this);
}
Response AbstractIntersectionNode::accept(const class State &state, Visitor &visitor) const
{
return visitor.visit(state, *this);
}
Response AbstractPolyNode::accept(const class State &state, Visitor &visitor) const
{
return visitor.visit(state, *this);
}
QString AbstractNode::mk_cache_id() const
{
QString cache_id = dump("");
@ -96,19 +79,19 @@ static CGAL_Nef_polyhedron render_cgal_nef_polyhedron_backend(const AbstractNode
if (v->modinst->tag_background)
continue;
if (first) {
N = v->renderCSGMesh();
N = v->render_cgal_nef_polyhedron();
if (N.dim != 0)
first = false;
} else if (N.dim == 2) {
if (intersect)
N.p2 *= v->renderCSGMesh().p2;
N.p2 *= v->render_cgal_nef_polyhedron().p2;
else
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
} else {
if (intersect)
N.p3 *= v->renderCSGMesh().p3;
N.p3 *= v->render_cgal_nef_polyhedron().p3;
else
N.p3 += v->renderCSGMesh().p3;
N.p3 += v->render_cgal_nef_polyhedron().p3;
}
v->progress_report();
}
@ -120,12 +103,12 @@ static CGAL_Nef_polyhedron render_cgal_nef_polyhedron_backend(const AbstractNode
return N;
}
CGAL_Nef_polyhedron AbstractNode::renderCSGMesh() const
CGAL_Nef_polyhedron AbstractNode::render_cgal_nef_polyhedron() const
{
return render_cgal_nef_polyhedron_backend(this, false);
}
CGAL_Nef_polyhedron AbstractIntersectionNode::renderCSGMesh() const
CGAL_Nef_polyhedron AbstractIntersectionNode::render_cgal_nef_polyhedron() const
{
return render_cgal_nef_polyhedron_backend(this, true);
}
@ -176,17 +159,10 @@ QString AbstractNode::dump(QString indent) const
return dump_cache;
}
std::string AbstractNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": group()";
return stream.str();
}
QString AbstractIntersectionNode::dump(QString indent) const
{
if (dump_cache.isEmpty()) {
QString text = indent + QString::fromStdString(this->toString()) + " {\n";
QString text = indent + QString("n%1: intersection() {\n").arg(idx);
foreach (AbstractNode *v, children)
text += v->dump(indent + QString("\t"));
((AbstractNode*)this)->dump_cache = text + indent + "}\n";
@ -194,13 +170,6 @@ QString AbstractIntersectionNode::dump(QString indent) const
return dump_cache;
}
std::string AbstractIntersectionNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": intersection()";
return stream.str();
}
void AbstractNode::progress_prepare()
{
foreach (AbstractNode *v, children)
@ -215,7 +184,7 @@ void AbstractNode::progress_report() const
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron AbstractPolyNode::renderCSGMesh() const
CGAL_Nef_polyhedron AbstractPolyNode::render_cgal_nef_polyhedron() const
{
QString cache_id = mk_cache_id();
if (cgal_nef_cache.contains(cache_id)) {
@ -228,7 +197,7 @@ CGAL_Nef_polyhedron AbstractPolyNode::renderCSGMesh() const
PolySet *ps = render_polyset(RENDER_CGAL);
try {
CGAL_Nef_polyhedron N = ps->renderCSGMesh();
CGAL_Nef_polyhedron N = ps->render_cgal_nef_polyhedron();
cgal_nef_cache.insert(cache_id, new cgal_nef_cache_entry(N), N.weight());
print_messages_pop();
progress_report();
@ -262,15 +231,3 @@ CSGTerm *AbstractPolyNode::render_csg_term_from_ps(double m[20], QVector<CSGTerm
return t;
}
std::ostream &operator<<(std::ostream &stream, const QString &str)
{
stream << str.toStdString();
return stream;
}
std::ostream &operator<<(std::ostream &stream, const AbstractNode &node)
{
stream << node.toString();
return stream;
}

57
src/node.h
View File

@ -8,8 +8,6 @@
#include "cgal.h"
#endif
#include "traverser.h"
extern int progress_report_count;
extern void (*progress_report_f)(const class AbstractNode*, void*, int);
extern void *progress_report_vp;
@ -19,47 +17,23 @@ void progress_report_fin();
class AbstractNode
{
// FIXME: the idx_counter/idx is mostly (only?) for debugging.
// We can hash on pointer value or smth. else.
// -> remove and
// use smth. else to display node identifier in CSG tree output?
static int idx_counter; // Node instantiation index
public:
AbstractNode(const class ModuleInstantiation *mi);
virtual ~AbstractNode();
virtual Response accept(const class State &state, class Visitor &visitor) const;
virtual std::string toString() const;
// FIXME: Make return value a reference
const std::list<AbstractNode*> getChildren() const {
return this->children.toList().toStdList();
}
int index() const { return this->idx; }
static void resetIndexCounter() { idx_counter = 1; }
// FIXME: Rewrite to STL container?
// FIXME: Make protected
QVector<AbstractNode*> children;
const ModuleInstantiation *modinst;
const class ModuleInstantiation *modinst;
// progress_mark is a running number used for progress indication
// FIXME: Make all progress handling external, put it in the traverser class?
int progress_mark;
void progress_prepare();
void progress_report() const;
int idx; // Node index (unique per tree)
// FIXME: Remove these three with dump() method
int idx;
QString dump_cache;
AbstractNode(const ModuleInstantiation *mi);
virtual ~AbstractNode();
virtual QString mk_cache_id() const;
virtual QString dump(QString indent) const;
// FIXME: Rewrite to visitor
virtual class CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
// FIXME: Rewrite to visitor
#ifdef ENABLE_CGAL
struct cgal_nef_cache_entry {
CGAL_Nef_polyhedron N;
@ -67,21 +41,19 @@ public:
cgal_nef_cache_entry(const CGAL_Nef_polyhedron &N);
};
static QCache<QString, cgal_nef_cache_entry> cgal_nef_cache;
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
class CSGTerm *render_csg_term_from_nef(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, const char *statement, int convexity) const;
#endif
virtual class CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
};
class AbstractIntersectionNode : public AbstractNode
{
public:
AbstractIntersectionNode(const ModuleInstantiation *mi) : AbstractNode(mi) { };
virtual ~AbstractIntersectionNode() { };
virtual Response accept(const class State &state, class Visitor &visitor) const;
virtual std::string toString() const;
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
virtual CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
@ -90,24 +62,17 @@ public:
class AbstractPolyNode : public AbstractNode
{
public:
AbstractPolyNode(const ModuleInstantiation *mi) : AbstractNode(mi) { };
virtual ~AbstractPolyNode() { };
virtual Response accept(const class State &state, class Visitor &visitor) const;
enum render_mode_e {
RENDER_CGAL,
RENDER_OPENCSG
};
AbstractPolyNode(const ModuleInstantiation *mi) : AbstractNode(mi) { };
virtual class PolySet *render_polyset(render_mode_e mode) const = 0;
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
virtual CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
static CSGTerm *render_csg_term_from_ps(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background, PolySet *ps, const ModuleInstantiation *modinst, int idx);
};
std::ostream &operator<<(std::ostream &stream, const AbstractNode &node);
// FIXME: Doesn't belong here..
std::ostream &operator<<(std::ostream &stream, const QString &str);
#endif

33
src/nodecache.h
View File

@ -1,33 +0,0 @@
#ifndef NODECACHE_H_
#define NODECACHE_H_
#include <vector>
#include "node.h"
template <class T>
class NodeCache
{
public:
NodeCache() { }
virtual ~NodeCache() { }
const T & operator[](const AbstractNode &node) const {
if (this->cache.size() > node.index()) return this->cache[node.index()];
else return nullvalue;
}
void insert(const class AbstractNode &node, const T & value) {
this->cache.resize(node.index() + 1);
this->cache[node.index()] = value;
}
void remove(const class AbstractNode &node) {
if (this->cache.size() > node.index()) this->cache[node.index()] = nullvalue;
}
private:
std::vector<T> cache;
T nullvalue;
};
#endif

98
src/nodedumper.cc
View File

@ -1,98 +0,0 @@
#include "nodedumper.h"
#include <string>
#include <map>
#include <list>
#include "visitor.h"
#include "state.h"
#include "nodecache.h"
#include <sstream>
#include <iostream>
// For compatibility with old dump() output
#define NODEDUMPER_COMPAT_MODE
#ifdef NODEDUMPER_COMPAT_MODE
#include "dxflinextrudenode.h"
#include "dxfrotextrudenode.h"
#include "projectionnode.h"
#endif
bool NodeDumper::isCached(const AbstractNode &node)
{
return !this->cache[node].empty();
}
void NodeDumper::handleIndent(const State &state)
{
if (state.isPrefix()) {
this->currindent += "\t";
}
else if (state.isPostfix()) {
this->currindent.erase((this->currindent.length() >= 1) ?
this->currindent.length() - 1 : 0);
}
}
string NodeDumper::dumpChildren(const AbstractNode &node)
{
std::stringstream dump;
if (!this->visitedchildren[node.index()].empty()) {
dump << " {\n";
for (ChildList::const_iterator iter = this->visitedchildren[node.index()].begin();
iter != this->visitedchildren[node.index()].end();
iter++) {
dump << this->cache[**iter] << "\n";
}
dump << this->currindent << "}";
}
else {
#ifndef NODEDUMPER_COMPAT_MODE
dump << ";";
#else
if (dynamic_cast<const AbstractPolyNode*>(&node) &&
!dynamic_cast<const ProjectionNode*>(&node) &&
!dynamic_cast<const DxfRotateExtrudeNode*>(&node) &&
!dynamic_cast<const DxfLinearExtrudeNode*>(&node)) dump << ";";
else dump << " {\n" << this->currindent << "}";
#endif
}
return dump.str();
}
Response NodeDumper::visit(const State &state, const AbstractNode &node)
{
if (isCached(node)) return PruneTraversal;
else handleIndent(state);
if (state.isPostfix()) {
std::stringstream dump;
dump << this->currindent << node;
dump << dumpChildren(node);
this->cache.insert(node, dump.str());
}
handleVisitedChildren(state, node);
return ContinueTraversal;
}
const string &NodeDumper::getDump() const
{
assert(this->root);
return this->cache[*this->root];
}
void NodeDumper::handleVisitedChildren(const State &state, const AbstractNode &node)
{
if (state.isPostfix()) {
this->visitedchildren.erase(node.index());
if (!state.parent()) {
this->root = &node;
}
else {
this->visitedchildren[state.parent()->index()].push_back(&node);
}
}
}

37
src/nodedumper.h
View File

@ -1,37 +0,0 @@
#ifndef NODEDUMPER_H_
#define NODEDUMPER_H_
#include <string>
#include <map>
#include <list>
#include "visitor.h"
#include "nodecache.h"
using std::string;
using std::map;
using std::list;
class NodeDumper : public Visitor
{
public:
NodeDumper() : root(NULL) {}
virtual ~NodeDumper() {}
virtual Response visit(const State &state, const AbstractNode &node);
const string &getDump() const;
private:
void handleVisitedChildren(const State &state, const AbstractNode &node);
bool isCached(const AbstractNode &node);
void handleIndent(const State &state);
string dumpChildren(const AbstractNode &node);
string currindent;
const AbstractNode *root;
typedef list<const AbstractNode *> ChildList;
map<int, ChildList> visitedchildren;
NodeCache<string> cache;
};
#endif

15
src/openscad.cc
View File

@ -31,7 +31,6 @@
#include "value.h"
#include "export.h"
#include "builtin.h"
#include "nodedumper.h"
#ifdef ENABLE_CGAL
#include "cgal.h"
@ -285,20 +284,8 @@ int main(int argc, char **argv)
AbstractNode::resetIndexCounter();
root_node = root_module->evaluate(&root_ctx, &root_inst);
NodeDumper dumper;
Traverser trav(dumper, *root_node, Traverser::PRE_AND_POSTFIX);
trav.execute();
// std::cout << dumper.getDump();
// std::cout << std::endl;
// trav.execute();
// std::cout << dumper.getDump();
// std::cout << std::endl;
printf(dumper.getDump().c_str());
exit(1);
CGAL_Nef_polyhedron *root_N;
root_N = new CGAL_Nef_polyhedron(root_node->renderCSGMesh());
root_N = new CGAL_Nef_polyhedron(root_node->render_cgal_nef_polyhedron());
QDir::setCurrent(original_path.absolutePath());

10
src/polyset.cc
View File

@ -144,9 +144,7 @@ void PolySet::render_surface(colormode_e colormode, csgmode_e csgmode, double *m
bool mirrored = m3f.determinant() < 0;
if (colormode == COLORMODE_MATERIAL) {
// FIXME: Reenable/rewrite - don't be dependant on GUI
// const QColor &col = Preferences::inst()->color(Preferences::OPENCSG_FACE_FRONT_COLOR);
const QColor &col = QColor(0xf9, 0xd7, 0x2c);
const QColor &col = Preferences::inst()->color(Preferences::OPENCSG_FACE_FRONT_COLOR);
glColor3f(col.redF(), col.greenF(), col.blueF());
#ifdef ENABLE_OPENCSG
if (shaderinfo) {
@ -156,9 +154,7 @@ void PolySet::render_surface(colormode_e colormode, csgmode_e csgmode, double *m
#endif /* ENABLE_OPENCSG */
}
if (colormode == COLORMODE_CUTOUT) {
// FIXME: Reenable/rewrite - don't be dependant on GUI
// const QColor &col = Preferences::inst()->color(Preferences::OPENCSG_FACE_BACK_COLOR);
const QColor &col = QColor(0x9d, 0xcb, 0x51);
const QColor &col = Preferences::inst()->color(Preferences::OPENCSG_FACE_BACK_COLOR);
glColor3f(col.redF(), col.greenF(), col.blueF());
#ifdef ENABLE_OPENCSG
if (shaderinfo) {
@ -411,7 +407,7 @@ public:
}
};
CGAL_Nef_polyhedron PolySet::renderCSGMesh() const
CGAL_Nef_polyhedron PolySet::render_cgal_nef_polyhedron() const
{
if (this->is2d)
{

2
src/polyset.h
View File

@ -78,7 +78,7 @@ public:
void render_edges(colormode_e colormode, csgmode_e csgmode) const;
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron renderCSGMesh() const;
CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
int refcount;

50
src/primitives.cc
View File

@ -32,8 +32,6 @@
#include "builtin.h"
#include "printutils.h"
#include <assert.h>
#include "visitor.h"
#include <sstream>
enum primitive_type_e {
CUBE,
@ -56,18 +54,13 @@ public:
class PrimitiveNode : public AbstractPolyNode
{
public:
PrimitiveNode(const ModuleInstantiation *mi, primitive_type_e type) : AbstractPolyNode(mi), type(type) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
bool center;
double x, y, z, h, r1, r2;
double fn, fs, fa;
primitive_type_e type;
int convexity;
Value points, paths, triangles;
PrimitiveNode(const ModuleInstantiation *mi, primitive_type_e type) : AbstractPolyNode(mi), type(type) { }
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
@ -549,44 +542,3 @@ QString PrimitiveNode::dump(QString indent) const
return dump_cache;
}
std::string PrimitiveNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
switch (this->type) {
case CUBE:
stream << "cube(size = [" << this->x << ", " << this->y << ", " << this->z << "], "
<< "center = " << (center ? "true" : "false") << ")";
break;
case SPHERE:
stream << "sphere($fn = " << this->fn << ", $fa = " << this->fa
<< ", $fs = " << this->fs << ", r = " << this->r1 << ")";
break;
case CYLINDER:
stream << "cylinder($fn = " << this->fn << ", $fa = " << this->fa
<< ", $fs = " << this->fs << ", h = " << this->h << ", r1 = " << this->r1
<< ", r2 = " << this->r2 << ", center = " << (center ? "true" : "false") << ")";
break;
case POLYHEDRON:
stream << "polyhedron(points = " << this->points.dump()
<< ", triangles = " << this->triangles.dump()
<< ", convexity = " << this->convexity << ")";
break;
case SQUARE:
stream << "square(size = [" << this->x << ", " << this->y << "], "
<< "center = " << (center ? "true" : "false") << ")";
break;
case CIRCLE:
stream << "circle($fn = " << this->fn << ", $fa = " << this->fa
<< ", $fs = " << this->fs << ", r = " << this->r1 << ")";
break;
case POLYGON:
stream << "polygon(points = " << this->points.dump() << ", paths = " << this->paths.dump() << ", convexity = " << this->convexity << ")";
break;
default:
assert(false);
}
return stream.str();
}

3
src/printutils.cc
View File

@ -18,7 +18,8 @@ void print_messages_push()
void print_messages_pop()
{
QString msg = print_messages_stack.takeLast();
QString msg = print_messages_stack.last();
print_messages_stack.removeLast();
if (print_messages_stack.size() > 0 && !msg.isNull()) {
if (!print_messages_stack.last().isEmpty())
print_messages_stack.last() += "\n";

30
src/projection.cc
View File

@ -23,8 +23,8 @@
*
*/
#include "projectionnode.h"
#include "module.h"
#include "node.h"
#include "context.h"
#include "printutils.h"
#include "builtin.h"
@ -33,7 +33,6 @@
#include "polyset.h"
#include "export.h"
#include "progress.h"
#include "visitor.h"
#ifdef ENABLE_CGAL
# include <CGAL/assertions_behaviour.h>
@ -44,7 +43,6 @@
#include <sys/stat.h>
#include <unistd.h>
#include <assert.h>
#include <sstream>
#include <QApplication>
#include <QTime>
@ -57,6 +55,18 @@ public:
virtual AbstractNode *evaluate(const Context *ctx, const ModuleInstantiation *inst) const;
};
class ProjectionNode : public AbstractPolyNode
{
public:
int convexity;
bool cut_mode;
ProjectionNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
cut_mode = false;
}
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
AbstractNode *ProjectionModule::evaluate(const Context *ctx, const ModuleInstantiation *inst) const
{
ProjectionNode *node = new ProjectionNode(inst);
@ -112,7 +122,7 @@ PolySet *ProjectionNode::render_polyset(render_mode_e) const
foreach(AbstractNode *v, this->children) {
if (v->modinst->tag_background)
continue;
N.p3 += v->renderCSGMesh().p3;
N.p3 += v->render_cgal_nef_polyhedron().p3;
}
}
catch (CGAL::Assertion_exception e) {
@ -163,7 +173,7 @@ PolySet *ProjectionNode::render_polyset(render_mode_e) const
cube->append_vertex(x1, y1, z1);
cube->append_vertex(x1, y1, z2);
cube->append_vertex(x1, y2, z2);
CGAL_Nef_polyhedron Ncube = cube->renderCSGMesh();
CGAL_Nef_polyhedron Ncube = cube->render_cgal_nef_polyhedron();
cube->unlink();
// N.p3 *= CGAL_Nef_polyhedron3(CGAL_Plane(0, 0, 1, 0), CGAL_Nef_polyhedron3::INCLUDED);
@ -288,13 +298,3 @@ QString ProjectionNode::dump(QString indent) const
return dump_cache;
}
std::string ProjectionNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
stream << "projection(cut = " << (this->cut_mode ? "true" : "false")
<< ", convexity = " << this->convexity << ")";
return stream.str();
}

24
src/projectionnode.h
View File

@ -1,24 +0,0 @@
#ifndef PROJECTIONNODE_H_
#define PROJECTIONNODE_H_
#include "node.h"
#include "visitor.h"
class ProjectionNode : public AbstractPolyNode
{
public:
ProjectionNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) {
cut_mode = false;
}
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
int convexity;
bool cut_mode;
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
#endif

31
src/render.cc
View File

@ -33,14 +33,13 @@
#include "builtin.h"
#include "printutils.h"
#include "progress.h"
#include "visitor.h"
#ifdef ENABLE_CGAL
# include "cgal.h"
#endif
#include <QProgressDialog>
#include <QApplication>
#include <QTime>
#include <sstream>
class RenderModule : public AbstractModule
{
@ -52,15 +51,10 @@ public:
class RenderNode : public AbstractNode
{
public:
RenderNode(const ModuleInstantiation *mi) : AbstractNode(mi), convexity(1) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
int convexity;
RenderNode(const ModuleInstantiation *mi) : AbstractNode(mi), convexity(1) { }
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
@ -96,7 +90,7 @@ void register_builtin_render()
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron RenderNode::renderCSGMesh() const
CGAL_Nef_polyhedron RenderNode::render_cgal_nef_polyhedron() const
{
QString cache_id = mk_cache_id();
if (cgal_nef_cache.contains(cache_id)) {
@ -114,13 +108,13 @@ CGAL_Nef_polyhedron RenderNode::renderCSGMesh() const
if (v->modinst->tag_background)
continue;
if (first) {
N = v->renderCSGMesh();
N = v->render_cgal_nef_polyhedron();
if (N.dim != 0)
first = false;
} else if (N.dim == 2) {
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
} else if (N.dim == 3) {
N.p3 += v->renderCSGMesh().p3;
N.p3 += v->render_cgal_nef_polyhedron().p3;
}
v->progress_report();
}
@ -159,7 +153,7 @@ CSGTerm *AbstractNode::render_csg_term_from_nef(double m[20], QVector<CSGTerm*>
QTime t;
t.start();
N = this->renderCSGMesh();
N = this->render_cgal_nef_polyhedron();
int s = t.elapsed() / 1000;
PRINTF_NOCACHE("..rendering time: %d hours, %d minutes, %d seconds", s / (60*60), (s / 60) % 60, s % 60);
@ -267,12 +261,3 @@ QString RenderNode::dump(QString indent) const
return dump_cache;
}
std::string RenderNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
stream << "render(convexity = " << convexity << ")";
return stream.str();
}

28
src/state.h
View File

@ -1,28 +0,0 @@
#ifndef STATE_H_
#define STATE_H_
class State
{
public:
State(const class AbstractNode *parent)
: parentnode(parent), isprefix(false), ispostfix(false), numchildren(0) { }
virtual ~State() {}
void setPrefix(bool on) { this->isprefix = on; }
void setPostfix(bool on) { this->ispostfix = on; }
void setNumChildren(unsigned int numc) { this->numchildren = numc; }
void setParent(const AbstractNode *parent) { this->parentnode = parent; }
bool isPrefix() const { return this->isprefix; }
bool isPostfix() const { return this->ispostfix; }
unsigned int numChildren() const { return this->numchildren; }
const AbstractNode *parent() const { return this->parentnode; }
private:
const AbstractNode * parentnode;
bool isprefix;
bool ispostfix;
unsigned int numchildren;
};
#endif

19
src/surface.cc
View File

@ -31,10 +31,8 @@
#include "dxftess.h"
#include "printutils.h"
#include "openscad.h" // handle_dep()
#include "visitor.h"
#include <QFile>
#include <sstream>
class SurfaceModule : public AbstractModule
{
@ -46,15 +44,10 @@ public:
class SurfaceNode : public AbstractPolyNode
{
public:
SurfaceNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
QString filename;
bool center;
int convexity;
SurfaceNode(const ModuleInstantiation *mi) : AbstractPolyNode(mi) { }
virtual PolySet *render_polyset(render_mode_e mode) const;
virtual QString dump(QString indent) const;
};
@ -215,13 +208,3 @@ QString SurfaceNode::dump(QString indent) const
return dump_cache;
}
std::string SurfaceNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
stream << "surface(file = \"" << this->filename
<< "\", center = " << (this->center ? "true" : "false") << ")";
return stream.str();
}

48
src/transform.cc
View File

@ -32,8 +32,6 @@
#include "dxftess.h"
#include "builtin.h"
#include "printutils.h"
#include "visitor.h"
#include <sstream>
enum transform_type_e {
SCALE,
@ -55,15 +53,10 @@ public:
class TransformNode : public AbstractNode
{
public:
TransformNode(const ModuleInstantiation *mi) : AbstractNode(mi) { }
virtual Response accept(const class State &state, Visitor &visitor) const {
return visitor.visit(state, *this);
}
virtual std::string toString() const;
double m[20];
TransformNode(const ModuleInstantiation *mi) : AbstractNode(mi) { }
#ifdef ENABLE_CGAL
virtual CGAL_Nef_polyhedron renderCSGMesh() const;
virtual CGAL_Nef_polyhedron render_cgal_nef_polyhedron() const;
#endif
virtual CSGTerm *render_csg_term(double m[20], QVector<CSGTerm*> *highlights, QVector<CSGTerm*> *background) const;
virtual QString dump(QString indent) const;
@ -247,7 +240,7 @@ AbstractNode *TransformModule::evaluate(const Context *ctx, const ModuleInstanti
#ifdef ENABLE_CGAL
CGAL_Nef_polyhedron TransformNode::renderCSGMesh() const
CGAL_Nef_polyhedron TransformNode::render_cgal_nef_polyhedron() const
{
QString cache_id = mk_cache_id();
if (cgal_nef_cache.contains(cache_id)) {
@ -265,13 +258,13 @@ CGAL_Nef_polyhedron TransformNode::renderCSGMesh() const
if (v->modinst->tag_background)
continue;
if (first) {
N = v->renderCSGMesh();
N = v->render_cgal_nef_polyhedron();
if (N.dim != 0)
first = false;
} else if (N.dim == 2) {
N.p2 += v->renderCSGMesh().p2;
N.p2 += v->render_cgal_nef_polyhedron().p2;
} else if (N.dim == 3) {
N.p3 += v->renderCSGMesh().p3;
N.p3 += v->render_cgal_nef_polyhedron().p3;
}
v->progress_report();
}
@ -298,7 +291,7 @@ CGAL_Nef_polyhedron TransformNode::renderCSGMesh() const
ps.is2d = true;
dxf_tesselate(&ps, &dd, 0, true, false, 0);
N = ps.renderCSGMesh();
N = ps.render_cgal_nef_polyhedron();
ps.refcount = 0;
}
if (N.dim == 3) {
@ -375,32 +368,6 @@ QString TransformNode::dump(QString indent) const
return dump_cache;
}
std::string TransformNode::toString() const
{
std::stringstream stream;
stream << "n" << this->index() << ": ";
if (m[16] >= 0 || m[17] >= 0 || m[18] >= 0 || m[19] >= 0) {
stream << "color([" << m[16] << ", " << m[17] << ", " << m[18] << ", " << m[19] << "])";
}
else {
stream << "multmatrix([";
for (int j=0;j<4;j++) {
stream << "[";
for (int i=0;i<4;i++) {
// FIXME: The 0 test is to avoid a leading minus before a single 0 (cosmetics)
stream << ((m[i*4+j]==0)?0:m[i*4+j]);
if (i != 3) stream << ", ";
}
stream << "]";
if (j != 3) stream << ", ";
}
stream << "])";
}
return stream.str();
}
void register_builtin_transform()
{
builtin_modules["scale"] = new TransformModule(SCALE);
@ -410,3 +377,4 @@ void register_builtin_transform()
builtin_modules["multmatrix"] = new TransformModule(MULTMATRIX);
builtin_modules["color"] = new TransformModule(COLOR);
}

40
src/traverser.cc
View File

@ -1,40 +0,0 @@
#include "traverser.h"
#include "visitor.h"
#include "node.h"
#include "state.h"
void Traverser::execute()
{
State state(NULL);
traverse(state, this->root);
}
void Traverser::traverse(const State &state, const AbstractNode &node)
{
// FIXME: Handle abort
State newstate = state;
newstate.setNumChildren(node.getChildren().size());
if (traversaltype == PREFIX || traversaltype == PRE_AND_POSTFIX) {
newstate.setPrefix(true);
newstate.setParent(state.parent());
node.accept(newstate, this->visitor);
}
newstate.setParent(&node);
const std::list<AbstractNode*> &children = node.getChildren();
for (std::list<AbstractNode*>::const_iterator iter = children.begin();
iter != children.end();
iter++) {
traverse(newstate, **iter);
}
if (traversaltype == POSTFIX || traversaltype == PRE_AND_POSTFIX) {
newstate.setParent(state.parent());
newstate.setPrefix(false);
newstate.setPostfix(true);
node.accept(newstate, this->visitor);
}
}

26
src/traverser.h
View File

@ -1,26 +0,0 @@
#ifndef TRAVERSER_H_
#define TRAVERSER_H_
enum Response {ContinueTraversal, AbortTraversal, PruneTraversal};
class Traverser
{
public:
enum TraversalType {PREFIX, POSTFIX, PRE_AND_POSTFIX};
Traverser(class Visitor &visitor, const class AbstractNode &root, TraversalType travtype)
: visitor(visitor), root(root), traversaltype(travtype) {
}
virtual ~Traverser() { }
void execute();
private:
// FIXME: reverse parameters
void traverse(const class State &state, const AbstractNode &node);
Visitor &visitor;
const AbstractNode &root;
TraversalType traversaltype;
};
#endif

1
src/value.h
View File

@ -59,7 +59,6 @@ public:
bool getv2(double &x, double &y) const;
bool getv3(double &x, double &y, double &z) const;
// FIXME: stream support
QString dump() const;
private:

52
src/visitor.h
View File

@ -1,52 +0,0 @@
#ifndef VISITOR_H_
#define VISITOR_H_
#include "traverser.h"
class Visitor
{
public:
Visitor() {}
virtual ~Visitor() {}
virtual Response visit(const class State &state, const class AbstractNode &node) = 0;
virtual Response visit(const class State &state, const class AbstractIntersectionNode &node) {
return visit(state, (const class AbstractNode &)node);
}
virtual Response visit(const class State &state, const class AbstractPolyNode &node) {
return visit(state, (const class AbstractNode &)node);
}
virtual Response visit(const class State &state, const class CgaladvNode &node) {
return visit(state, (const class AbstractNode &)node);
}
virtual Response visit(const class State &state, const class CsgNode &node) {
return visit(state, (const class AbstractNode &)node);
}
virtual Response visit(const class State &state, const class DxfLinearExtrudeNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class DxfRotateExtrudeNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class ImportNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class PrimitiveNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class ProjectionNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class RenderNode &node) {
return visit(state, (const class AbstractNode &)node);
}
virtual Response visit(const class State &state, const class SurfaceNode &node) {
return visit(state, (const class AbstractPolyNode &)node);
}
virtual Response visit(const class State &state, const class TransformNode &node) {
return visit(state, (const class AbstractNode &)node);
}
// Add visit() methods for new visitable subtypes of AbstractNode here
};
#endif

16
test-code/dumptest.cc
View File

@ -30,7 +30,7 @@
#include "value.h"
#include "export.h"
#include "builtin.h"
#include "nodedumper.h"
//#include "nodedumper.h"
#include <QApplication>
#include <QFile>
@ -148,19 +148,17 @@ int main(int argc, char **argv)
QString dumpstr_cached = root_node->dump("");
if (dumpstr != dumpstr_cached) rc = 1;
printf(dumpstr.toUtf8());
#if 0
NodeDumper dumper;
Traverser trav(dumper, *root_node, Traverser::PRE_AND_POSTFIX);
trav.execute();
std::string dumpstdstr = dumper.getDump() + "\n";
std::string dumpstdstr = dumper.getDump();
trav.execute();
std::string dumpstdstr_cached = dumper.getDump() + "\n";
std::string dumpstdstr_cached = dumper.getDump();
if (dumpstdstr != dumpstdstr_cached) rc = 1;
if (QString::fromStdString(dumpstdstr) != dumpstr) {
printf(dumpstr.toUtf8());
printf(dumpstdstr.c_str());
rc = 1;
}
#endif
destroy_builtin_functions();
destroy_builtin_modules();

18
test-code/dumptest.pro
View File

@ -50,23 +50,11 @@ HEADERS += ../src/builtin.h \
../src/grid.h \
../src/module.h \
../src/node.h \
../src/dxflinextrudenode.h \
../src/dxfrotextrudenode.h \
../src/projectionnode.h \
../src/importnode.h \
../src/csgnode.h \
../src/openscad.h \
../src/polyset.h \
../src/printutils.h \
../src/value.h \
../src/progress.h \
../src/traverser.h \
../src/csgnode.h \
../src/visitor.h \
../src/nodedumper.h \
../src/nodecache.h \
../src/importnode.h \
../src/state.h
../src/progress.h
SOURCES += dumptest.cc \
../src/export.cc \
@ -95,6 +83,4 @@ SOURCES += dumptest.cc \
../src/dxflinextrude.cc \
../src/dxfrotextrude.cc \
../src/printutils.cc \
../src/progress.cc \
../src/nodedumper.cc \
../src/traverser.cc
../src/progress.cc