/// <summary>
        ///     Inits the datastructures, later forces can be defined on the nodes.
        /// </summary>
        /// <param name="majorizer"></param>
        /// <param name="graph"></param>
        /// <param name="nodePositions"></param>
        static void InitStressWithGraph(StressMajorization majorizer, GeometryGraph graph, Point[] nodePositions)
        {
            majorizer.Positions   = new List <Point>(nodePositions);
            majorizer.NodeVotings = new List <NodeVoting>(graph.Nodes.Count);

            for (int i = 0; i < graph.Nodes.Count; i++)
            {
                var nodeVote = new NodeVoting(i);
                //add second block for separate weighting of the overlap distances
                var voteBlock = new VoteBlock(new List <Vote>(), 100);
//                nodeVote.VotingBlocks[0].BlockWeight = 0;
                nodeVote.VotingBlocks.Add(voteBlock);
                majorizer.NodeVotings.Add(nodeVote);
            }
        }
        static void AddStressFromProximityEdges(StressMajorization stressSolver,
                                                List <Tuple <int, int, double, double> > proximityEdgesWithDistance)
        {
            //set to check whether we already added forces between two nodes
            var nodePairs = new HashSet <Tuple <int, int> >();

            // set the corresponding forces/votings
            foreach (var tuple in proximityEdgesWithDistance)
            {
                int nodeId1 = tuple.Item1;
                int nodeId2 = tuple.Item2;
                if (nodeId1 > nodeId2)
                {
                    nodeId1 = tuple.Item2;
                    nodeId2 = tuple.Item1;
                }
                var tup = new Tuple <int, int>(nodeId1, nodeId2);
                if (nodePairs.Contains(tup))
                {
                    continue;
                }
                nodePairs.Add(tup);

                double distance      = tuple.Item3;
                double weight        = 1 / (distance * distance);
                var    voteFromNode1 = new Vote(nodeId1, distance, weight); // vote from node1 for node2
                var    voteFromNode2 = new Vote(nodeId2, distance, weight); // vote from node2 for node1

                if (tuple.Item4 <= 1)
                {
                    //nodes do not overlap
                    // add the votings, which represent forces, to the corresponding block.
                    stressSolver.NodeVotings[nodeId2].VotingBlocks[0].Votings.Add(voteFromNode1);
                    // add vote of node1 to list of node2
                    stressSolver.NodeVotings[nodeId1].VotingBlocks[0].Votings.Add(voteFromNode2);
                }
                else
                {
                    //edges where nodes do overlap
                    // add the votings, which represent forces, to the corresponding block.
                    stressSolver.NodeVotings[nodeId2].VotingBlocks[1].Votings.Add(voteFromNode1);
                    // add vote of node1 to list of node2
                    stressSolver.NodeVotings[nodeId1].VotingBlocks[1].Votings.Add(voteFromNode2);
                    // add vote of node2 to list of node1
                }
            }
        }
        /// <summary>
        ///     Inits some structures.
        /// </summary>
        protected virtual void InitWithGraph()
        {
            if (StressSolver != null)
            {
                //possibly call destructor to free memory...
            }

            if (Graph == null || Graph.Nodes.Count == 0)
            {
                return;
            }

            if (StressSolver == null)
            {
                StressSolver = new StressMajorization();
                if (Settings != null)
                {
                    StressSolver.Settings = Settings.StressSettings;
                }
            }
        }