This is a curious challenge jon,

I am a retired (well almost!) teacher and I can see a lot of value in
trying to encourage students with young agile minds to exercise their
potential with this kind of thinking.  To me it a great fusion of
abstract mathematics with reality ie  3D shapes and it can be printed
out as an object.  The various arguments put forward about how to extend
the language in a productive way always on these discussion groups, make
very interesting reading to me, however my understanding of matrix
algebra has always been primitive, so I get lost easily.  Thanks to all
those who discuss and explore the many and varied topics at length.

I would like to encourage my current students to use openSCAD, and to
that end, I will be producing a number of short tutorial work sheets
that may be of use to other beginners, or maybe even people in Jon's
situation, needing a starting point to introduce the benefits of this
way of thinking at a very low entry point. So would these worksheets -
come challenges, be a useful starting point for beginners to see the
potential of openSCAD?  I am happy to contribute my efforts so far and
over the next few weeks submit a few more???

I find openSCAD some what challenging like a crossword or a jigsaw
puzzle, only at the end, one can print it out and have some of value at
the end that is really unique!!!  Students respond very positively to
this sort of thing.

In short, should we have a "kids" section for openSCAD?

Cheers, Rob

On 01/10/16 04:05, jon wrote:

--

Rob Ward
Lake Tyers Beach, 3909
Lake Tyers Beach Website http://www.laketyersbeach.net.au
XP to XUbuntu http://www.laketyersbeach.net.au/XP2XU.html

On 10/01/2016 11:02 AM, Rob Ward wrote:

That would be awesome. Maybe it could be the beginning of
a tutorial next to the manual?

