Publishing in Metadata, extending?

[kmsquire]

This package seems quite developed and potentially useful. Would you consider publishing it in METADATA.jl?

If you haven't seen it yet, I would also invite you to comment on the discussion happening at https://groups.google.com/forum/m/#!topic/julia-dev/vZpZ8NBX_z8.

Cheers!

[mroughan]

Hi,

I had hesitated to publish Geometry2D yet for a few reasons:
-- I was new to Julia when I started -- it was a an exercise I set
myself to help learn Julia, and to see how well it really worked -- so I
was concerned my code might not be top notch.
-- There are a couple more things to add -- I have a fairly well
developed convex hull routine but it isn't included yet. I wanted to get
it faster than Matlab's one, but Matlab actually have a pretty good
convex hull routine, so its taken a bit of work. Unfortunately, my day
job caught up with me before I got it into the package. Once that is
in, a few other useful algorithms are pretty easy to add.
-- back when I started, there was a problem with immutables. Should
be fixed now, but I am not running the latest version
see JuliaLang/julia#3651
If fixed then Points (and some other primitives) should be immutables I
think, though I don't know all the issues.
-- I haven't really done any documentation.
-- I haven't done enough testing (but can you ever do enough :)

I'm in the UK at the moment, but will be back in a week, and will make a
concerted effort to get a little bit more infrastructure into this and
publish it.

The big missing part of my code from my point of view was Delaunay
Triangulation/Voronoi diagrams, though there are many other pieces that
could be added. Triangulation is useful, but at least as hard as convex
hull code to write well, and I haven't done that one before so I would
be starting from scratch.

RE extending to nD, and different underlying coordinate systems. I
thought for a while about simply writing bindings for CGAL
https://www.cgal.org/, which might be the way to go for a more
professional package, but I didn't think I would learn as much about
Julia that way. But maybe it would make sense to start a more general
computational geometry package there?

RE coordinate systems, in an object oriented system, polar/spherical vs
Cartesian would be irrelevant. We would have constructors, and output
routines for whichever you need, but the underlying coordinate system
would be fixed. I don't know the best approach to this in Julia?
Perhaps it still isn't that hard?

On the other hand, RE homogenous coordinates, my goal with
parameterisation was eventually to have the Rational data types be a
type of homogenous representation, but I hadn't fully thought this
through as I don't really need it. So most of the routines are really
written for floating point, even though the rational parametrisation is
there. A lot of work is needed to make the code properly robust for
X{Rational}.

I haven't thought about Geographic coordinates at all. Mapping is a
really cool. But it would take a lot more effort to really build this --
my nascent efforts at playing with maps in the past have shown me that
there is a lot to it. There used to be some good open source places to
start though I don't have them at my fingertips.

In any case, my goal was to provide a simple to use, native Julia,
implementation that was fast enough to be used seriously. I didn't plan
to try to work on 3D or nD, but I would like to get the 2D code to the
point where it is a useful contribution for Julia users. Any thoughts on
that, or people who want to try it out (and see what breaks) would be
welcome.

Cheers,
Matt

On 8/07/2014 1:59 pm, Kevin Squire wrote:

This package seems quite developed and potentially useful. Would you
consider publishing it in METADATA.jl?

If you haven't seen it yet, I would also invite you to comment on the
discussion happening at
https://groups.google.com/forum/m/#!topic/julia-dev/vZpZ8NBX_z8
https://groups.google.com/forum/m/#%21topic/julia-dev/vZpZ8NBX_z8.

Cheers!

—
Reply to this email directly or view it on GitHub
#1.

[sjkelly]

IIRC, CGAL uses C++ templates so Julia cannot call it yet. I believe Keno Fischer is working on making this a possibility. That said, I think it is an interesting exercise to write the algorithms in Julia. There are some commonly used algorithms in computational geometry which have had few implementations. Personally, I think it is highly valuable to make implementations in Julia since it opens up interesting avenues for extensibility and modification which might not be possible in tightly integrated libraries.

Also, @kmsquire I've done some work on polygon clipping and I would be happy to have it become part of a computational geometry package. I was hoping to get it into METADATA.jl soon, but I will hold off if we can integrate it into a larger project. @mroughan there is some overlap between our two packages, but the data structure for PolygonClipping.jl is pretty complex.

Link to the PolygonClipping package: https://github.com/sjkelly/PolygonClipping.jl

[mroughan]

On 8/07/2014 11:27 pm, Steve Kelly wrote:

IIRC, CGAL uses C++ templates so Julia cannot call it yet. I believe
Keno Fischer is working on making this a possibility. That said, I
think it is an interesting exercise to write the algorithms in Julia.
There are some commonly used algorithms in computational geometry
which have had few implementations. Personally, I think it is highly
valuable to make implementations in Julia since it opens up
interesting avenues for extensibility and modification which might not
be possible in tightly integrated libraries.

Also, @kmsquire https://github.com/kmsquire I've done some work on
polygon clipping and I would be happy to have it become part of a
computational geometry package. I was hoping to get it into
METADATA.jl soon, but I will hold off if we can integrate it into a
larger project. @mroughan https://github.com/mroughan there is some
overlap between our two packages, but the data structure for
PolygonClipping.jl is pretty complex.

Link to the PolygonClipping package:
https://github.com/sjkelly/PolygonClipping.jl

Sounds cool. I was imagining doing polygon intersection by triangulation
and convex intersection (for which convex hulls is a pretty good
starting point).

My biggest issue for this sort of thing was I haven't really dealt with
complex polygons, e.g., with holes. I guess that is what makes your data
structures more complex?

I hadn't thought about the C++ issue. I had used the C bindings and
assumed that C++ wasn't much harder, so forget that for the moment. And
I agree that a native Julia version would be really useful, if only
because then its a hell of a lot easier for people to understand how it
works, and add to it.

As I said, I'm away at the moment, so I can't easily modify the code. If
you can wait a couple of weeks, I can have a new version up on GitHub. I
could also add you to the current repo if you'd like?

Cheers,
Matt

[sjkelly]

@mroughan @kmsquire Sorry for the delayed reply. I think the best thing for interoperability is to define some convert and promote methods. This way we don't sacrifice high performance data structures but also can still afford to have transparent data structures facing the user. I am going to experiment with design of conversions and promotions between PolygonClipping.jl and MeshSlicer.jl.

If you could add me to this repo that would be great. Once I have a complete feature set in PolygonClipping I can start to merge the code here. Maybe we want to shoot for getting the package under the JuliaGraphics organization?