Solid modeling in Guile

Solid modeling in Guile

[Matthew Keeter]

Hi Guile-folks,

I wrote a computer-aided design (CAD) tool that you may find interesting.

It’s a solid modeling tool that uses Guile scripts to define objects (and
constructive solid geometry + functional representations under the hood).

Project page:  http://www.mattkeeter.com/projects/ao/
Source:  https://github.com/mkeeter/ao

I’d love feedback – Scheme is relatively new to me, so I’m sure there are
more elegant ways to accomplish a lot of what the code implements.

-Matt

Re: Solid modeling in Guile

[dsmich]

---- Matthew Keeter <matt.j.keeter@gmail.com> wrote: 
> Hi Guile-folks,
> 
> I wrote a computer-aided design (CAD) tool that you may find interesting.
> 
> It’s a solid modeling tool that uses Guile scripts to define objects (and
> constructive solid geometry + functional representations under the hood).
> 
> Project page:  http://www.mattkeeter.com/projects/ao/
> Source:  https://github.com/mkeeter/ao
> 
> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
> more elegant ways to accomplish a lot of what the code implements.


Wow.  That looks really awesome.  Looking forward to playing with it.

-Dale

Re: Solid modeling in Guile

[Mark H Weaver]

Matthew Keeter <matt.j.keeter@gmail.com> writes:

> I wrote a computer-aided design (CAD) tool that you may find interesting.
>
> It’s a solid modeling tool that uses Guile scripts to define objects (and
> constructive solid geometry + functional representations under the hood).

Sounds very interesting!

> Project page:  http://www.mattkeeter.com/projects/ao/
> Source:  https://github.com/mkeeter/ao

The names 'ao' and 'libao' are already taken by a widely-used cross
platform audio library.  See http://www.xiph.org/ao/

      Mark

Re: Solid modeling in Guile

[Alex Kost]

Matthew Keeter (2016-08-19 00:44 +0300) wrote:

> Hi Guile-folks,
>
> I wrote a computer-aided design (CAD) tool that you may find interesting.
>
> It’s a solid modeling tool that uses Guile scripts to define objects (and
> constructive solid geometry + functional representations under the hood).
>
> Project page:  http://www.mattkeeter.com/projects/ao/
> Source:  https://github.com/mkeeter/ao

Wow, this looks very impressive, and you have so many great projects!

> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
> more elegant ways to accomplish a lot of what the code implements.

You use ‘(- (inf))’ several times, it can be replaced with ‘-inf.0’.

From "bind/guile/ao/bind.scm":

--8<---------------cut here---------------start------------->8---
(define-module (ao bind))

(use-modules (srfi srfi-1))
(use-modules (ice-9 i18n))
(use-modules (system foreign))
--8<---------------cut here---------------end--------------->8---

Usually modules are defined like this:

--8<---------------cut here---------------start------------->8---
(define-module (ao bind)
  #:use-modules (srfi srfi-1)
  #:use-modules (ice-9 i18n)
  #:use-modules (system foreign))
--8<---------------cut here---------------end--------------->8---

From "bind/guile/ao/bounds.scm":

--8<---------------cut here---------------start------------->8---
(define-public (bounds-intersection bs)
    "bounds-intersection bs
    bs should be a list of '((xmin ymin zmin) (xmax ymax zmax)) lists
    Finds the intersection along each dimension
    If bounds are disjoint, returns empty interval (0, 0)"
    (let* ((lower (map car bs))
           (upper (map cadr bs))
           (xmin (apply max (map (lambda (b) (car b)) lower)))
           (ymin (apply max (map (lambda (b) (cadr b)) lower)))
           (zmin (apply max (map (lambda (b) (caddr b)) lower)))
           (xmax (apply min (map (lambda (b) (car b)) upper)))
           (ymax (apply min (map (lambda (b) (cadr b)) upper)))
           (zmax (apply min (map (lambda (b) (caddr b)) upper))))
    ;; Clamp intervals to empty (0,0) if bounds are disjoint
    (if (< xmax xmin)   (begin (set! xmin 0) (set! xmax 0)))
    (if (< ymax ymin)   (begin (set! ymin 0) (set! ymax 0)))
    (if (< zmax zmin)   (begin (set! zmin 0) (set! zmax 0)))
    (list (list xmin ymin zmin) (list xmax ymax zmax))))
--8<---------------cut here---------------end--------------->8---

All these cadr, caddr are hard to understand.  I would rather make some
level of abstraction for coordinates and bounds.  (if I understand it
right) the simplest would be:

--8<---------------cut here---------------start------------->8---
(define make-coordinates list)
(define x first)
(define y second)
(define z third)

(define make-bound cons)  ; bound of lower and upper coordinates
(define lower-coordinates car)
(define upper-coordinates cdr)

(define (extremum min-or-max coordinate coordinates)
  "Return minimal or maximal coordinate from COORDINATES.
MIN-OR-MAX is 'min' or 'max' procedure.
COORDINATE is either 'x', 'y' or 'z' procedure."
  (apply min-or-max (map coordinate coordinates)))
--8<---------------cut here---------------end--------------->8---

And now this 'bounds-intersection' can be written like this:

--8<---------------cut here---------------start------------->8---
(define-public (bounds-intersection bounds)
  "Finds the intersection along each dimension of BOUNDS.
If bounds are disjoint, returns empty interval (0, 0)."
  (let* ((lower (map lower-coordinates bounds))
         (upper (map upper-coordinates bounds))
         (xmin (extremum max x lower))
         (ymin (extremum max y lower))
         (zmin (extremum max z lower))
         (xmax (extremum min x upper))
         (ymax (extremum min y upper))
         (zmax (extremum min z upper)))
    ;; Clamp intervals to empty (0,0) if bounds are disjoint
    (when (< xmax xmin) (set! xmin 0) (set! xmax 0))
    (when (< ymax ymin) (set! ymin 0) (set! ymax 0))
    (when (< zmax zmin) (set! zmin 0) (set! zmax 0))
    (make-bound (make-coordinates xmin ymin zmin)
                (make-coordinates xmax ymax zmax))))
--8<---------------cut here---------------end--------------->8---

Actually using 'set!' for local variables is not considered a good
style, but, well, who cares :-)

