コード例 #1
0
        private static List <AnnotatedNode> NodesFromImageAnnotations(List <LayerWrapper> layers,
                                                                      int precedingLayerIndex,
                                                                      Dictionary <string, InterpretationFromImage> interps)
        {
            LayerWrapper currentLayer = layers[precedingLayerIndex + 1];

            List <ImageAnnotation> annotations = new List <ImageAnnotation>();

            IEnumerable <string> layerlibs = currentLayer.Layer.AnnotationLibraries();

            if (layerlibs != null)
            {
                foreach (string lib in layerlibs)
                {
                    annotations.AddRange(AnnotationLibrary.GetAnnotations(lib));
                }
            }

            List <AnnotatedNode> nodesToProcess = new List <AnnotatedNode>();

            //for each one, interpret the observation
            foreach (ImageAnnotation annotation in annotations)
            {
                InterpretationFromImage interp = interps[annotation.ImageId];
                Interpret(layers, precedingLayerIndex, interp);
                Tree root         = interp.interpretation;
                Tree matchingnode = MatchingNode(root, annotation.Region);

                AnnotatedNode annoatednode = new AnnotatedNode(matchingnode, root, annotation.Data, annotation.Region, annotation.ImageId);
                nodesToProcess.Add(annoatednode);
            }

            //MergeNodesWithSameRegion(nodesToProcess);

            return(nodesToProcess);
        }
コード例 #2
0
        //private static void MergeNodesWithSameRegion(List<AnnotatedNode> nodes){

        //    List<AnnotatedNode> processed = new List<AnnotatedNode>();
        //    for(int i = 0; i < nodes.Count; i++){
        //        AnnotatedNode currNode = nodes[i];
        //        if(!processed.Contains(currNode)){
        //            Dictionary<string, string> merged = new Dictionary<string, string>();

        //            foreach(string key in currNode.Data.Keys)
        //                merged.Add(key, currNode.Data[key]);

        //            for(int j = i+1; j < nodes.Count; j++){

        //                AnnotatedNode possibleMerge = nodes[j];

        //                if(BoundingBox.Equals(possibleMerge.Region, currNode.Region) && possibleMerge.ImageId.Equals(currNode.ImageId))
        //                {
        //                    foreach(string key in possibleMerge.Data.Keys)
        //                        merged.Add(key, possibleMerge.Data[key]);
        //                }

        //                processed.Add(possibleMerge);
        //            }

        //            AnnotatedNode replacement = new AnnotatedNode(currNode.MatchingNode, currNode.Root, merged, currNode.Region, currNode.ImageId );
        //            nodes [i] = replacement;
        //        }

        //    }

        //    foreach(AnnotatedNode toRemove in processed){
        //        nodes.Remove(toRemove);
        //    }
        //}

		private static void Interpret(List<LayerWrapper> layers, int precedingLayerIndex, InterpretationFromImage interp)
		{

			if (precedingLayerIndex >= 0)
			{
				if (interp.layerWhereInterpretationEnded != layers[precedingLayerIndex])
				{
					int start = 0;
					if (interp.layerWhereInterpretationEnded != null)
						start = layers.IndexOf(interp.layerWhereInterpretationEnded);

					interp.interpretation = InterpretSubchain(layers, start, precedingLayerIndex, interp.interpretation);
					interp.layerWhereInterpretationEnded = layers[precedingLayerIndex];
				}
			}
		}
コード例 #3
0
        //private static void MergeNodesWithSameRegion(List<AnnotatedNode> nodes){

        //    List<AnnotatedNode> processed = new List<AnnotatedNode>();
        //    for(int i = 0; i < nodes.Count; i++){
        //        AnnotatedNode currNode = nodes[i];
        //        if(!processed.Contains(currNode)){
        //            Dictionary<string, string> merged = new Dictionary<string, string>();

        //            foreach(string key in currNode.Data.Keys)
        //                merged.Add(key, currNode.Data[key]);

        //            for(int j = i+1; j < nodes.Count; j++){

        //                AnnotatedNode possibleMerge = nodes[j];

        //                if(BoundingBox.Equals(possibleMerge.Region, currNode.Region) && possibleMerge.ImageId.Equals(currNode.ImageId))
        //                {
        //                    foreach(string key in possibleMerge.Data.Keys)
        //                        merged.Add(key, possibleMerge.Data[key]);
        //                }

        //                processed.Add(possibleMerge);
        //            }

        //            AnnotatedNode replacement = new AnnotatedNode(currNode.MatchingNode, currNode.Root, merged, currNode.Region, currNode.ImageId );
        //            nodes [i] = replacement;
        //        }

        //    }

        //    foreach(AnnotatedNode toRemove in processed){
        //        nodes.Remove(toRemove);
        //    }
        //}

        private static void Interpret(List <LayerWrapper> layers, int precedingLayerIndex, InterpretationFromImage interp)
        {
            if (precedingLayerIndex >= 0)
            {
                if (interp.layerWhereInterpretationEnded != layers[precedingLayerIndex])
                {
                    int start = 0;
                    if (interp.layerWhereInterpretationEnded != null)
                    {
                        start = layers.IndexOf(interp.layerWhereInterpretationEnded);
                    }

                    interp.interpretation = InterpretSubchain(layers, start, precedingLayerIndex, interp.interpretation);
                    interp.layerWhereInterpretationEnded = layers[precedingLayerIndex];
                }
            }
        }