public ViewableTreeNode(Tree node) { Node = node; Children = new BindingList<ViewableTreeNode>(); foreach (Tree child in node.GetChildren()) { Children.Add(new ViewableTreeNode(child)); } if (node.HasTag("type")){ Id = "{x=" + node.Left + ", y=" + node.Top + ", width=" + node.Width + ", height=" + node.Height + "}"; //switch(node["type"].ToString()){ // case "ptype": // Id = ((string)node["ptype_id"]); // break; // default: // Id = node["type"].ToString(); // break; //} } else Id = "node"; }
public void AfterInterpret(Tree tree) { if (_afterInterpretFunc != null) { _afterInterpretFunc(tree); } }
public void FindContent(Bitmap image, Bitmap foregroundImage, Tree currentNode, List<Tree> foundContent) { Utils.RectData[] found = ConnectedComponents.TwoPass(ccLabelingBitmap, foregroundImage, currentNode, Utils.BACKGROUND); foreach (Utils.RectData rect in found) { if(rect != null){ int hash = 17; for (int row = rect.Top; row <= rect.Bottom; row++) { for (int col = rect.Left; col <= rect.Right; col++) { hash = 31 * hash + image[row, col]; } } BoundingBox bb = new BoundingBox(rect.Left, rect.Top, (rect.Right - rect.Left) + 1, (rect.Bottom - rect.Top) + 1); Dictionary<string,object> tags = new Dictionary<string, object>(); tags.Add("type", "content"); tags.Add("pixel_hash", hash); Tree node = Tree.FromBoundingBox(bb, tags); foundContent.Add(node); } } }
public AnnotatedNode(Tree matchingNode, Tree root, JObject data, IBoundingBox region, string imageId){ this.MatchingNode = matchingNode; this.Root = root; this.Data = data; this.Region = region; this.ImageId = imageId; }
public static Tree InterpretChain(IEnumerable<LayerWrapper> layers, Tree start){ Tree.BatchTransform updater = new Tree.BatchTransform(start); Tree tree = start; LayerWrapper currLayer = null; try { foreach (LayerWrapper wrapper in layers) { currLayer = wrapper; InterpretArgs args = new InterpretArgs(tree, updater, wrapper.Intent); wrapper.Layer.Interpret(args); tree = updater.GetUpdatedTree(); wrapper.Layer.AfterInterpret(tree); } } catch(Exception e) { Tree.BatchTransform newupdater = new Tree.BatchTransform(tree); LayerException exception = new LayerException(currLayer, e); newupdater.Tag(tree, "interpretation_exception", exception); tree = newupdater.GetUpdatedTree(); } return tree; }
private void InterpretHelper(InterpretArgs args, Tree currNode) { if(currNode.Height > 3 && currNode["type"] != null && currNode["type"].Equals("content")) { args.Tag(currNode, "is_text", true); } foreach (Tree child in currNode.GetChildren()) InterpretHelper(args, child); }
public static Tree FromPixels(Bitmap image, Dictionary<string, object> tags){ BoundingBox frame = new BoundingBox(0,0, image.Width, image.Height); Tree tree = new Tree(); tree.Occurrence = frame; tree._tags = new Dictionary<string, object>(tags); tree._children = new List<Tree>(); tree._tags.Add("capturedpixels", image); tree._tags.Add("type", "frame"); return tree; }
/// <summary> /// Finds the unpredictable content using the backround regions of elements. /// </summary> /// <param name="node"></param> /// <param name="image"></param> /// <param name="background"></param> /// <param name="isForeground"></param> private static List<Tree> FindAndAddContent(InterpretArgs args, Tree node, Bitmap image, Bitmap isForeground){ Ptype ptype = (Ptype)node["ptype"]; List<Tree> allFound = new List<Tree>(); if(ptype != null){ ptype.Model.Finder.SetForeground(node, image, isForeground); } //recurse. if no siblings are overlapping (the majority case) then we can run each child in parallel. // if (!anyOverlapping(node.children())){ // List<Future<ICollection<Tree>>> asyncResults = new List<Future<ICollection<Tree>>>(); // for(final Tree child : node.children()){ // Callable<ICollection<Tree>> callable = new Callable<ICollection<Tree>>(){ // public ICollection<Tree> call(){ // return findAndAddContent(args, ptype, child, image, isForeground); // } // }; // Future<ICollection<Tree>> results = Utils.service.submit(callable); // asyncResults.add(results); // } // // for(Future<ICollection<Tree>> res : asyncResults){ // // try { // allFound.addAll(res.get()); // } catch (InterruptedException e) { // e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates. // } catch (ExecutionException e) { // e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates. // } // } // } // else //we can't run children in parallel if any nodes overlap. // //nodes only overlap when there's a false positive. so we might be able // //to trigger something here and automatically correct that. // { foreach (Tree child in node.GetChildren()) FindAndAddContent(args, child, image, isForeground); if(ptype != null){ ptype.Model.Finder.FindContent(node, image, isForeground, allFound); foreach(Tree found in allFound) args.SetAncestor(found, node); allFound.AddRange(node.GetChildren()); PrototypeDetectionLayer.SetAncestorsByContainment(allFound, args); } // } return allFound; }
public static Tree FromBoundingBox(IBoundingBox bb, Dictionary<string,object> tags){ Tree tree = new Tree(); tree.Occurrence = bb; if(tags != null) tree._tags = new Dictionary<string, object>(tags); else tree._tags = new Dictionary<string, object>(); tree._children = new List<Tree>(); return tree; }
public static int CompareByAreaAndFeaturesFirst(Tree a, Tree b) { int val = CompareByArea(a, b); if (val == 0) { if (a.HasTag("type") && a["type"].Equals("feature") && (!b.HasTag("type") || !b["type"].Equals("feature"))) return -1; else if (b.HasTag("type") && b["type"].Equals("feature")) return 1; } return val; }
public static Utils.RectData[] TwoPass(Bitmap labels, Bitmap srcBitmap, Tree root, int background) { DisjointSets linked = new DisjointSets(root.Width * root.Height); int bottom = root.Top + root.Height; int right = root.Left + root.Width; int numelements = IdentifyComponents(labels, srcBitmap, linked, root, root.GetHashCode(), bottom, right, background); //Run the second pass through the image to label each component //and create bounding rectangles LabelComponentsAndSetBoundingBoxes(labels, linked, root.Top, root.Left, bottom, right, background); return GetRectsFromLabeledImage(labels, srcBitmap, numelements, root.Top, root.Left, bottom, right, background); }
private Tree(Tree toCopy) { _tags = new Dictionary<string, object>(); foreach (var item in toCopy.GetTags()) _tags.Add (item.Key, item.Value); Occurrence = toCopy.Occurrence; List<Tree> children = new List<Tree>(); foreach (Tree child in toCopy.GetChildren()) { children.Add(new Tree(child)); } _children = children; }
public void InterpretHelper(InterpretArgs args, Tree currNode) { IEnumerable<Tree> textChildren = currNode.GetChildren().Where(c => c.ContainsTag("is_text") && (bool)c["is_text"]); List<Tree> readingOrder = SortNodesInReadingOrder(textChildren); for (int i = 0; i < readingOrder.Count - 1; i++) { Tree curr = readingOrder[i]; Tree next = readingOrder[i + 1]; args.Tag(curr, "group_next", GroupNext(curr, next)); } //recurse foreach (Tree child in currNode.GetChildren()) InterpretHelper(args, child); }
private static int IdentifyComponents(Bitmap labels, Bitmap srcBitmap, DisjointSets linked, Tree toProcess, int treeNodeIndex, int bottom, int right, int background) { int numElements = 0; //Run the first pass through the image to find any foreground content int[] neighbors = new int[8]; for (int row = toProcess.Top; row < bottom; row++) { for (int col = toProcess.Left; col < right; col++) { int sourcepixel = srcBitmap[row, col]; if (sourcepixel == treeNodeIndex) { int neighborCount = NeighborsConnected8(neighbors, toProcess, row, col, labels, background); if (neighborCount == 0) { labels[row, col] = numElements+1; numElements++; } else { int min = Min(neighbors, neighborCount); labels[row, col] = min; for(int i = 0; i < neighborCount; i++) { linked.union(min, neighbors[i]); } } } else labels[row, col] = background; } } return numElements; }
public static Tree GetParent(Tree node, Tree root) { if (root == null || node == null) return null; if (root == node) return null; if (root.GetChildren().Contains(node)) return root; foreach (Tree child in root.GetChildren()) { Tree found = GetParent(node, child); if (found != null) return found; } return null; }
public Dictionary<string, List<IAnnotation>> GetAnnotationsMatchingNode(Tree node, Tree root, string bitmapid) { var anns = AnnotationLibrary.GetAllAnnotationsForImageUsingAllLayers(_layers, bitmapid, node); var annotationsByLib = new Dictionary<string, List<IAnnotation>>(); foreach (var pair in anns) { List<IAnnotation> wrappers = new List<IAnnotation>(); foreach (var annotation in pair.Value) { wrappers.Add(new ImageAnnotationWrapper(annotation)); } annotationsByLib[pair.Key] = wrappers; } return annotationsByLib; }
private void InterpretHelper(InterpretArgs args, Tree node) { if (node.ContainsTag("type") && node["type"].Equals("ptype")) { args.Tag(node, "is_target", "true"); } else if (node.ContainsTag("type") && !node["type"].Equals("ptype")) { foreach (Tree child in node.GetChildren()) { if (child.ContainsTag("type") && !child["type"].Equals("feature") && child.GetChildren().Count() == 0) { args.Tag(child, "is_target", "true"); } } } foreach (Tree child in node.GetChildren()) InterpretHelper(args, child); }
public void WriteBackgroundAndRender(Tree tree) { VideoInterpreter.VideoCapture capture = tree["videocapture"] as VideoInterpreter.VideoCapture; IBoundingBox invalidatedpixels = tree["invalidated"] as IBoundingBox; //Todo: this is not working properly - returning null when there is a change... List<Tree> contentRegionBoxes = GetContentRegionBoxes(tree); if (invalidatedpixels != null) { _backgroundBitmap.Width = tree.Width; _backgroundBitmap.Height = tree.Height; WriteBackgroundPixels(_backgroundBitmap,contentRegionBoxes, tree); Dispatcher.BeginInvoke(_update, capture, tree, contentRegionBoxes, tree); } else { WriteBackgroundPixels(_backgroundBitmap, contentRegionBoxes, tree); Dispatcher.BeginInvoke(_update, capture, tree, contentRegionBoxes, null); } }
public Dictionary<string, List<IAnnotation>> GetAnnotationsMatchingNode(Tree node, Tree root, string bitmapid) { Dictionary<string, List<IAnnotation>> toreturn = new Dictionary<string, List<IAnnotation>>(); Dictionary<string, JToken> all = Storage.ReadAllData(); string nodepath = PathDescriptor.GetPath(node, root); List<IAnnotation> matches = new List<IAnnotation>(); foreach (string key in all.Keys) { if (key.Equals(nodepath)) { matches.Add(new PathDescriptorAnnotation(key, all[key])); } } toreturn.Add("prefab_single", matches); return toreturn; }
private static Tree GetClosestHelper(int left, int top, Tree node, out double closestDistance) { double currBestDist = double.MaxValue; Tree closestTarget = null; if(node.HasTag("is_target") && node["is_target"].ToString().ToLower().Equals("true") && (!node.HasTag("is_minor") || node["is_minor"].ToString().ToLower().Equals("false") || Keyboard.IsKeyDown(Key.LeftCtrl) ) ) { currBestDist = DistanceBetweenPointAndRectangle(left, top, node); closestTarget = node; } double bestChildDist = double.MaxValue; Tree closestChild = null; foreach (Tree child in node.GetChildren()) { double childDist = double.MaxValue; Tree childCandidate = GetClosestHelper(left, top, child, out childDist); if (childCandidate != null && childDist < bestChildDist) { bestChildDist = childDist; closestChild = childCandidate; } } if (bestChildDist < currBestDist) { closestTarget = closestChild; currBestDist = bestChildDist; } closestDistance = currBestDist; return closestTarget; }
public void AfterInterpret(Tree tree) { }
//private bool IsToTheRightAndInLine(Tree possibleLeft, Tree possibleRight) //{ // bool isInLine = BoundingBox.IsAlignedHorizontally(possibleLeft, possibleRight); // return isInLine && possibleLeft.Left + possibleLeft.Width < possibleRight.Left; //} private bool GroupNext(Tree curr, Tree next) { int leftDist; int topDist; if (BoundingBox.IsAlignedVertically(curr, next)) leftDist = 0; else if (curr.Left < next.Left) leftDist = next.Left - (curr.Left + curr.Width); else leftDist = curr.Left - (next.Left + next.Width); if (BoundingBox.IsAlignedHorizontally(curr, next)) topDist = 0; else if (curr.Top < next.Top) { topDist = next.Top - (curr.Top + curr.Height); } else { topDist = curr.Top - (next.Top + next.Height); } bool closeXDist = leftDist < MAX_SPACE_DIST; bool closeYDist = topDist < MAX_ROW_DIST; //int yDist = next.Top - curr.Top; //bool horizontallyAligned = BoundingBox.IsAlignedHorizontally(curr, next); return closeXDist && closeYDist; }
public void Remove(Tree node) { _updater.Remove(node); }
public void SetAncestor(Tree node, Tree ancestor) { _updater.SetAncestor (node, ancestor); }
public string get_path(Tree node) { return PathDescriptor.GetPath(node, tree); }
public void enqueue_set_tag(Tree node, string key, object value) { args.Tag(node, key, value); }
public void enqueue_set_ancestor(Tree node, Tree ancestor) { args.SetAncestor(node, ancestor); }
public InterpretArgs (Tree tree, Tree.BatchTransform updater, IRuntimeStorage runtimeStorage) { this._updater = updater; Tree = tree; RuntimeStorage = runtimeStorage; }
public Tree get_parent(Tree node) { return Tree.GetParent(node, tree); }
public void Tag(Tree node, string key, object value) { _updater.Tag (node, key, value); }