Note that those 'first', 'second', 'third' procedures come from (srfi
srfi-1) module.

I'm not an expert, so do not consider this is the best (or even a good)
way.  I just wanted to point that instead of using lists, cars and cdrs
directly, it is better to have some higher-level procedures.

BTW, the indentation in .scm files is *very* unusual :-)

-- 
Alex

Re: Solid modeling in Guile

[Thompson, David]

Hello Matt,

On Thu, Aug 18, 2016 at 5:44 PM, Matthew Keeter <matt.j.keeter@gmail.com> wrote:
> Hi Guile-folks,
>
> I wrote a computer-aided design (CAD) tool that you may find interesting.
>
> It’s a solid modeling tool that uses Guile scripts to define objects (and
> constructive solid geometry + functional representations under the hood).
>
> Project page:  http://www.mattkeeter.com/projects/ao/
> Source:  https://github.com/mkeeter/ao

This is a really awesome project.  Just recently I was lamenting that
I didn't know how to use any CAD tools and was wishing that there was
one that used Guile.  Good timing!  The section of the website that
explains the advantage over software like OpenSCAD really resonated
with me.  It seems like a successful application of the Emacs design
philosophy to computer aided design.

Unfortunately, I haven't been able to build Ao because I can't get
CMake to find my glfw3.pc pkgconfig file.  PKG_CONFIG_PATH was set
appropriately as I use GuixSD which has no notion of the global /usr
directory.  Do you know how to explicitly tell the build system about
glfw3.pc?

> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
> more elegant ways to accomplish a lot of what the code implements.

I think so far you've done a great job, so consider the following
criticism to be of the "it would be really cool if..." variety.  I
watched the video of Ao in action, and while auto-reload of script
files is cool, it's no replacement for a REPL server.  So, in addition
to having that REPL attached to your terminal's STDIN/STDOUT, it's
possible to make a REPL server[0] in guile that listens on a port or
uses a UNIX domain socket.  This unlocks great hacking power for Emacs
users who can use Geiser[1] to connect to the REPL and write/eval code
directly from their Scheme buffers.  This kind of interaction is much
preferred over having to save and reload entire script files as it
allows for more incremental computation and a faster feedback loop.

Additionally, embedding Guile in a C/C++ application has become a
somewhat discouraged practice.  The recommended architecture these
days is to write the entire program in Guile and use the foreign
function interface to access C libraries (GLFW and friends, in your
case) when needed.  This would make Ao a Guile library in addition to
an executable, and having everything written in Guile means that users
can easily hack on any part of Ao from the comfort of their REPL
without having to edit C code and recompile.  There's a good article
written by Python programmers[2] that explains the advantages of
extending over embedding.  I don't know how feasible this is to do in
the case of Ao, but I've had good luck in the past transforming
software from an embedded model to an extended one.  The more code
that is written in Scheme the better!

Anyway, great work!  I hope I can get this to build at some point, and
if you ever make an official release please let us know so that
someone can package it for GNU Guix. :)

- Dave

[0] https://www.gnu.org/software/guile/manual/html_node/REPL-Servers.html
[1] http://geiser.nongnu.org/
[2] https://twistedmatrix.com/users/glyph/rant/extendit.html