There are great resources scattered around on the web, as
Blog posts or on Thingiverse. Some of those with licenses
that confuse me (e.g. what about people who want to use
OpenSCAD to create a 3d printer design they want to sell.
Are those people allowed to use the code from CC-NC
tutorials? What about Makerspaces wanting to use it in
courses that have an entry fee? I don't know... ).

I always wanted to get something like this going, but I
don't have the didactic knowledge to give it a good
outline where one topic leads to the next. This means I'm
always getting stuck trying to sort the things to
discuss. The quite sad looking page with some notes is
gathering dust at
https://github.com/openscad/openscad/wiki/Ideas-for-Tutorial

Yes, please!

We could start with a single page, similar to the tips &
tricks page at
https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Tips_and_Tricks
and start moving things to sub-pages once it grows.

ciao,
Torsten.

Doubly awesome, with an extra helping of awesomeness on top 😀 I'm teaching a course, Foundations of Computing, and my one indulgence is a module on 3D printing (which I have justified/rationalized because OpenSCAD is programming-based). So any resources that would help a group of decidedly non-programers be able to use this package would be great.

Michael

Thanks for the encouraging response Torsten.  Over the next few weeks I
will be following up last term's work and building on my small
collection of 2 worksheets.  I am not full time and at the moment just
finding out what depth of projects suits students. Plus building in a
way for the teacher to monitor student's progress is also a useful
addition (ie just adding sign-off points strategically placed in the
document as the project is developed), and should not be obtrusive for
someone doing self instruction.

I am hoping that we will be able to publish these in a wiki manner where
they can be polished up by others as time goes on.  I can see parents
being enormously impressed if their child began working productively
with openSCAD, I know I would be (even though mine are now +35 years
old, haha). I will need help with the publishing process to ensure this
goal is accomplished.  I am not expecting many tutorials at this level
will be required as once a child's imagination takes off, much of the
existing helpful information will kick in.

Cheers, stay tuned,

Rob

On 02/10/16 07:28, Torsten Paul wrote:

--

Rob Ward
Lake Tyers Beach, 3909
Lake Tyers Beach Website http://www.laketyersbeach.net.au
XP to XUbuntu http://www.laketyersbeach.net.au/XP2XU.html

jon_bondy wrote

But once you have that complex script, changing bits of it such as the wall
thickness, the overall size or the number of doobries in the whatsit is a
simple editing exercise.

It can also be effectively held in version-control systems.

tp3 wrote

The answer is to contact the author and ask them. Most of the stuff I
produce (nothing relevant to here yet) have CC_BY_NC licenses because I
don't want someone else making money from work I am giving away free.
However if someone wanted to offer me a reasonable cut, or if their case was
charitable or their use was negligable, I would be more than willing to give
them a commercial license.

mprogers wrote

Have you considered that OpenSCAD is to all external purposes a Data Flow
language that bears striking similarities to languages such as SISAL? (In
fact making OpenSCAD more like SISAL would be wonderful -- there's more
orthogonality and more powerful structures there, but little chance of it
happening.)

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18511.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

free.

Why? If you aren't intending to make money from it yourself, why stop
others?

On 3 October 2016 at 10:19, Richard Urwin soronlin+openscad@googlemail.com
wrote:

nophead wrote

It's complex.
I could say that if you were working in a soup-kitchen, you would be
displeased to find that people were taking your food and selling it on. But
software is not an expendable resource so the analogy fails. To reach the
real argument we need to get into more esoteric language.

The CC/GPL/whatever is the basis of a gift-economy. In such an economy,
status is gained by giving stuff away. You see it in Beowulf, where the king
gives his favoured warriors gold rings. I have put time, energy and
expertise into generating a product with worth. It must have worth, or you
would not want to use it. I give this away for no cost because it pleases me
to help other people and in return I receive recognition. The people who
receive it recognise that it is a gift with worth. The fact that it is free
has value to me.

So imagine that you were running that soup-kitchen in the basement of an
apartment block and you hear that the landlord is advertising that the
apartments come with a free restaurant and thereore gets more applications
and can charge higher rents. You might feel that this is wrong. You might
tell him that you are slaving away in that kitchen for hours and that work
has a value that he would otherwise have to pay for. You would be happy to
provide restaurant services to his tenents for a reasonable sum, and if they
were to find their way to you on their own you would be happy to feed them,
but he should not be making money off your free gift.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18513.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On Mon, 3 Oct 2016 03:59:51 -0700 (MST)
Richard Urwin soronlin+openscad@googlemail.com wrote:

GPL is a commons economy which is not the same thing as a gift economy at
all.

The examples you probably want are the BSD/MIT style licences.
</pedant>

Alan

Alan Cox wrote

Some people like to give anonymously. They still take value from their
giving.

Alan Cox wrote

While the GPL license doesn't forbid it explicitly, it is widely considered
the height of bad manners to remove an attribution from a GPL'd file.
http://www.catb.org/esr/writings/cathedral-bazaar/homesteading/ar01s03.html

The choice of the license is not a choice of economy; it is a pragmatic
evalutation of the forces at play in a particular scenario. I have certainly
used public domain when my input was low and I felt that demanding an
attribution would be burdensome. I still received benefit from that initial
post. I have used attribution-only licenses when my input was larger but
many of the users I wanted to benefit would  be commercial and, in so doing,
knowingly gave up any rights to profit. I have used BSD, GPL, LGPL, various
versions of CC and all-rights-reserved on a case-by-case basis in order to
protect my brand and intellectual property while benefitting the maximum
number of people. That is a gift economy.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18515.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

Making soup is nothing like making software.

Once you wrote a piece of code (should I called it a "soup recipe" ?), it
is eternally useful - while probably also broken to some extent of course -
without the need for you to continue working on it. That specific version
can benefit people without any further input from you. So the comparison to
the "slave soup maker" is not fair, even if there's future economic
activity based on your piece of freely distributed code (recipe).

The comparison to soup making would be fair if you were talking about
software maintainance. I.e. if you were talking about a programmer who
continuously provides the service of tweaking, improving, bugfixing,
packaging, etc. For that kind of work there are indeed companies hiring
developers/maintainers/packagers and paying them to develop and maintain
free software. So, the "soup maker" is paid for the service of actually
preparing soup on a daily-basis. The obvious name that comes to mind is
RedHat. But there are plenty of other companies that also work that way
nowadays.

Off course, there must be plenty of soup makers in the world still
complaining that someone "stole their soup recipe". But that's not the
point.

On Mon, Oct 3, 2016 at 7:59 AM, Richard Urwin <
soronlin+openscad@googlemail.com> wrote:

Felipe Sanches wrote

Your soup recipe analogy fails because a recipe, in its fundimental parts,
would probably be subject to patent, not copyright. The expression of the
recipe on a page is of course copyrightable and by all means try selling
photocopies of Jamie Oliver's recipes and see where you find yourself.

It is a feature of copyright that a work created once can be monetized over
time. Nobody much argues against copyright in books or music, why would it
be a bad thing for software?
Software would never be profitable if the first sale ever made must pay back
all investment. They sell many copies and reap the profits over time. Few
people would argue that pirating music, video or books was legitimate.

Similarly, when I give away one copy of a work, I do not achieve much
increase in respect and I have not helped many people. It is only by giving
away many copies over an extended time that I achieve value. It is precisely
analogous to the monetary profit achieved by mainstream authors and
musicians.

Let's suppose the slave in the kitchen made all the meals for a year and
sealed them away in a magic stasis bubble before a single customer received
one. The work has still been done and the value will still be received in
the thanks of the customers over that year. The fact that the work has been
completed does not mean that the creator has or should forfeit all interest
in it.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18517.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On 10/03/2016 11:19 AM, Richard Urwin wrote:

I'm sorry, but no, that's is not the answer. We might talk
about quite different things though. I'm talking about the
code snippets shown in tutorials/books, NOT about the whole
tutorial or the whole book.

If you are not prepared to let people use code snippets given
as learning examples, what's the point at all?

I would like the OpenSCAD documentation and very much specifically
tutorials useful for education to be usable in any way. I've
seen quite a number of references to OpenSCAD used by teachers
and that's what I want to support. And I want them to use the
stuff without even a remote risk of someone saying "you need
the school lawyer to acquire a license before you can use it".
(Yes, may still happen, there's no ideal world yet, but that's
not the point).

It really bothers me how the big companies are pushing their
proprietary apps into schools like Apple did lately with their
Swift app. In my view applications like SonicPI should be
selected for education. It would be awesome if OpenSCAD could
become a good option too, but for that to happen, we will
need to help by providing at least a fair amount of initial
documentation/tutorials for that.

Anyway, we are using Wikibooks for the official docs, so the
license of that documentation must be CC-BY-SA and GFDL
anyway as that's what Wikibooks enforces.
I'm simply proposing the additional release of all the
included code snippets to be public domain / CC0 so that
code can be used without restrictions (which is allowed by
Wikibooks as far as I read the related Wikibooks docs).

ciao,
Torsten.

tp3 wrote

Which is why I have used waivers like this one:
"Unless I say otherwise in a particular instance, I hereby waive all
personal copyright interest in all code and methodology examples I publish
on the following sites: ..." -- http://www.wikidot.com/user:info/rurwin

It would be nice if book authors did the same.
The answer is still correct though: talk to the author. If they can give you
a letter formally giving you permission to use code snippets then you would
be safe. Of course a mainstream published  book has more interested parties
and you would be unlikely to get a clear enough answer for your needs.
That's a pain.

I have a nice little program I put together to monitor both sides of a
serial conversation. Along with a special cable it's very useful for
bebugging protocol issues. However it is built on top of a code example that
shipped with Microsoft's Visual Studio. I can't distribute it to anyone who
doesn't have a Visual Studio license. It's annoying but it's the price you
pay.

You could write out the examples in your own words. Just like the soup
example above, a program is only copyrightable in its creative content. So
long as you rewrite it from memory and change the names and maybe the order
of statements, you will be safe.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18519.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On 10/03/2016 04:58 PM, Richard Urwin wrote:

Perfect, that's essentially what I'm proposing for the code
examples in the ("official") tutorials.
Although due to German law I can't just waive the copyright,
so I have to declare it CC0 and hope that works.

See? And I absolutely don't want teachers to pay that
kind of price when trying to use OpenSCAD documentation.
Because I suspect in 98% of the cases it will just mean
it's not used at all. And that the worst option.
If someone decides to make other great documentation with
a different license, that's cool, and I'm still happy about
it existing. However, I won't contribute to that.
Like there's an Udemy course about OpenSCAD which is
currently available for 19€ and I saw someone mentioning
it is well done. That's nice to have, nothing wrong with
additional options.

ciao,
Torsten.

On 10/04/2016 04:12 AM, MichaelAtOz wrote:

Yes, but that's different in various legislations and I also
expect the more advanced parts of the tutorial to very likely
reach the limit to be accepted as original work (at least in
German law).

So why take any chances? A clear statement of intention also
has a certain value.

ciao,
Torsten.

I’ve been looking into ways of using OpenSCAD as a dataflow language, but I haven’t looked at SISAL in particular.
Most of the concepts in OpenSCAD should be pretty well mappable to a dataflow or flow-based programming graph. It would be interesting to look into isomorphic representations, where text-based and a flow graph could just be two different editing modes.

So far I’ve temporarily shelved all of this in search of more resources to get this off the ground, but take a look at e.g. Antimony, which has combined flow-based programming with an f-rep kernel to achieve smth. very similar.

-Marius

Marius said: "It would be interesting to look into isomorphic
representations, where text-based and a flow graph could just be two
different editing modes."

I've thought about this too, although from my perspective it would be
difficult to pull off[*]. Still, if someone manages to do it, it could be
awesome.

[*] The difficulty is that the text based representation might contain
information that isn't contained in the graphical flow chart, and vice
versa, so what does the file format look like, how human readable is it,
what happens to this information when you switch between views in the
editor. An Antimony-like flow graph might contain X-Y coordinates for each
block. If the flow graph is a directed acyclic graph, as in Richard's
writeup, then the text version will need to introduce variable names and
let blocks that aren't needed by the graphical view.

Antimony avoids these issues because the flow graph and the programming
language representation are two different file formats.

As for SISAL, my impression is that it doesn't have too much to do with
Antimony-style visual programming. Instead, I view it as "functional
programming for Fortran programmers". In SISAL, there is a big emphasis on
compiler technology (automatic parallelization for SMP architecture
machines and efficient code generation), and there is also a lot of
language design focused on providing a convenient and efficient way to
write loops for array based code without using recursion or other
functional programming design patterns. But SISAL is still a functional
language (in the same sense that OpenSCAD is): functions are pure and
referentially transparent, with no side effects; there are no mutable
global variables; variables are single-assignment.

On 4 October 2016 at 16:29, Marius Kintel marius@kintel.net wrote:

On 2016-10-05 01:38, Richard Urwin wrote:

Agreed. This is why the text-based approach in OpenSCAD is a good idea.

Carsten Arnholm

as a "language" graphical languages may have issues but I think the idea
behind the original post was:

it would greatly help usability and productivity in OpenSCAD (for making
arbitrary objects) if there were snap-to capabilities (vertices, centers of
faces, cetroids of solids).  I've been musing on this just about every day
I use OpenSCAD.

The math / programming aspects of OpenSCAD are nice for making math based
shapes, visualizing equations, etc.

But if you have an arbitrary idea for an object in your brain snap to
capabilities and the like (such as offsets from snap to in various units)
and a bigger variety of primitives would be a big help.  And drawing
capablities would also help.

Another way to approach it is some kind of "marriage of tools" where one
CAD suite provides that and OpenSCAD concentrates on the math side but both
can import / export from each other.  If you were importing into OpenSCAD I
would fully expect that the autogenerated code or whatever would look
horrible.

I have fun using OpenSCAD but also find it very frustrating and tedious at
the same time, marrying it with some other Open source CAD tool (which
works more graphically) would greatly increase productivity for the end
users.

On Wed, Oct 5, 2016 at 3:45 AM, arnholm@arnholm.org wrote:

On 10/06/2016 01:25 AM, Dan Shriver wrote:

More primitives is basically a matter of a maintained
library providing those. There is no real need for the
core to provide that directly.

In general, that's not going to work easily (well, you can
just import files generated by other tools, but I don't
count that as "easy"). I do have some ideas regarding
LibreCAD and 2D sketching. If that ever is going to happen,
I don't know. With the long list of open topics and the
available amount of time, the reasonable guess is
unfortunately: not anytime soon.

