Example #1
0
 private void updateOutsideEdges(List <IGWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData> >[] outsideEdges, IGWNode <ICRFNodeData, ICRFEdgeData, ICRFGraphData> node)
 {
     foreach (IGWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData> edge in node.Edges)
     {
         outsideEdges[node.Neighbour(edge).GraphId].Remove(edge);
     }
 }
        private LinkedList <IGWNode <ICRFNodeDataBinary, ICRFEdgeDataBinary, ICRFGraphData> > ComputeNewBoundaryVertices(IGWNode <ICRFNodeDataBinary, ICRFEdgeDataBinary, ICRFGraphData> chosenVertex)
        {
            var NewInnerVertices = new LinkedList <IGWNode <ICRFNodeDataBinary, ICRFEdgeDataBinary, ICRFGraphData> >();

            foreach (var edge in chosenVertex.Edges)
            {
                var otherVertex = chosenVertex.Neighbour(edge);
                //if (otherVertex.IsChosen)
                //    continue;
                otherVertex.Data.UnchosenNeighboursTemp--;
                if (otherVertex.Data.UnchosenNeighboursTemp == 0)
                {
                    BoundaryVertices.Remove(otherVertex);
                    NewInnerVertices.AddLast(otherVertex);
                }
            }

            if (chosenVertex.Data.UnchosenNeighboursTemp > 0)
            {
                BoundaryVertices.Add(chosenVertex);
            }
            else
            {
                NewInnerVertices.AddLast(chosenVertex);
            }



            return(NewInnerVertices);
        }
Example #3
0
        private double DetermineBarrier(List <CRFLabelling> Combinations, IGWNode <ICRFNodeData, ICRFEdgeData, ICRFGraphData> vertex, bool needBarrier, int MaximalCombinationsUnderConsideration, int RunsToDetermineBarrier)
        {
            if (!needBarrier)
            {
                return(double.MinValue);
            }

            var surviveRatio = ((double)MaximalCombinationsUnderConsideration) / (Combinations.Count * NumberLabels);

            if (surviveRatio >= 1.0)
            {
                return(double.MinValue);
            }

            var sample = Combinations.RandomTake(RunsToDetermineBarrier, Random).ToList();

            double barrier     = 0.0;
            int    sampleCount = sample.Count;

            int survivors = (int)(surviveRatio * sampleCount) + 1;
            LinkedList <double> Scores = new LinkedList <double>();

            Random rand = new Random();

            var scoringEdges = vertex.Edges.Where(e => vertex.Neighbour(e).Data.IsChosen).ToList();

            foreach (var item in sample)
            {
                int label = Random.Next(NumberLabels);
                var score = item.Score + vertex.Data.Score(label);
                foreach (var edge in scoringEdges)
                {
                    if (edge.Foot.Equals(vertex))
                    {
                        score += edge.Score(item.AssignedLabels[edge.Head.GraphId], label);
                    }
                    else
                    {
                        score += edge.Score(label, item.AssignedLabels[edge.Foot.GraphId]);
                    }
                }
                LinkedListHandler.SortedInsert(Scores, score, survivors);
            }
            barrier = (Scores.Last.Value + Scores.Last.Previous.Value) / 2.0;

            return(barrier);
        }