Re: Solid modeling in Guile

[Ralf Mattes]

On Thu, Aug 18, 2016 at 05:44:46PM -0400, Matthew Keeter wrote:
> Hi Guile-folks,
> 
> I wrote a computer-aided design (CAD) tool that you may find interesting.
> 
> It’s a solid modeling tool that uses Guile scripts to define objects (and
> constructive solid geometry + functional representations under the hood).
> 
> Project page:  http://www.mattkeeter.com/projects/ao/
> Source:  https://github.com/mkeeter/ao
> 
> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
> more elegant ways to accomplish a lot of what the code implements.


Build fails over here: 

 ../kernel/src/eval/evaluator.cpp: In function ‘Interval clause(Opcode, const Interval&, const Interval&)’:
../kernel/src/eval/evaluator.cpp:805:36: error: ‘isnan’ was not declared in this scope
             return (isnan(a.lower()) || isnan(a.upper())) ? b : a;
                                    ^

This is with:

 /usr/bin/c++ --version
 g++-5.real (Debian 5.4.0-6) 5.4.0 20160609

and /usr/include/c++/5/cmath from the package libstdc++-5-dev:amd64
on a Debian Testing system.

But it looks very nice 


 Cheers, Ralf Mattes

> -Matt

Re: Solid modeling in Guile

[Matthew Keeter]

I added a cmath include and qualified isnan with std::,
try it out now and see if that fixes it (commit 61ce8e1).

-Matt

On Aug 20, 2016, at 9:23 AM, Ralf Mattes <rm@seid-online.de> wrote:

> On Thu, Aug 18, 2016 at 05:44:46PM -0400, Matthew Keeter wrote:
>> Hi Guile-folks,
>> 
>> I wrote a computer-aided design (CAD) tool that you may find interesting.
>> 
>> It’s a solid modeling tool that uses Guile scripts to define objects (and
>> constructive solid geometry + functional representations under the hood).
>> 
>> Project page:  http://www.mattkeeter.com/projects/ao/
>> Source:  https://github.com/mkeeter/ao
>> 
>> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
>> more elegant ways to accomplish a lot of what the code implements.
> 
> 
> Build fails over here: 
> 
> ../kernel/src/eval/evaluator.cpp: In function ‘Interval clause(Opcode, const Interval&, const Interval&)’:
> ../kernel/src/eval/evaluator.cpp:805:36: error: ‘isnan’ was not declared in this scope
>             return (isnan(a.lower()) || isnan(a.upper())) ? b : a;
>                                    ^
> 
> This is with:
> 
> /usr/bin/c++ --version
> g++-5.real (Debian 5.4.0-6) 5.4.0 20160609
> 
> and /usr/include/c++/5/cmath from the package libstdc++-5-dev:amd64
> on a Debian Testing system.
> 
> But it looks very nice 
> 
> 
> Cheers, Ralf Mattes
> 
>> -Matt

Re: Solid modeling in Guile

[Ralf Mattes]

On Sat, Aug 20, 2016 at 10:26:53AM -0400, Matthew Keeter wrote:
> I added a cmath include and qualified isnan with std::,
> try it out now and see if that fixes it (commit 61ce8e1).

Yes, it does fix the compilation problem.
There seems to be a problem with out-of-tree building (or isn't that
supported by ninja?).
When I start the build from <toplevel source>/build64/ everything compiles
fine but the ao-guile script ends up in <toplevel source>/bin and _not_ in
<toplevel source>/build64/bin where it should be ...
Strangely, libao.so ends up in the right place.

When I run the program I the program finishes with the following line:

 $ GUILE_AUTO_COMPILE=0 bin/ao-guile
 ....
 under certain conditions; type `,show c' for details.

 Enter `,help' for help.
 Ao> guile-2.0: Couldn't find current GLX or EGL context.

When I set  GUILE_AUTO_COMPILE=1 that same error shows up, but 
already during compilation (?!).
 
 $ GUILE_AUTO_COMPILE=1 bin/ao-guile
 ...
 ;;; compiling /usr/local/src/LISP/ao/bin/../bind/guile/ao/shapes.scm
 guile-2.0: Couldn't find current GLX or EGL context.

HTH RalfD