ciao,
Torsten.

tp3 wrote

I was musing today on extending the language of OpenSCAD by writing my own
compiler and outputting pure OpenSCAD code, much like early C++ compilers
(properly translators or transpilers) output pure C code. That introduces
another step where you have to write your file, translate it to OpenSCAD and
then load the result into OpenSCAD.

However OpenSCAD already makes some of that transparent. It watches the
source file and when it changes it automatically reloads it. Of course that
makes the extra translation step even more obvious to someone used to just
writing the file out and seeing the result.

So how would it be if OpenSCAD had an ability to watch the source file and
then run a configurable script on it before loading the result of that
script. There's various levels of doing that, from a script that is blindly
run on all files, to something that can treat files differently based on
their extensions with macros for the filenames involved. A modular first
hack should be simple to produce and then others with more interest could
extend it as required and send pull requests.

Then OpenSCAD could continue doing what it does and anyone with other ideas
could implement them as simple text-to-text filters without needing to
implement complex GUIs or rendering pipelines.

Another advantage is that the built-in OpenSCAD editor would transparently
work on the real source-code and the ugly autogenerated OpenSCAD code would
never be seen. Of course any errors in that OpenSCAD code would refer to
lines that the user never saw, but a competent compiler should never produce
erronious code.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18556.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On 2016-10-06 01:40, Torsten Paul wrote:

To get profiles freom LibreCAD would be nice.

I have been experimenting with extracting 2d profiles from hand
drawings, so they can be used to obtain 3d-printable models.
See for example
http://www.printrbottalk.com/forum/download/file.php?id=11168

In this case the drawing was scanned to .png using a flatbed-scanner.
The image was slightly manipulated before it was processed in some
experimental code to generate 2d polygons representing outer and inner
contours respectively. That's all you need for generating data to be
extruded into 3d.

Obviously this works also when the image is not a hand drawing.

Carsten Arnholm

Or a tool that allows you to position Bezier handles which are then
converted to smoothed lines and then imported into OpenSCAD

Jon

On 10/6/2016 7:33 AM, arnholm@arnholm.org wrote:

On 10/06/2016 01:12 PM, Richard Urwin wrote:

Nothing wrong with that, people have done that before and
I guess there always be use cases where that's the best
option.

But as always, I'm curious... Why? Which feature?

The other option is to help making OpenSCAD itself better
which will then can benefit everyone who uses it.
Yes, it's more complicated to work together and find
solutions that don't break existing stuff, and yes that
can be frustrating at times, but there's also lots of
things to gain. There's lots of effort going into making
OpenSCAD usable by providing ready to use packages (not
only those on the homepage, but also for lots of Linux
distributions), responding to issues here and on github,
documenting stuff and so on. So while writing code is
obviously an important part, all those other topics and
all the people helping with that are even more important
for an (open source) application to live on.

