GitLab

Each segmenter has now its own toJsonList() method.
This is more flexible and allows to output the KmerSegmenter even when the FineSegmenter failed.

The boolean dSegmented is now correctly set (but it is still not used...)

Re-organization, equivalent code

Not using a pointer creates some problems with KmerSegmenter.
We should have a copy constructor in KmerSegmenter but it is a pain in the ***.

Not using pointers makes several copies of the same object. However the copies share the
same pointer to a KmerAffectAnalyser and that's the problem. When one of the copy is
deleted, its destructor is called which will delete the KmerAffectAnalyser and the other
copies won't have access to it, and it will also generate an error when the copies will try
to delete the KmerAffectAnalyser.

This has been solved by using pointers to KmerSegmenter everywhere.

Now 'out_unsegmented' causes are output in segment.cpp, displaying affectation for each germline

Useful for '-U' debug output.

core/segment.{h,cpp}: both V and J kmers must be above DETECT_THRESHOLD to flag the germline as 'detected'

This reverts the idea of 41b4f071, but still uses a 'detected' flag.
This flag tells us whether we should continue to the remaining germlines.
In the case of incomplete rearrangements, we certainly want to continue even if we have
many V or many J (but now both of them).
Tests d2a0dbd5 are now passing.

Note that we don't run this test when strand == 2, this should be changed.

ABIGUOUS_THRESHOLD becomes DETECTED_THRESHOLD, such reads are flag 'detected'

This is cleaner: on one side we have the cause of unsegmentation, on the other we have the
flag 'detected' if there were enough V+J (now total V+J, we don't need to have both V and J).
Currently, the flag can be set when SEG_+/, TOO_FEW_V/J, or DELTA_MIN/MAX (but not STRAND).

We do not continue to the remaining germlines when 'detected' or STRAND.

When a sequence has both enough V and J affectations (above AMBIGUOUS_THRESHOLD),
it should normally be segmented. If not, the sequence is probably a chimera,
or the V and J repertoires are not well choosen. We now label this sequence
as AMBIGUOUS (instead of TOO_FEW_V or TOO_FEW_J).

As KmerAffectAnalyser is only used with KmerAffect, we do not need to keep the templates.
The code should be easier to read for C++ newbies such as the author of this commit.

Moreover, the argument 's' was not used

update json output for 2014.10.10 format

Again, this breaks some unit tests.

Now the MultiGermline contains only one germline.
The 'should' tests are still passing, but some unit tests are now broken.

It happens when we have V and J labels but when we're not able to segment because one
of the criteria on the number of V compared to J is not fulfilled

While CountKmerAffectAnalyser is more flexible, the heuristic implemented
in KmerAffectAnalyser is more efficient, that's why we use it in the KmerSegmenter

The function actually checks if there is a segmentation, including the main Vend/Jstart computation.

'removeChevauchement' and possibly other infos

	* Refactored main vidjil.cpp (core/windows.cpp, core/windowExtractor.cpp)
	* Removed unused html output
	* Better json output (core/json.cpp)
	* Updated main stdout, with representative sequence for each clone
	* Updated parameters for FineSegmenter (delta_max) and dynprog (substition cost)
	* Bugs closed

	* Better heuristic, segments more reads (core/segment.cpp)
	* Better and faster selection of representative read (vidjil.cpp, core/read_chooser.cpp)
	* Better display of reason of non-segmenting reads
	* New normalization against a standard (-Z) (core/labels.cpp)
	* New experimental lazy_msa multiple aligner
	* New .json output
	* New unit tests
	* Bugs closed

	* First public release