radudragusin / vispy Goto Github PK

Find way to save positions across sessions such that:
  * only calculate new position when graph is altered
  * keep old position when graph is NOT altered.

Under the assumption that:
  * marking nodes and edges does NOT alter graph
  * adding and/or removing nodes/edges DOES alter graph

Possibility to homogenize new list datastructure with built-in functionality

Implement methods to mark edges and nodes in graphs and trees more easily.

def markEdge(self, edge): STUB!

def markNode(self, node): STUB!

Tuesdays 4. may and 11. may
Make introduction to python lesson, 2 hour session.
4. may:
13 - 15
15 - 17 (brian work)
17 - 19 (brian work)

11. may:
13 - 15
15 - 17
17 - 19

We only now support binary trees, extend the datastructure to
support n leafs for any node.

Optimize tree structure positioning algorithm, á la Kim.

Discuss design of managing multiple graphs.

What steps will reproduce the problem?
1. create list with several of same value
2. visualize

What is the expected output? What do you see instead?
Expected output is all nodes places.
Duplicate nodes are "eliminated" in the positioning phase.

What steps will reproduce the problem?
1. add edge to graph
2. remove edge

What is the expected output? What do you see instead?
Edge should be removed from graph.
It is not removed.

Implement dictionaries to hold nodes and edges instead of lists.

This will greatly improve performance of adding/removing nodes and edges!

Implementation of MultiGraph data structure,
or implementation of abstract data structure

Remove methods. Redundant!

Rewrite code and comments to adapt Python Conventions according to PEB 8:
Code: http://www.python.org/dev/peps/pep-0008/
DOC-style: http://www.python.org/dev/peps/pep-0257/

Data structure constructor's given arguments whether it should automatically 
visualize changes, or not

Proposal:
def __init__ (self, ... , automaticvisualization=False)...




in the methods:
if automaticvisualization:
   self.vizMe(...)

Support marking of nodes, by node-id.

Shared methods should be renamed to more appropriate names according to 
their functionality.

Implement support for handling labels for any node and/or edge for
all data structures.

Graph visualization is not completely satisfactory.
Provide better/more options for visualizing graphs.

- Possibility to use own positioning algorithms?

Decide what problem the generic Graph datastructure solves.
Is it multi-graph, directed/undirected?

Current solution is too dynamic. It handles too many possible scenarios.
Discuss the design decisions and possibilities of extending the program 
logic to other classes, such to create static and concrete graph structures 
(ie. undirected, directed, weighted, etc).

Some method *copy* data to the user or other program functions. Consider a 
way to minimize this memory waste. Perhaps solve with iterators.

An exercise must be formulated covering the following:
  * Algorithm development
  * visualization of result of algorithm: prior algorithm, during algorithm, 
after algorithm
  * complexity analysis
  * Data structure development

Decide upon naming standards.

Is it 'vertex' or 'node'?

Book standard, or Python/other standard?

Option for generating specific kinds of structures eg.:
- MST
- full graph
- etc...