I see how that could be a powerful thing, but also sounds
very much like a support nightmare (even without thinking
about cross-platform issues).

ciao,
Torsten.

On 10/06/2016 01:33 PM, arnholm@arnholm.org wrote:

Nice, what was used for the image->vector conversion?
The "some experimental code" sounds like it's not using
any existing tool or library?

We still need to work out some of the details, but
https://github.com/openscad/openscad/pull/1110 should
be able to handle at least the simpler cases using
the potrace library.

ciao,
Torsten.

On 10/06/2016 01:49 PM, jon wrote:

Not integrated, but still nice way to just draw polygon:

http://daid.eu/~daid/3d/

source: https://github.com/daid/OpenSCAD-polygon-editor

ciao,
Torsten.

Thank you, Torsten, but this "tool" is not documented sufficiently for
me to even understand where to start.

Jon

On 10/6/2016 1:05 PM, Torsten Paul wrote:

Interesting idea, Richard.

A couple of thoughts....

OpenSCAD would need to monitor the "precompiler" source code, not the
OpenSCAD source file generated by the precompiler, for your idea of
automatically running a script beforehand. Or would the script generate a
temp file to be read by OpenSCAD itself?

It's already common for people to write Python scripts to generate OpenSCAD
source. What's the benefit of yet another super-OpenSCAD language? Or were
you thinking of something like the way PHP embeds chunks of HTML?

This can be done now by using an IDE or something like NotePad++ to manage
the source editing, and on command run the precompiler script to generate
the .scad file which in turn would trigger OpenSCAD to reload it. There's
no need to see the ugly generated code... you can tell OpenSCAD to hide its
editor window.

Frank

On Fri, Oct 7, 2016 at 6:30 AM, jon jon@jonbondy.com wrote:

On 06. okt. 2016 18:58, Torsten Paul wrote:

No, it is a new library + application I have been playing with lately to
do this. It is experimental as noted but solves some difficult examples
already. It does not use any pre-existing tool or library (just
wxWidgets for the application GUI).

Another example, this time a famous logo:

The starting point, a B/W image
https://gyazo.com/5a256235cf21905c5946a4971c50e2ed

The white areas are triangulated into a mesh (home-grown triangulator).
Rather dense triangles in this case:
https://gyazo.com/79195935193fa14ff73e725e0807f4e8

The contours are identified from the mesh, note the colours of the inner
and outer contours, it is automatic
https://gyazo.com/c048ff34f3a1599ddc9234f9775ec3ac

The contours are exported as Angelscript source code and extruded in my
CSG application (using carve for 3d booleans). Below is OpenSCAD used as
a viewer of the resulting polyhedron:

Linear extrude
https://gyazo.com/bae667e63d29c7526d59b99693f7f7af

