It worked fine, but it seems to be not used anymore and the codebase contains lots of special cases...

Bandage supports a set of custom GFA tags to color nodes / edges besides other tags. Document them

Are any command line options supported? For example, to change defaults, etc. I tried --help but got the following. I am on Ubuntu 20.04.

./BandageNG-3b69a79-x86_64.AppImage --help
qt.qpa.plugin: Could not find the Qt platform plugin "minimal" in ""
This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.

Available platform plugins are: xcb.

Aborted (core dumped)

Add support for gapped paths and jump links from the coming GFA v1.2

This, besides the tests, could provide pre-built binaries as well

GFA grammar requires some lookahead. In particular, "+/-" are allowed in segment names. As a result we need to have some lookahead while parsing oriented segments from P lines.

After #46 we do allow "+/-" in segment names, however, such segments will not be able to participate in P lines due to absence of required lookahead

In GFA format to augment existing graph from external sources

When graph is reloaded we might end with stale annotations

@ekg Will it be possible for you to draft requirement here? Something more specific than just "use coordinates along the path", if anything?

Hi,

I have multiple GFA files where the S/L lines are mixed. For example:

H	VN:Z:1.0
S	1	GCGGTTCAGCAATTTCAGG
L	1	+	2	+	0M
L	1	+	3	+	0M
S	2	G
L	2	+	4	+	0M
S	3	C
L	3	+	4	+	0M
...

In order to open them with the new power-upped Bandage, I have to put all S lines first, then L lines, and then P lines. Else, I get this kind of error:

Is it possible to avoid such a constraint? The old Bandage can read S/L-mixed GFA files.

Subject

This could be used to apply any kind of annotation to the graph.

We need to support the basic columns:

• chrom
• chromStart
• chromEnd

As well as:

• name
• strand
• rgb

The formal specification is at https://samtools.github.io/hts-specs/BEDv1.pdf

• Add support for gapped paths (e.g. from scaffolds)
• Load SPAdes *.paths file directly

Large genome / metagenome could generate very huge assembly graph. We need to see how to load them properly.

Few ideas straight from the head:

• Switch to GFA parser from https://github.com/lh3/gfatools Our experience show that it's pretty efficient.
• Some additional indexing could be done, so we won't need to keep the whole graph in the memory

In very many places, objects are passed by value, for example QString. It is necessary to pass a constant reference.

ps: For the case of QString, this will not improve the speed, since copy-on-write

Hi,

it would be very nice to have as a feature the ability to export the generated graph layout without opening the GUI, that this with the command line interface. A generic and practical enough output format could be tab-separated output with these columns:

• node identifier
• x coordinate (of the midpoint of the node)
• y coordinate (of the midpoint of the node)

Eventually, the coordinates of both ends of the nodes could be output. An additional column with the number of the connected component to which the node belongs would also be useful.

This would allow us using BandageNG layouts with other tools like gfaestus.

What do you think?

Currently path selector is just plain combo box, which is quite ugly when we're having multiple paths. Redesign for better usability.

When searching for an empty path in the graph, the application crashes

1. Fix the style
2. Add clang format

It's really great that Bandage gets a new life - thank you for taking that up.

As a possible enhancement, I suggest minimap2 support. Currently you can map the assembly using blast and display those super useful rainbow plots, but blast is getting a bit tired these days.

If you add this support, it would be useful to allow both mapping on the fly (like currently for Blast), as well as the use of a preexisting paf file written by minimap2.

Loving this! Just a reminder to update the build instructions to reflect the current setup and dependencies.

Then paths are loading from the file they always created with the flag circular = false.

Is it correct behavior?

If several blast hits have the same center in the node then query names overlapped.

There are 5 hits on the screen.

Quickly spot contamination..

The old version of gfa builder could parse the bn:Z tag of the header (H line) which controls Bandage's options.

The new version doesn't support this because of using a third-party parser.

This is more of a FAQ item than an issue.

The front page README lists "Qt" as a prerequisite. Is this that "Qt", or is there something else called "Qt": https://www.qt.io ?

I seem to get errors setting blastn parameters (and I tried many) on the current version (v0.9.5.1) on the mac binary, that claim the arg name is invalid. It seems to strip the leading '-'

Error: Invalid argument name: task blastn-short -word_size 4
Error:  (CArgException::eInvalidArg) Invalid argument name: task blastn-short -word_size 4

Passing with --task, \-task, or "-task " all lead to either invalid names or positional arg errors.

Trying the same files and blast params works fine on normal Bandage, so seems to be an error in BandageNG.

If we have a graphical representation of the node containing N line parts and M blast hits for this node, we will draw hits with O(NM) complexity.

Here is the cycle iterating by blast hits:
https://github.com/asl/Bandage/blob/dev/graph/graphicsitemnode.cpp#L169

Here is the code iterating by line parts for drawing one hit:
https://github.com/asl/Bandage/blob/dev/graph/graphicsitemnode.cpp#L610

Spec: https://github.com/lh3/gfatools/blob/master/doc/rGFA.md#the-graph-alignment-format-gaf

Currently when writing GFA we're emitting them as 'L' ones

Show all tags when node / edge is selected

Bandage is fantastic, I'm glad to hear you are continuing its development. I was wondering if it would be possible to implement a save/load feature? This would be useful for making figures for publications. It would be nice to be able to set a layout, add colors, blast hits etc. and then save the state so that it can be loaded again in the future.

Alternatively, a way to set the seed for the graph layout would be good as well in case I need to remake a figure but keep it looking the same. Thanks!

Switch to some library (e.g. clipp) to reduce hand-generated code and simplify adding new options

Currently we do require sequences to be present. We need to just use lengths and return 'N' instead

Use QRegularExpression instead

If I try to load a gfa file containing no sequence, I get the following error message:

Here is the beginning of the file I am trying to load:

H       VN:Z:1.0
S       0       *
S       1       *
S       2       *
S       3       *

According to the GFA specification, the sequence can be omitted and specified as *. The specification also says that, if the sequence is missing, "its length may be specified using the LN tag", but this is not required. The LN field is clearly described as optional, and the original Bandage has no problem loading this file.

GFA files without sequence are very useful to inspect an assembly without having to load a large file. This is useful for applications where the sequence is not needed, and one is interested only in the structure of the assembly graph.

In shasta assembly graphs, the node size range goes from 1bp all the way to 100Mbp and the font size is often too small when looking at the graph from a zoom level that allows you to see the overall structure:

For example, here the middle bubble is 8.67Mbp:

It would be convenient for making figures/presentations to be able to read the labels directly.

This way we can support multiple columns, etc.

1. The signature of the getStartingNodes function has changed. The test is not compiled.
2. linker problems
   ...

According to profiling results, a huge part of graph loading is QApplication::processEvents().

https://doc.qt.io/archives/qq/qq27-responsive-guis.html

Hi, I downloaded your AppImage release v0.9.5 and tried loading a human assembly graph generated by verkko (the current state of the art for contiguity/completeness) and it created this malformed UI element and has been running like this for about 10min without finishing

The static executable from conventional bandage has successfully loaded this graph in a minute or so.

Qt6 allows one to do everything in cmake. Switch from qmake to cmake.

So we can ensure build is not broken there

When writing GFA