> -Matt
> 
> On Aug 20, 2016, at 9:23 AM, Ralf Mattes <rm@seid-online.de> wrote:
> 
> > On Thu, Aug 18, 2016 at 05:44:46PM -0400, Matthew Keeter wrote:
> >> Hi Guile-folks,
> >> 
> >> I wrote a computer-aided design (CAD) tool that you may find interesting.
> >> 
> >> It’s a solid modeling tool that uses Guile scripts to define objects (and
> >> constructive solid geometry + functional representations under the hood).
> >> 
> >> Project page:  http://www.mattkeeter.com/projects/ao/
> >> Source:  https://github.com/mkeeter/ao
> >> 
> >> I’d love feedback – Scheme is relatively new to me, so I’m sure there are
> >> more elegant ways to accomplish a lot of what the code implements.
> > 
> > 
> > Build fails over here: 
> > 
> > ../kernel/src/eval/evaluator.cpp: In function ‘Interval clause(Opcode, const Interval&, const Interval&)’:
> > ../kernel/src/eval/evaluator.cpp:805:36: error: ‘isnan’ was not declared in this scope
> >             return (isnan(a.lower()) || isnan(a.upper())) ? b : a;
> >                                    ^
> > 
> > This is with:
> > 
> > /usr/bin/c++ --version
> > g++-5.real (Debian 5.4.0-6) 5.4.0 20160609
> > 
> > and /usr/include/c++/5/cmath from the package libstdc++-5-dev:amd64
> > on a Debian Testing system.
> > 
> > But it looks very nice 
> > 
> > 
> > Cheers, Ralf Mattes
> > 
> >> -Matt
> 
> 

Re: Solid modeling in Guile

[Ralf Mattes]

One other thing,

your script (ao-guile) starts with a hash-bang "/usr/bin/env guile".
At least on Debian that might not work since guile might well be a link
to guile-1.8

Maybe you need to make the guile binary a configuration option?

 Cheers, RalfD

Re: Solid modeling in Guile

[Thien-Thi Nguyen]

[-- Attachment #1: Type: text/plain, Size: 603 bytes --]


() Alex Kost <alezost@gmail.com>
() Fri, 19 Aug 2016 12:29:46 +0300

   Usually modules are defined like this:

   (define-module (ao bind)
     #:use-modules (srfi srfi-1)
     #:use-modules (ice-9 i18n)
     #:use-modules (system foreign))

Minor correction: ‘s/#:use-modules/#:use-module/g’.

-- 
Thien-Thi Nguyen -----------------------------------------------
 (defun responsep (type via)
   (case type
     (technical (eq 'mailing-list via))
     ...))                              748E A0E8 1CB8 A748 9BFA
--------------------------------------- 6CE4 6703 2224 4C80 7502

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 197 bytes --]

Re: Solid modeling in Guile

[Mark H Weaver]

Mark H Weaver <mhw@netris.org> writes:

> Matthew Keeter <matt.j.keeter@gmail.com> writes:
>
>> I wrote a computer-aided design (CAD) tool that you may find interesting.
>>
>> It’s a solid modeling tool that uses Guile scripts to define objects (and
>> constructive solid geometry + functional representations under the hood).
>
> Sounds very interesting!
>
>> Project page:  http://www.mattkeeter.com/projects/ao/
>> Source:  https://github.com/mkeeter/ao
>
> The names 'ao' and 'libao' are already taken by a widely-used cross
> platform audio library.  See http://www.xiph.org/ao/

Following up to myself: the problem here is that since 'ao' is already
taken, distributions wishing to include your package will need to invent
a new name.  It might be better for you to choose that new name, to
prevent a situation where each distro picks a different name, which
would be rather confusing for users wishing to install your package.

To make this more concrete, I would like to add your package to GNU
Guix, where 'ao' is the aforementioned audio library.  What name shall
I choose for your package?

       Mark

Re: Solid modeling in Guile

[Matthew Keeter]

How about ao-cad?  That should be pretty unambiguous.

-Matt

On Sep 22, 2016, at 1:40 PM, Mark H Weaver <mhw@netris.org> wrote:

> Mark H Weaver <mhw@netris.org> writes:
> 
>> Matthew Keeter <matt.j.keeter@gmail.com> writes:
>> 
>>> I wrote a computer-aided design (CAD) tool that you may find interesting.
>>> 
>>> It’s a solid modeling tool that uses Guile scripts to define objects (and
>>> constructive solid geometry + functional representations under the hood).
>> 
>> Sounds very interesting!
>> 
>>> Project page:  http://www.mattkeeter.com/projects/ao/
>>> Source:  https://github.com/mkeeter/ao
>> 
>> The names 'ao' and 'libao' are already taken by a widely-used cross
>> platform audio library.  See http://www.xiph.org/ao/
> 
> Following up to myself: the problem here is that since 'ao' is already
> taken, distributions wishing to include your package will need to invent
> a new name.  It might be better for you to choose that new name, to
> prevent a situation where each distro picks a different name, which
> would be rather confusing for users wishing to install your package.
> 
> To make this more concrete, I would like to add your package to GNU
> Guix, where 'ao' is the aforementioned audio library.  What name shall
> I choose for your package?
> 
>       Mark