Rotate extrude (20 degrees)
https://gyazo.com/52a0cef818160c151b9b9b4c86762ef5

It would no doubt be possible to use the exact same approach to export
to .scad format and let OpenSCAD do the extrusions, but I have not done it.

I had a quick look at the potrace algorithm now, since you mentioned it.
http://potrace.sourceforge.net/potrace.pdf
Nice paper, the approach is quite different from mine, but some very
good ideas there.

Originally, I had a similar idea as your trace(...) command of
integrating image->vector conversion into my CSG application, but now I
think it really is impractical because the conversion needs to be
inspected and possibly redone with other parameters before it can be
accepted and used in a 3d model. So I found it easier to handle it
separately as shown above. The result is easy to integrate with other
modeling code since the profiles become source code functions returning
2d shapes (equivalent to an OpenSCAD module), you just copy/paste the
generated functions.

The potrace integration idea is nice but I suspect it might be subject
to difficult user issues if integrated too tightly.

I have briefly used potrace with OpenSCAD in the past
http://arnholm.org/a-reverse-3d-printing-experiment/, but I didn't know
the algorithm used by potrace.

Just my thoughts.

Carsten Arnholm

On 10/06/2016 09:17 PM, Carsten Arnholm wrote:

Yeah, looks like both approaches give quite good results.

I think it's more a matter of scope. It's not intended to
cover all possible cases giving thousands of parameters. It's
supposed to "just work" for the simple/normal case. For
everything more advanced, I agree that a separate, specialized
application is a better choice.
I do expect it to work well for simple scanned sketches and
could reduce the effort to base a design on that quite a bit.

ciao,
Torsten.

frankv wrote

Yes.

In this case, no; this would be a complete compiler, at least initially, for
my own delictation. Although I do have an application already written that
would do exactly that.

And I do elsewhere; save-make-run is a normal part of programming. It would
just be nice not to have to do it.

Doesn't everyone? ;) I was just pointing out how transparent it would be for
very little effort.

tp3 wrote

Granted, and I might. But there are other gains in working alone on a
private project, such as not having to convince everyone you have a good
idea before you try it out and find it is rubbish.

--
View this message in context: http://forum.openscad.org/Fusion360-and-OpenSCAD-tp18493p18581.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

On 10/06/2016 10:04 PM, Richard Urwin wrote:

Just trying something is actually very simple when using
OpenSCAD as base. Creating a new node that does something
new is quite easy, e.g. I had a python() node that could
generate geometry working in a couple of hours and I mostly
had to fight with the actual python interpreter calls.
The neat thing is that it's possible to reuse all the
existing parser and viewer code without even having to
look at it.
It's only getting a bit more complicated when integrating
new modules as it's hard to change language syntax once
it's out in the wild.
(e.g. https://github.com/openscad/openscad/pull/1380)
But it pretty much all the cases the result of the
discussions is a better solution, even if it takes some
time.

Anyway, I'm just asking because it's a bit sad seeing
all those dead pyscad projects (just an example, but I
feel there are at least 10 different ones with that name)
with description "Make better OpenSCAD and work around
limitations" with maybe 100 commits from some years ago.
Yep, there's lots of things that need improvement, and
at least some of those don't need a separate project.

As said before, it's not wrong to start a project like
that, it's very likely there's lots of things to learn
and that a good thing. But it's also very likely the
project is dead a couple of month later.

ciao,
Torsten.

potrace is an excellent tool for this and you can see a good example of
its integration into inkscape code.

Which is where I use it to generate openscad files direct for export
from vector linework. Of which inkscape is an excellent tool

On 10/7/2016 8:46 AM, Torsten Paul wrote:

Or you allow it to run as a command line in a pipe (which for some of the
other tools is the only way to do it)

I actually go to the trouble of generating nice code with proper
indentation from my tools. In the longer term I've found it pays off
repeatedly when you need to take tool output and debug it, or when you
want to take tool output and hand tweak it for a special case.

It would also not be hard to write an "indent" for openscad 8)

Alan

FYI: The OpenSCAD development snapshot has experimental support for direct SVG import. It’s still experimental - we need more people testing this and commenting on how it fits their use-cases.

-Marius

You could solve your problem by running a separate tool that watches your
source file, and invokes your language->OpenSCAD compiler when the source
file changes.

There are lots of tools like this available on the internet. Here's one
option:  http://entrproject.org/

There's no need to build this tool into OpenSCAD.