For consistency with cones and for a cleaner interface, we should also build a dataclass for planes, like we did for cones. Such a class could also host alternative constructors, if necessary in the future. For planes, these already exist at some points, because we use two ways of specifying planes: with parameter d or with a point on the plane.

Filtering is currently too slow (hence the need for tqdm progress bars). Make faster somehow.

We could add an object tentatively called an open cone, which would be a cone with no height, i.e. one that extends infinitely into one direction. Such an object has one parameter less than the Cone. The radius and the height (both meaningless for this infinite object) are replaced by the single opening angle parameter. The fact that there is one less parameter, may make fitting easier. In the case of sundials, this is then the preferred option, since it does not actually make sense to limit the cone in height and radius, as we must do now.

We need a notebook (or several) to showcase ectopylasm functionality. It/they should do at least the following:

• Notebook 1
  • Download Sundial data
  • Load it
  • Visualize the points
  • Filter out a plane section
  • Visualize filtered points
  • Fit a Plane shape to that filtered out section
  • Plot the shape together with the filtered points
• Notebook 2
  • Fit a Cone shape to some points (maybe generated, don't know which data source to use for this)
  • Plot the shape together with the filtered points

After doing a fit to a plane or a cone, we want to be able to project the points to the nearest place on this shape. This will allow further two-dimensional analysis of e.g. lines or other carvings in this structure.

Inspired by the NormalDist.from_samples() syntax, I think it would be nice if the shape classes could have constructors that take a point set as input, fit to that point set, and use the best fitting parameters to make the new shape. It would look like this:

from numpy.random import random, normal
from ectopylasm import Plane

N = 1000
xyz = (random(N), random(N), normal(0, 0.01, N))

plane = Plane.from_points(xyz)

It's not actually Figures that are returned from the ipyvolume functions. Change the names so that they make more semantic sense.

Loading PLY files is slow at the moment. We can speed this up by loading once with plyfile and then only saving the vertex coordinates in some other format, e.g. HDF5. This way we can skip loading the faces.

When fitting to a plane, symfit throws a warning, because there is a conceptual issue with the way we're doing the fit, as described here: tBuLi/symfit#256

While that issue remains open, we should somehow block the warning from the ectopylasm side, since the issue is understood and should not be warned about.

Now the output of the filter_points_ functions are lists of arrays, which is really cumbersome to work with. Change this to output dataframes, similar to the dataframe that is used as input.

I forgot to write tests for the cone functions when I changed the interface to use Cone objects, violating my own unwritten rule about when to absolutely write tests (i.e. when you change a function). Do it anyway!

This may improve fitting, since these are a lot easier to interpret. Also visual / manual fitting might be easier with these parameters than by fiddling around with angles. This is probably the reason Mathematica uses these construction parameters instead of the set we currently use (height, radius, two angles, base position x, y, z). Note that in both cases we have 7 parameters for the cone.

For consistency with cones and for a cleaner interface, we should also build a dataclass for planes, like we did for cones. Such a class could also host alternative constructors, if necessary in the future. For planes, these already exist at some points, because we use two ways of specifying planes: with parameter d or with a point on the plane.

We would like to be able to (automatically) fit to lines (or maybe other possible carvings) in the surface that we selected using a filter. This could either be in 3D, or in 2D after projection to a fit surface (see #7). To do this, we will likely first need tools in ipyvolume to manually alter or initialize such lines or carvings. The automatic process could consist of fitting to groove/carving shapes, or, more easily, by using some measure based on distance from the projected shape, which could also possibly lead to a further filter step, followed by a simple line fit.