Appion

Neil, did you start from scratch or are you using what I started to make with approc2d.py? Have you checked in your version?

Hi Scott, I started with approc2d, but it was not quite ready and I decided not to use a system call. In many respects it is the same, but it is all handled in (small amounts of) memory.

I have made some changes to approc2d, but approc2d gets bogged down with file formats, when to append/when not to append. In makestack2, it is more controlled. Makestack2 only uses hed/img and we are always appending, so it was much easier and straight-forward to implement in-place, in my opinion.

I also removed the calls to Xmipp, because we can handle ramping and pixlimit within python.

I see. I'll take a look at the code during the hackathon. I still think we should have an approc2d.py . Hopefully your imagic I/O code is modularized enough that I can use it for approc2d. My plan for the next step for it was to make a generalized stack class that handles reads and writes in a more generalized way. I'm hoping to work on that at the hackathon if I get the website stuff that I want to get done finished.

### Works
# read MRC image
# write to MRC image
# filter images
# implement binning

### needs more testing
# write pixelsize to new MRC file
# read MRC stack
# read IMAGIC stack
# write to HED/IMG
# write to MRC stack
# append to HED/IMG
# append to MRC
# get apix from MRC header

### TODO
# read SPIDER
# read EMAN/HDF
# get apix from HED/IMG header
# implement proc2d --list feature
# implement proc2d --clip
# implement normalization

I think the mem map idea is not working. I am trying to use approc2d.py to change the format of a stack from imagic to mrc, and it appears to be loading the whole thing into memory before beginning to write the new stack. This was a major reason why in my original script, I was treating a stack one particle at a time. I'm not sure what the fix for this is. Neil, any ideas?

Hi Scott, I will have to test, but it should work. One problem could be the number of particles per cycle OR no properly cleaning up the particles in memory (supposedly automatically done via garbage collection in python).

Doing one particle at a time could make the program slow, because calling for too many disk writes can be a bottleneck, especially since how the headers are setup in stacks.