Add an __array__ method to NDData - #266

+1 I think this fulfills any near-term desire for easy plotting.
For that matter, I'm kind of surprised NDData didn't already have an __array__, but I haven't been following it very closely.

+1 from me as well. Even if there ends up being a plot method, this is still useful.

My one concern with this is that it makes NDData look like an array when it is really much more than that. If not told otherwise, it would be tempting for users to end up doing, e.g.,

d = NDData( ... )
...
d[:, 2]

to access the underlying data of an NDData object, rather than using d.data[:, 2]. The two would give different results depending on the mask attribute.

I'm not that familiar with the use of masked arrays, but if a masked array is what you want all the time anyway, here's a possible alternative: change NDData. Rather than having separate data and mask attributes, only have data, which would be a masked array if there is a mask, and a normal ndarray if there is not a mask. (There could still be a mask attribute that points to the mask in the data attribute for convenience.) Then, instead of doing plt.imshow(x, interpolation='nearest') in the example above, one could do plt.imshow(x.data, interpolation='nearest') with the same result, and we would avoid having two similar but different ways to access the data attribute.

Just a thought. Would this cause problems for the use of NDData in other situations? (i.e., not knowing if data is an ndarray or a masked array?)

@kbarbary - we definitely don't want data to be a masked array, because numpy masked arrays have significant performance penalties. Also, they are more limited in what "mask" means than what we intend (in the future) for NDData.

And to clarify, d[:,2] will not give an array out. Definiting __array__ does not automatically make the object into an ndarray - it just tells how to translate the object into an array if the array function is used. So the behavior you're talking about would instead require:

d = NDData( ... )
...
darr = np.array(d)
darr[:, 2]

Which is explicit and makes it clear what's going on. @mdboom suggested this as a solution to the plotting commands, because matplotlib functions like plot convert to arrays if the input is not an array internally, so this makes plot(nddataobj) possible, but without nddataobj being an array.

This does raise a point about this leading to some user confusion, though. @mdboom, can you update this PR to add a little bit to the nddata documentation that gives an example of this, and tries to clarify this point so other users don't make the (very reasonable) assumption @kbarbary did?

@eteq Thanks for the clarification. I withdraw my comments :)

I agree it's reasonable to elaborate in a comment (or docstring). Will do.

Ok, great - once you've done that, as far as I'm concerned this can be merged.

I'm don't have access to my computer right now, but does this actually make sense for anything else than 1 and 2d datasets? If not, should it just be implemented in Spectrum and Image instead?

For plotting images, lines or scatters with matplotlib, yes it only makes sense for 1 and 2d datasets. 3d is less useful -- looking at mayavi2 as an example, there aren't really any functions that take a 3d array as a volume.

In general, though, I think __array__ may be useful (for things other than matplotlib) on any array, and it's certainly simple to do so.

Ok - in that case I agree it is useful!

@mdboom - I just generated the docstring on this now, and unfortunately, __array__ does not get documented because it has a leading underscore. Perhaps move part/all of it to the main documentation for the NDData object? It would also be good to include some of it in the docs/nddata somewhere, although I can do that after this is merged, if you'd prefer.

I've moved the __array__ docstring to the class-level docstring as a note.

Alright, looks good - I'll go ahead and merge this, and I'll add a little bit to the docs/nddata.