First (incomplete) rough draft of the Mussagl Manual

Win32 Inno Setup installer script

disable coloring things with reverse compliment colors.
since the reverse compliment color (blue) is being applied incorrectly
just disable it for the moment. ticket:44

this of course needs to be reversed when I actually fix the bug.

define an analysis should keep settings
The define an analysis dialog should keep its values (as it doesn't do
a good job of validating input) (ticket:57) because when something is wrong
you'd have to then reenter everything.

change from slider to spinner for threshold
Use a spinner instead of a slider as its useful to be able to type in a
threshold. (starts implementation of ticket:39)
Also ticket:55 would be _very_ helpful.

better sidebar rendering
This should fix the problems with the sidebar's output getting messed up,
(ala ticket:39) also it outputs the species name

fix selection box coordinate bugs
ticket:41 and ticket:43 were both due to the fact that the right screen
coordinates weren't being properly offset by the current ortho.

spurious mouseReleaseEvent caused a crash
For some reason a mouseReleaseEvent was making it to mussa when
using one of the load dialog boxes. This caused a crash.
This patch causes it to not crash.
Though this patch also seems to sometimes select things for no apparent
reason.

finish dialog box to setup an analysis
Closes ticket:5 (though I'm sure it'll introduce some new tickets).

this gets the dialog box brandon coded working so you can now setup an
analysis from the gui.

I think this finishes everything tristan's mussa had, and I think it took
5 weeks instead of the 3-4 estimated.

Increase line thickness
On some OS X machines the lines on the opengl canvas were nearly illegible.
I'm guessing it was because they were being rendered as sub-pixel objects
Hopefully this'll fix those problems.

provide more information in the about box.

Progress towards MussaSetupDialog (Currently will cause crash! Be warned!)

bless osx Qt components and make a .dmg
OS X needs to have the location of any shared libraries prelinked
(at build time). This does that, and then makes a dmg.

tell doxygen about motif_editor and mussa_setup_dialog

Removed 'create subanalysis' from menu for now (until implemented)

Added two load icons to file menu.

Work towards MussaSetupDialog (Not finished yet).

provide a user interface to edit motifs

resizing should also change the sequence position indicators

hopefully this fixes the off by one error
with the left sequence position.

when changing alignment the position also needs to update

set inital left position
when starting with the sequences at a non-zero position, make sure the
positions shown in the sidebar actually corresponds to what sequence
is currently visible (ticket:40)

resizing increases the viewable world
When resizing increase the amount of world that's visibile in the viewport
(and a couple of { moves.

changing the set of links does need to redraw
Somehow I deleted an update that was needed for redrawing the links.
This puts one back in so changing the threshold works.

Mussa aligned sequence view seems to work
I added a "normalizedIndexes" to the ConservedPath classes to return
vectors which don't have any negative path values.

I also think the use of menu entries is a bit annoying as it wont extend
well to large numbers of selected paths. Additionally, deselecting an
alignment doesnt seem to do much as I suspect there's a fair amount of
overlap betwen the various alignments.

But i was eventually able to make them all go away.

dont crash when loading a new analysis
Since the MussaAlignedWindow uses a pointer to the mussa analysis, when
we load a different analysis it crashes. So close (and delete) all the
aligned windows when we load a new analysis.

draw alignment lines
A step toward getting the alignment view... This draws the alignment
lines. And even gets it right occasionally.

Open issues are: reverse complimented sequences get shifted
by the wrong sign. There's an off by one error (ticket:37), and of course
there's a need for a user interface to pick which alignment to use & show.

render sequence correctly in mussa aligned window
My math for locating a sequence when seq_x moved was wrong, so I was
drawing the sequence in some weird off the wall place.

implement zoom in terms of base pairs per pixel
Though the value we return from zoom is actually basepairs/pixels*100
(so i can use int).

I also implemented a zoomOut function that zooms far enough out to fit the
current scene on the display.

center on path
This manages to make the various sequences line up along some provided path.
(a vector<int> listing the sequences positions).

This has problems because of the use of the negative flag to indicate
reverse compliment (as it moves the sequence the wrong direction).

Additionally to get this to work I had to get all of the glsequence code
necessary to allow non-zero x values.

define window for showing a mussa alignment
Create a new window to hold the mussa sequence alignment. (aka
show all the sequences lined up at a starting point with lines connecting
base pairs.)

(This also fixes a bug I introduced into the fltk version of mussa back
when I changed paths from just being a vector of ints into an actual
class.)

I still need to actually allow the user to pick the aligned path and show
the conserved base pairs.

Work towards MussaSetupDialog

This patch just adds a director qui/mussa_setup_dialog/ and includes the .cpp and .hpp files to support the dialog box. This patch does not touch any other areas of the code and therefor is a safe patch to pull (without worrying about merge conflicts).

Zoom Icon Patch

refactored PathScene into SequenceBrowserWidget
The thing that was really hurting my brain was trying to keep track of
which of all the classes needed to actually implement the
SequenceBrowserWidget was actually implementing some function.

SequenceBrowserWidget is now the central control widget that manages
how all of the sub-widgets connect.

I could've tried to simplify how the SequenceBrowserWidget::updatePosition
code worked but it was to hard and I didn't bother.

specify where the gl.h is on a mac

fix motif coloring
Need to force tying a GlSequence's AnnotationColor mapper to the one in
the mussa analysis, not the default being created in GlTracks

track labels
ticket:3
This adds two side bars to the PathWidget that show the current position
(and the total length of the sequence, and should show the name).

Scrolling the viewport around makes the position number change too.
(Which revealed a bug that glsequence.leftbase would return values larger
than the sequence).

I also fixed the default size hint.

However all is not completely well, I really need to specialize the
right and left sidebars. And there were way too many classes created for
trying to handle all the user interface widgets. And I'm the locations
of the various signals and updating code could certainly be better thought
out.

re-implement selection
The new segment based paths are more challenging to try and track
which segment maps to which path, which makes highlighting stuff
a bit challenging.

But this mostly works. (other than ticket:21 hard coded selection buffer
size)

computation for a path segment was wrong
The second y axis for the path segment was wrong. (Too much cut and
paste coding). It should go to the top of a track, not the bottom
(+= not -=)

fix the scrollbar
reconnect all the signals so the scollbar works, and
fix my overly clever use of a floating point equality test when i should've
been using a not equal test.

make the path view independent of type of connection
I moved the opengl code for drawing multiple tracks with paths
connecting various elements into GlTracks. This also includes the performance
improvement of only drawing a track once.

Unfortunately I disabled the selection code, as I'm not sure how much
should live at the Qt level and how much should live at the opengl level.

Even more difficult is the problem that a segment can belong to _many_
paths. Which makes my old each path having one pathid not so likely to work--
especially since there's a limit to how many names one can have.

Unfortunately for a large dataset, there's a segfault on closing.

make doxygen output more focused
make all of our exceptions derive from one base class so doxygen will
group them.

Also stop generating docs for mussa_fltk.

And in the process I found that I hadn't updated the main cxx for mussa
fltk to the new cpp standard

load and display a motif list
Mussagl can now load a motif list from a text file in the form
AAGGGCCTT 1.0 0.5 0.0
(The trailing numbers are the red, green, blue channels)
and motifs are properly displayed on the sequence tracks.

I did this by attaching an AnnotationColors color mapper to the mussa
analysis and passing it to the glsequence class for rendering.

document win_append, thres_append
and remove some unused parameters win_override and thres_override.

just load the sequence
The old load sequence code, loaded information about a sequence into a
list of vectors and then, later went and actually loaded from the data files
(Probably had something to do with mussa originally being a C program).

This version loads the data when its been collected and shoves the resulting
Sequence onto our vector<Sequence>.

rename motif class used in fltk code to fltk_motif
I forgot to build the fltk code and so my patch that added the motif derived
from the annot class, conflicted with the motif in the fltk code.

So I renamed it. darcs replace is really neat, it made dealing with that
sooo much easier.

attach motifs to a sequence object
this attaches a list of motfis (derived from annot class) to a sequence,
ideally there'd be only one list, but as I'm under a time pressure
its a bit easier to keep the lists seperate. (As this way I don't have
to go deal with fixing the file IO until later)

implement a color mapper class
So I was deeply inspired by my habit of using nested python dictionaries
This provides the semantics of a hierarchy of 3 different colors.
A generic default, a per annotation "type" default, and an "instance" default.

it does assume there's only those 3 levels and nothing else, though it
probably is possible to make it more recursive and capable of supporting
arbitrary depths. However I don't need that.

tell darcs whats boring to make whatsnew more useful

There can be only one (filename convention)
So I was used to using .cxx/.h, tristan used .cc/.hh, neither
are really that great, so after some consultation we're going to use
the boost convention of .cpp/.hpp, we assume that the boost people know
what they're doing.

Thicker bars, better letters
Aparently there's a limit to how thick an OpenGL line can be, so to get
lines of sufficient thickness I switched to drawing large polygons.

Also to help with getting the text and sequence view to line up correctly,
I pushed all the font letters down so they're centered at the midline.

There's also more work that needs to be done for z-order, the window
connections z is currently just hardcoded.

Also I made my hacked vector  A, G, and Cs look a little bit better.

make it easier to build on win32

refactor glsequence to be more testable
I wanted to make it easier to verify that components of glsequence
actually worked correctly, so chunks of the code that determined when to
draw the sequence as text were broken out into subfunctions so I could test
them. This patch also changes the place that the sequence as text is drawn
from above the sequence as bar to the same place. (AKA you either get
a bar representing a sequence, or text for the sequence, and they're both
(in this patch) approximately in the same place)

And while in there I also made some modifications to sequence to be more
iterator friendly. (And I finally got around to taking tristan's suggestion
and changed filter_sequence into set_filtered_sequence, so it directly
sets the sequence member instead of returning a modified string.

Finally I tossed in a color class that basically maps to the opengl rgba
color model. (To the level of having a function that returns a GLfloat[4)

For the immediate future, I need to make sure that the sequence text
and sequence bar take the same vertical space so when I start connecting
sequence lines together they connect at the right place. I also need
to get the annotations to keep track of their color and draw those colors.

we can scroll
This adds a scrollbar to allow moving the viewport around, and the
scrollbar does stay in the right place as one changes the zoom level.

However there's a bit of weirdness with it. Currently the minimum zoom
level is "2" as, 1 causes the display to be at half size. (probalby
due to the the curOrtho left and right having the scale added and
subtracted from them, respectively).

I also think the scrollbar's going to be very grumpy for sequences larger
than 100k. as its width isn't scaled, and that's going to make a
very hard to control scrollbar.

resolve complicated merge conflict
Ok so trac-darcs doesn't handle renaming directories that have stuff
in them, so I made a new version of that patch, and then pulled
a the original version on top.

needless to say this led to some merge conflicts. hopefully this patch
resolves those conflicts.

fix segfault when changing soft threshold when no analysis is loaded
somehow the trans_path_search tweaked things so that it when it was
called again it'd seg fault.

PathScene rare mousemove without mouseclick event bug fix.

LCDNumber now looks black and is more readable now!

drawing sequence basepairs.
OpenGL is not very text friendly. But I can draw AGCTs with something
that's vaguely readable. I tried to use FTGL (a freetype based GL font
rendering library, but I couldn't get it to control the width of fonts
and so they ended up rendering on top of each other.) I used an example
out of the opengl redbook, to hand code glyphs that are at least passable.

The current block of code manages to turn on text rendering only when there's
enough space to make them legible. However I'm not completely convinced that
the text is actually in the right place.

There's also a problem with the python to C++ interface that I worked around
if you create a Sequence object and point a GlSequence to it, if the
python copy goes away, the copy in GlSequence dies, which makes rendering
sequence data a bit challenging.

mild improvements to demo python sequence view
gl.py can successfully display a glSequence in a glut window.
Not terribly exciting, but still its python driving a mussa view

record selected track
Keep track of the lowest value selected track, so we know what to show
when people try to bring up the sequence view.

Also toss in some more Boost.Python code

python wrap mussa, nwaypaths, and conservedpaths
provide a python interface to at least some of Mussa, NwayPaths, and
ConservedPaths so I can get some idea of how much more efficient a
graph representation for paths would be than the current linear structure.
(AKA how often is a a path segment shared?)

select paths and highlight them
This patch enables selecting paths and then highlighting them
(it uses a vector<bool> of the size of our refined_pathz to track
if things should be highlighted.

The weakness of this code is that it uses the opengl selection buffer
to detect which elements were selected, and it's possible to overflow
the buffer, though I attempt to be clever and allocate a buffer large
enough to hold every element.

main function should return int

improve error handling for loading
I think all of the mussa file loading code throws a mussa_load_error
when something doesn't work. (instead of returning an error string).
All the GUIs catch this error and display the error in their message box

One annoying thing was that loading a different analysis after you'd already
loaded one in the Qt version caused it to try to merge the two versions
and then die when it ran its analysis. I got around that by deleting the
old mussa pointer and replacing it with the newly loaded version.
Though I discovered I need to do the pointer swap _after_ I'd successfully
loaded a the new analysis.

Also the Qt version doesn't try to load anything when the user presses
the cancel button in the load dialog boxes.

we can load parameter files
Mussagl now as several ways to load an analysis.
There are now two command-line arguments, run-analysis and view-analysis
which will load a parameter file and an analysis directory respectively.

The menu items in mussagl are also connected to slots in PathScene to
handle loading.

When something is loaded PathScene::updateAnalysis will (if the
analysis actually has some contents) run the analysis.

However there's some bug where the loading the previously saved analysis
is choaking on some assertion.

refining an empty pathz would cause a segfault
So I added the test code to check for that condition and not run the
refining code (especially the initialization of our first extended
window pointer which was the real culprit).

connect a spin box to the scene zoom slot

hacked thresholding
This is a quick hack using the older recompute the paths using
a soft threshold code. Once we get the opengl line depth path working
most of this can be reverted.

One of key weaknesses is this calls draw_line repeatedly instead of using
the display list.

Also the reason we have the hack is that properly computing the score for
a path is going to take some more refactoring, in this case probably
coming up with some class to handle generating paths from the lists of
FLPs.

use ConservedPath class instead of vector<int>
This is a massive bout of refactoring, instead of just using vector<int>s
to store a path I implemented two classes ConservedPath and
ExtendedConservedPath which contain a path of ints and score information
for the ConservedPath and window_size for the Extended version.

In trying to unit test this I also ended up needing to implement several
useful things like operator== and operator<< (for the boost test cases).
for these classes and FLPs.

Though even with all of this refactoring the key feature of getting
the path score correct so I can use clipping planes isn't implemented yet.

But at least both old and new mussa work correctly with the refactoring.
And I fixed one of the rendering bugs in old mussa.

Gave SaveImageDialog a better window name

move glsequence into "alg" component
I decided to try to make the opengl rendering code toolkit independent
this makes it easier to test some of these components as then I can
just use boost.unittest to verify them.

Also when I python wrap parts it might make sense for the gl components
to be the part that ends up getting exported as the python package.

Added SaveImageDialog to mussagl

ImageSaveDialog cout removal

ImageSaveDialog

First version of ImageScaler Widget

Image File Icon & Lock Icon

cleanup nway code
Purged the sp_num variable and replaced it with either a .size() call, or
a call to a new member function sequence_count()
Renamed Nway_Paths to NwayPaths
Used vector<>::size_type in a number of places
Reflowed some blocks.

line rendering fixes
Get the reversed versus forward conservation lines correct. The color is
blue if the orientation of the current vertex differs from the previous
vertex, and red if they have the same oreintation. I also (hopefully)
adjusted the x position so the line points to the center of the conserved
window (adjusting to the right for forward and left for reverse compliment
sequences).

Also we discovered that you can't use both depth testing and alpha blending
at the same time, and so now the selection highlighter is hopefully alpha
blended while all the various lines are depth ordered.

move glsequence into "alg" comonent
decided to try to make the opengl rendering code toolkit independent
this makes it easier to test some of these components as then I can
just use boost.unittest to verify them.

Also when I python wrap parts it might make sense for the gl components
to be the part that ends up getting exported as the python package.

this is actually a hacked version of the original patch that moves
the test directory a file at a time.

show conservation paths
This patch draws the windows of conservation between the various sequences.
Getting this to work also required making a number of member functions
properly const.

fix many mussa_class.cxx warnings
Got rid of a bunch of signed vs unsigned warning messages by using size_type,
and also put the bodies of a few if or for statements in { }

advance_sp_itor_track was triggering an infinite loop
I somehow missed moving the logic that detected when we'd finished advancing
all the species iterators, which was causing an infinite loop.
I also changed int to vector<>::size_type to get rid of some warnings.

render the sequences from the mussa analysis
I implemented a GlSequence which attempts to handle the opengl rendering
for a sequence object. Also to make Sequence a bit more consistent
with STL I changed len() to length() and added size() (and changed
the code using it to size()

I added some unit tests for GlSequence as I was not remotely confident
that const_cast was actually the right way to implement the assignment
operator= when one of the member variables is a const reference.

The updateAnalysis code currently is what is handling the layout of the
various sequence objects.

provide an annotation for our example data
Admittedly the sample annotation is utterly meaningless.
We should probably go look up some real annotations.

Added WhatsThis feature to Mussa.

To use this feature, take any QWidget inherited object and call:

widget->setWhatsThis(tr("Long description"));

That's it!

Crystal Icons added to repository + Added icons to menu.
Crystal SVG Icons are LGPL, comment in README.txt about license.

Toolbar is now toggleable from menu.

Added icon for motif toggle.

View Toolbar Action in View Menu.

put the fake lines at a clipable depth
I'm not sure why these precise parameters work, but the slider now
nicely makes my fake lines fade in and out of existence.

add a toolbar with toggle motifs and the base pair threshold

load mupa and show fake path scene
Enable loading a mupa file.
Use the gl scene widget from the qtgl prototype to make it look
like we've done something.

reduce warning messages in sequence.cxx

tell doxygen to create docs for the qt classes too

skeleten of a qt version of mussa
One annoying thing about qmake is that each .pro file can only make one
binary. So the old make file which build the fltk gui and more importantly
the boost based unittests is now available as Makefile.noqt.

qmake-qt4 mussagl.pro will generate the qt4 makefile for building the qt4
mussa.

(And I may switch to boost build or scons so I can have one build file
for all the versions).

refactor nway_other.cxx
In order to understand how the transitive and radial nway comparisons
worked I wanted to make the algorithms fit in a single window. I did
this by taking various types of initialization loops that were duplicated
between both algortihms and refactored them into seperate functions.
(mostly these common loops handled building paths that were between
our various iterators on each species lists of FLPs)

I thought it might be nice to turn the various functions I ripped out
into a class that manages the march of the iterators across the lists
of FLPs.

I also added some fairly basic unit tests for the nway (transitive) comparison.

use exceptions to indicate Mussa::analyze failed
also modified the fltk gui code to report the exception text.

subanalysis menu option wont crash mussa

only include headers by names relative to project base path