A lot of components in the C# environment are essentially a K-ary [kay-er-ee] tree. From tree-view nodes, to serialising a type via reflection, to directory listings to menu hierarchies, and so on.

Often we need to iterate through these types of structures, or our own trees, and we just write some code to do it as needed. This code is often problematic as it’s non-trivial to do well, because:

• It’s complex to do certain traversals in an iterative manor. (non recursive);
• Traversal is prone to bugs, as there are many edge cases;
• Software hangs if a circular reference exists and you don’t catch it;
• Unit-testing of once-off code is often neglected;
• Examining / verifying correct behaviour of tree traversal algorithms is difficult in the debugger.

Wanting to rid myself of this re-occurring situation I built a few helper methods to do the following traversals iteratively:

• Depth First Pre Order
• Depth First Post Order,
• Breadth First

The helpers are generic [BYO data type] and dont require a specific interface. You just supply a Func to return a nodes sub nodes. Thus you can drop a working tested algorithm onto whatever situation you encounter.

Iteration

Example:

• Made using an example data type “Node”
  • See the unit-tests at the  bottom of the page for implementation
• First it shows using a foreach loop on a depth first pre-order iterator
• Then is shows using a breadth-first iterator to convert a tree to an array using Linq.

/*
* Test tree
*                  A
*                / | \ 
*              B   C   D
*            / |       | \
*          E   F       G   H
*        / |         / | \
*       I  J        K  L  M
*/
Node<char> tree = Node<char>.TestTree();

//EXAMPLE 1: Pre-order traversal via foreach loop
foreach(var node in  Misc.EnumerateNodes(tree, 
                                    N => N.Nodes, 
                                    NodeVisitOrder.DepthFirstPreOrder))
{
    Console.Out.Write(node.Item);
}
Console.Out.WriteLine();
//outputs ABEIJFCDGKLMH

//EXAMPLE 2: Creating an array via breadth first traversal 
string s = new String(Misc.EnumerateNodes(tree, N => N.Nodes, NodeVisitOrder.BredthFirst)
                            .Select(N => N.Item)
                            .ToArray());
Console.Out.WriteLine(s);
//outputs ABCDEFGHIJKLM

This was a simplistic example, but it works, its unit-tested, its efficient and non-recursive. It all ties into linq and IEnumerable so many neat tricks are possible.

Lets examine the crucial line in detail.

EnumerateNodes(tree, N => N.Nodes, NodeVisitOrder.DepthFirstPreOrder)

• The first parameter is the root node. This is method is generic, so any class type will do.
• The second is a lambda expression for an enumerable  set of sub-nodes
• The third is the traversal method.

Another example of how flexible the method is, using DirectoryInfo as the node, and iterating over all subdirectories:

• This time we use the optional forth parameter to enable circular reference checking. this prevents any chance of an infinite loop

DirectoryInfo root = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments));
 
var dirs = Misc.EnumerateNodes(
                root,
                N => { try { return N.GetDirectories();  } 
                       catch (Exception) { return null; } },
                NodeVisitOrder.DepthFirstPreOrder, 
                CircularRefernceBehaviour.Skip);
 
foreach (var dir in dirs)
{
}

Duplication

Often you just need to copy one tree structure to another (possibly of a different type):

• Loading a directory structure into a TreeView control
• Turning a tree of commands into Menu Items
• Working with expression parsing  and evaluation
• Just making a deep copy of a tree structure

/*
* Test tree
*                  A
*                / | \ 
*              B   C   D
*            / |       | \
*          E   F       G   H
*        / |         / | \
*       I  J        K  L  M
*/
Node<char> tree = Node<char>.TestTree();

TreeNode n = Misc.RebuildTree(tree,  
							 N => N.Nodes, 
							 N => new TreeNode("" + N.Item), 
							 (T, N) => T.Nodes.AddRange(N.ToArray()));

Neeto, one line of code, and our tree is duplicated into a TreeView (or whatever) in a efficient, reliable manor.

RebuildTree takes five parameters:

1. The root of the tree to be copied.
2. Func for an enumerating sub-nodes in the source structure
3. Func to create a new destination  node form a source node
   • Just the data of the node, Leave the child nodes unpopulated
4. Action to add a collection of Nodes to an existing node (destination structure)
5. Circular reference checking behaviour

Core Algorithms

Depth First Pre-Order

• Note: visitOk(…) returns true unless a circular reference is detected.
• This works by feeding al nodes onto a stack, a basic way to resolve the recursion.
• Child nodes are pushed in reverse order, so they are pop’ed in the correct order.

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Pop();
	if (visitOk(item, visited, checkType))
	{
		yield return item;
		list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse());
	}
}

Depth First Post-Order

• Depth First Post-Order is actually pretty tricky, a few algorithms exist.
• This one initially traverses the entire tree O(n) to fill a stack, then returns each item in the stack.
• The overall time is O(n), with the first iteration being O(n) and all subsequent  iterations being O(1)
• There s a requirement for  extra memory for this to work, but its not too bad.

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

Stack output = new Stack();
list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Pop();
	if (visitOk(item, visited, checkType))
	{
		output.Push(item);
		list.AddLastAll(getSubNodesSafe(item, getSubNodes));
	}
}
foreach (T item in output)
{
	yield return item;
}

Breadth First

• This works by feeding al nodes onto a queue, as opposed to the depth first – pre order, which uses a stack.
  • This time Child nodes are not added in reverse order, however

LinkedList list = new LinkedList();
HashSet visited = new HashSet();

list.AddLast(node);
while (list.Count > 0)
{
	T item = list.Dequeue();
	if (visitOk(item, visited, checkType))
	{
		yield return item;
		list.AddLastAll(getSubNodesSafe(item, getSubNodes));
	}
}
break;
}

Source Code:

/*
Available under the BSD 3-Clause License
Copyright (c) 2015, Dr Warren Creemers All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using WD_toolbox;

namespace WD_toolbox
{
    public enum NodeVisitOrder { DepthFirstPreOrder, DepthFirstPostOrder, BredthFirst }

    public enum CircularRefernceBehaviour { DontCheck, ThrowException, Skip }

    public class NodeTraversalException : Exception
    {
        public NodeTraversalException(string message) : base(message) { }
        public NodeTraversalException() : base() { }
        public static NodeTraversalException VisitedTwice(object item) {return new NodeTraversalException("Node already visied: " + item.ToString());} 
    }

    public static class Misc
    {
        /// <summary>
        /// Enumerates any Tree/graph in a non-recursive manor.
        /// Does not check for circularReferences.
        /// </summary>
        /// <param name="node">Root node.</param>
        /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="order">The visit order.</param>
        /// <param name="checkType">If circular references should be checked, and how to handle them. 
        /// Note (1): Checks repeated node, which is not nesesiarly a circular reference (but all circulare references have a repeated node).
        /// Note (2): performance hit reduced if  node generates a good hashcode.
        /// </param>
        public static IEnumerable<T> EnumerateNodes<T>( T node, 
                                                        Func<T, IEnumerable<T>> getSubNodes,
                                                        NodeVisitOrder order = NodeVisitOrder.DepthFirstPreOrder,
                                                        CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where T : class
        {
            if (node != null) //assuming null indicats an empty tree
            {
                //this acts as a stack or queue to resolve the recursion
                LinkedList<T> list = new LinkedList<T>();
                HashSet<T> visited = new HashSet<T>();

                switch (order)
                {
                    case NodeVisitOrder.DepthFirstPreOrder:
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Pop();
                            if (visitOk(item, visited, checkType))
                            {
                                yield return item;
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse());
                            }
                        }
                        break;

                    case NodeVisitOrder.DepthFirstPostOrder:
                        //This has a side effects, the first iteeration is slow (also memory consuming) 
                        //as the entire structure is copied into a stack 
                        Stack<T> output = new Stack<T>();
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Pop();
                            if (visitOk(item, visited, checkType))
                            {
                                output.Push(item);
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes));
                            }
                        }
                        foreach (T item in output)
                        {
                            yield return item;
                        }
                        break;

                    case NodeVisitOrder.BredthFirst:
                        list.AddLast(node);
                        while (list.Count > 0)
                        {
                            T item = list.Dequeue();
                            if (visitOk(item, visited, checkType))
                            {
                                yield return item;
                                list.AddLastAll(getSubNodesSafe(item, getSubNodes));
                            }
                        }
                        break;
                }
            }
        }

        // Because getSubNodes(T) may return null to indicate no nodes.
        private static IEnumerable<T> getSubNodesSafe<T>(T node, Func<T, IEnumerable<T>> getSubNodes)
        {
            if ((node != null) && (getSubNodes != null))
            {
                IEnumerable<T> subNodes = getSubNodes(node);
                return (subNodes != null) ? subNodes : new List<T>();
            }
            return new List<T>();
        }

        private static bool visitOk<T>(T item, HashSet<T> visited, CircularRefernceBehaviour checkType)
        {
            if (checkType != CircularRefernceBehaviour.DontCheck)
            {
                if (visited.Contains(item))
                {
                    // error
                    if (checkType == CircularRefernceBehaviour.ThrowException)
                    {
                        throw NodeTraversalException.VisitedTwice(item);
                    }
                    return false; //indicate it's not ok to visit (ie skip)
                }

                //no error
                visited.Add(item);
                return true;
            }

            //no check
            return true;
        }


        /// <summary>
        /// Copies a tree structure. (useful in copying a tree structure to a tree view).
        /// </summary>
        /// <typeparam name="A">The node type of the tree to copy.</typeparam>
        /// <typeparam name="B">The destination node type.</typeparam>
        /// /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="newNode">To create a simple non-recursive copy of a node.</param>
        /// <param name="addSubNodes"></param>
        /// <param name="checkType"> Type of circular reference checking to perform.</param>
        /// <returns></returns>
        public static B RebuildTree<A, B>(A srcNode,
                                           Func<A, IEnumerable<A>> getSubNodes,
                                           Func<A, B> newNode,
                                           Action<B, IEnumerable<B>> addSubNodes,
                                           CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where A : class
            where B : class
        {
            return RebuildTree(srcNode, getSubNodes, newNode, addSubNodes, P => true, checkType);
        }
        
        /// <summary>
        /// Copies a tree structure. (useful in copying a tree structure to a tree view).
        /// </summary>
        /// <typeparam name="A">The node type of the tree to copy.</typeparam>
        /// <typeparam name="B">The destination node type.</typeparam>
        /// /// <param name="getSubNodes"> Get the sub-nodes of any given node.</param>
        /// <param name="newNode">To create a simple non-recursive copy of a node.</param>
        /// <param name="addSubNodes"></param>
        /// <param name="where"></param>
        /// <param name="checkType"> Type of circular reference checking to perform.</param>
        /// <returns></returns>
        public static B RebuildTree<A, B>( A srcNode,
                                           Func<A, IEnumerable<A>> getSubNodes, 
                                           Func<A, B> newNode,
                                           Action<B, IEnumerable<B>> addSubNodes,
                                           Predicate<A> where,
                                           CircularRefernceBehaviour checkType = CircularRefernceBehaviour.DontCheck)
            where A : class
            where B : class
        {


            LinkedList<Tuple<A, B>> list = new LinkedList<Tuple<A, B>>();
            HashSet<A> visited = new HashSet<A>();
            B newRootNode = null;

            list.AddLast(new Tuple<A, B>(srcNode, null));
            while (list.Count > 0)
            {
                var tuple = list.Pop();
                A item = tuple.Item1;
                B parent = tuple.Item2;

                if (visitOk(item, visited, checkType))
                {
                    if (where(item))
                    {
                        B newItem = newNode(item);
                        if (newRootNode == null) //root node
                        {
                            newRootNode = newItem;
                        }

                        safeAddSubNode(parent, newItem, addSubNodes);
                        
                        list.AddLastAll(getSubNodesSafe(item, getSubNodes).Reverse().Select(N => new Tuple<A, B>(N, newItem)));
                    }
                }
            }

            //done
            return newRootNode;
        }

        private static void safeAddSubNode<B>(B parent, B child, Action<B, IEnumerable<B>> addSubNodes)
        {
            if ((addSubNodes != null) && (parent != null) && (child != null))
            {
                addSubNodes(parent, new B[] { child });
            }
        }
    }
}

Requires The following Extension class to make LinkedList sane.

/*
Available under the BSD 3-Clause License
Copyright (c) 2015, Dr Warren Creemers All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/// <summary>
/// These extensions make usage of the LinkedList more consise.
/// </summary>
public static class LinkedListExtension
{
	/// <summary>
	/// Pops the last value of the linked list.
	/// </summary>
	/// <returns> Value of the (formerly) last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T Pop<T>(this LinkedList<T> list)
	{
		T item = list.Last.Value;
		list.RemoveLast(); //throws InvalidOperationException
		return item;
	}

	/// <summary>
	/// Dequeues the first value of the linked list.
	/// </summary>
	/// <returns> Value of the (formerly) first item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T Dequeue<T>(this LinkedList<T> list)
	{
		T item = list.First.Value;
		list.RemoveFirst(); //throws InvalidOperationException
		return item;
	}

	/// <summary>
	/// Gets the last value of the linked list.
	/// </summary>
	/// <returns> Value of the last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T PeekLast<T>(this LinkedList<T> list)
	{
		if (list.Count <= 0)
		{
			throw new InvalidOperationException("LinkedList is empty (call to PeekLast)");
		}

		T item = list.Last.Value;
		return item;
	}

	/// <summary>
	/// Gets the last value of the linked list.
	/// </summary>
	/// <returns> Value of the last item in the list. </returns>
	/// <exception cref="System.InvalidOperationException"> The LinkedList is empty.</exception>
	public static T PeekFirst<T>(this LinkedList<T> list)
	{
		if (list.Count <= 0)
		{
			throw new InvalidOperationException("LinkedList is empty (call to PeekFirst)");
		}

		T item = list.First.Value;
		return item;
	}

	/// <summary>
	/// Addss items to the end of the list.
	/// </summary>
	/// <param name="items">Items to add.</param>
	public static void AddLastAll<T>(this LinkedList<T> list, IEnumerable<T> items)
	{
		foreach (T item in items)
		{
			list.AddLast(item);
		}
	}

	/// <summary>
	/// Addss items to the end of the list.
	/// </summary>
	/// <param name="items">Items to add.</param>
	public static void AddFirstAll<T>(this LinkedList<T> list, IEnumerable<T> items)
	{
		foreach (T item in items)
		{
			list.AddFirst(item);
		}
	}
}

Unit Tests:

       [TestMethod()]
        public void EnumerateNodesTest()
        {
            /*
            * Test tree
            *                  A
            *                / | \ 
            *              B   C   D
            *            / |       | \
            *          E   F       G   H
            *        / |         / | \
            *       I  J        K  L  M
            */
            Node<char> tree = Node<char>.TestTree();

            Node<char> coruptTree = Node<char>.TestTree();
            //point L  to A
            coruptTree.Nodes[2].Nodes[0].Nodes[1].Nodes.Add(coruptTree); 

            //DepthFirstPreOrder
            string res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                        NodeVisitOrder.DepthFirstPreOrder, 
                                                        CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());



            //System.Diagnostics.Trace.WriteLine("Hello World");
            Assert.AreEqual("ABEIJFCDGKLMH", res);
            
            //DepthFirstProstOrder
            res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                    NodeVisitOrder.DepthFirstPostOrder,
                                                    CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());
            Assert.IsTrue(res == "IJEFBCKLMGHDA");

            //BredthFirst
            res = new String(Misc.EnumerateNodes(tree, N => N.Nodes, 
                                                 NodeVisitOrder.BredthFirst,
                                                 CircularRefernceBehaviour.ThrowException).Select(N => N.Item).ToArray());
            Assert.AreEqual("ABCDEFGHIJKLM", res);

            //just to check no exception thrown
            TreeNode n = Misc.RebuildTree(tree,  
                                         N => N.Nodes, 
                                         N => new TreeNode("" + N.Item),
                                         (T, N) => T.Nodes.AddRange(N.ToArray()), 
                                         CircularRefernceBehaviour.ThrowException);

            //Check an exception is thrown for curupted tree

            try
            {
                n = Misc.RebuildTree(coruptTree,
                                             N => N.Nodes,
                                             N => new TreeNode("" + N.Item),
                                             (T, N) => T.Nodes.AddRange(N.ToArray()),
                                             CircularRefernceBehaviour.ThrowException);

                Assert.Fail("Should never reach this line of code");
            }
            catch (Exception)
            {
            }

            //Just handle a corupt tree by not going backward.
            n = Misc.RebuildTree(coruptTree,
                                 N => N.Nodes,
                                 N => new TreeNode("" + N.Item),
                                 (T, N) => T.Nodes.AddRange(N.ToArray()),
                                 CircularRefernceBehaviour.Skip);

            //NB: Infinite loop on fail

        }

        

        public class Node<T>
        {
            public List<Node<T>> Nodes = new List<Node<T>>();
            public T Item;
            public Node(T item, IList<Node<T>> nodes = null)
            {
                Item = item;
                if (nodes != null)
                {
                    Nodes.AddRange(nodes);
                }
            }

            private static Node<T> NODE<T>(T item, params Node<T>[] Nodes)
            {
                return new Node<T>(item, Nodes);
            }

            public static Node<char> TestTree()
            {
                /*
                * Test tree
                *                  A
                *                / | \ 
                *              B   C   D
                *            / |       | \
                *          E   F       G   H
                *        / |         / | \
                *       I  J        K  L  M
                */


                Node<char> tree =
                    NODE('A',
                        NODE('B',
                            NODE('E',
                                NODE('I'),
                                NODE('J')
                                ),
                            NODE('F')
                            ),
                        NODE('C'),
                        NODE('D',
                            NODE('G',
                                NODE('K'),
                                NODE('L'),
                                NODE('M')
                                ),
                            NODE('H')
                            )
                        );

                return tree;
            }
        }
    }

WDLib Library:

This is part of my personal toolbox, WDLib (in the misc class, which is abridged for clarity on this page). I am moving to open source the library at the moment.

Limitations and Usage:

• The circular reference check just checks for a repeated node, which is not necessarily a circular reference (but all circular references have a repeated node). This may deny some malformed trees that could otherwise be safely parsed. Checking can always be disabled if this is your intent.
• Be aware the first iteration of the Depth First Post-Order has a O(n) overhead.

Contact / Feedback

[Sorry I had to remove this, because hundreds of spam emails about SEO]

Introduction

Laser engraving text on acrylic / perspex does not create a lot of contrast. This leads to the subject of painting text on the acrylic. I have developed some useful methods of achieving this that I thought I would share.

My techniques achieve a good hard wearing result. One of them allows for painting everything except the text, to allow for back lighting. Note: As I often have to bend and mould Perspex, I needed a procedure that could be implemented on the final moulded pieces. This meant that using a laser cutter to remove paint was not an option.

Technique 1, Painting the text.

This effect is a little more difficult than would appear at first glance. You want to paint the whole area and remove only the paint that’s not in the text. Problem is doing this by washing with solvents will thin the paint and dilute the finish, reducing the contrast. There is a neat trick you an use however, it involves pouring water over an oil based paint to form a gum in the lettering, which is resistant to solvents.

• Laser engrave the text with a deep cut (1mm -ish).
• Prepare the piece (bend, polish etc.)
• Spray paint with a cheap oil based paint (the kind that gums with water). The “Fiddly Bits” brand works well.
• Wait 30sec to a minute.
• Place piece under running water for a couple of seconds.
• You should now be looking at a complete disaster, the finish is ruined and everything is a kinda horrid sticky mess.
• Get a thin micro-fiber disposable cloth, dip in turpentine.
• Scrub the surface (will require elbow grease and persistence).
• Presto, the only stuff you cant scrub out is this awesome looking text.

Technique 2, Painting everything that is not text.

This seems like an odd way of doing things, but offers some interesting advantages:

• Done on translucent acrylic, you can now do back-lighting
• You can paint gradients / flames etc. and still have blacked out text.
• You can always find the right coloured paint on short notice, while acrylic colours are at the mercy of your supplier.

This technique is actually a lot simpler than the first technique, but a lot less forgiving to errors.

• Engrave text with the quick shallow cut. You basicly just want to rough the surface.
• Prepare the piece (bend, polish etc.)
• Wipe turpentine over the piece with a cloth.
• Gently (half) dry the surface with a dry cloth. Leave the thinnest smear don’t dry out the letters.
• Wait 20 seconds to allow for some evaporation to occur.
• Spray paint a very thin layer.
• The text area will still have some turps, and also possesses a higher surface tension due to its roughness.
  • The paint will move away from the text forming on the flat, smooth areas.
• Repeat coats using this procedure as needed.

   
(Left, final product. Right. first coat)

Useful image for teachers, overhead slides etc.
NB: This is not always a good DIY or classroom activity. Be aware that some electrical components create a seriously hazardous dust when broken open. Rectifiers, Hi Power transistors, Older IC’s & IC’s with certain head spreaders as well as some IC’s designed for use in microwaves contain Beryllium Oxide.  While safe to handle, the dust particles created when they are damaged will make you gravely ill.

Download large and detailed image [4096 x 5686] (1.5mb) here
Download full scan [16394 x 22761] (27mb, use save as, because images this large still crash some broswers) here

What’s the white grid? Its a standard prototyping board, used to protect the scanner from the IC’s pins.

Solution in this video.

I spent a lot of time calculating track widths to make sure my circuit board could handle the current I was using.
Then I had to do more calculations for font ratios. so that that all lines were wide enough to work with the silk screening process.

Sick of this; I quickly used matlab to create a few charts so I could look up the answers quickly.
I thought I would share these charts and the matlab scripts, hope they are useful.

Font Ratio Chart

To my experience, In Eagle Cad (and others) font ratios for silk screens work best using vector fonts. The cam processor, other tools, and factory will often use vector fonts regardless; – so using vector fonts tends to keep things compatible. In the text properties dialogue you must set the ratio correctly so that (Size * Ratio) > “Factory Minimum Line Width”.  To make it worse, fonts are best wrangled using Mils (1/1000th of an inch [what’s an inch]).

Typically in Eagle Cad, I would set up text for silk-screening as follows.

Anyway, here is the chart

To use it:

• Find the colour that corresponds to your manufactures minimum silk screen resolution.
• Find your font height in the x-axis
• The corresponding ratio is given in the y-axis.

PCB Track Width Chart

Track width is related to a lot of factors (acceptable temperatures. how insulated the tracks are from the air, current, acceptable power loss, etc). For anything complicated (internal PCB layers, high currents/voltages, installation in a vehicle/ heater / oven) go do proper calculations!

Looking for a good track width calculator, I found this and like it a lot:  http://www.4pcb.com/trace-width-calculator.html

99% of the time, as a hobbyist, you just want an external PCB track that does not raise in temperature by more than 10ºC. You would be using either 0.5, 1 or 2 oz copper tracks (eek, more imperial units). So I implemented the formula presented on the calculator mentioned above in matlab.  Then I plotted 3 lines, one for each common copper thickness, creating charts that seem correct for normal hobbyist type situations.

Four charts follow metric and imperial versions of high and low current situations. Find the graph that suits you and keep it handy.

Disclaimer: Your mileage may vary. A) I may be wrong, and accept no liability for that. B) Silkscreens, lacquer, protective coatings, hot electrical components may invalidate these figures.  If your doing anything medical / military /  safety critical / mass produced / potentially dangerous; this page is not an appropriate source of information, go find an engineering book, or something peer reviewed.

Metric – High Amps

Metric – Low Amps

Mils (Imperial)- High Amps

Mils (Imperial)- Low Amps

Source Code

Fonts

%----------------------------------------------------------------------------------%
%                                    BUSYDUCKS.COM                                 %
%                            Making you pro-duck-tive                              %
%                                                                                  %
%  Author: Duckman   Date: 10/3/15   Ver: 1.0   Licence: Creative Commons (by-sa)  %
%                                                                                  %
%  Calculates silckscreen font ratios.                                             %
%  Compile with Matlab / Possibly Octave                                           %
%                                                                                  %
%  Permision given to freely copy/paste "code snippets" into your own code. For    %
%  other uses (e.g. derivative works) the Creative Commons Attribution Share-      %
%  alike license applies (cite busyducks.com). This means commercial use is ok.    %
%----------------------------------------------------------------------------------%
s = [10 : 5 : 100];
r = zeros(7, max(size(s)))

for x = 2:8
    r(x-1,:) = ((x*100) ./ s)';
    plot(s, r);
end

plot(s, r);
title('PCB Silk Screen Font Ratios')
xlabel('Font Height (Mils)')
ylabel('Font Ratio (%)')
legend('2 Mil', '3 Mil', '4 Mil', '5 Mil', '6 Mil', '7 Mil', '8 Mil');
grid on

Track Width

%----------------------------------------------------------------------------------%
%                                    BUSYDUCKS.COM                                 %
%                            Making you pro-duck-tive                              %
%                                                                                  %
%  Author: Duckman   Date: 10/3/15   Ver: 1.0   Licence: Creative Commons (by-sa)  %
%                                                                                  %
%  Calculates Track widths.                                                        %
%  Compile with Matlab / Possibly Octave                                           %
%                                                                                  %
%  Permision given to freely copy/paste "code snippets" into your own code. For    %
%  other uses (e.g. derivative works) the Creative Commons Attribution Share-      %
%  alike license applies (cite busyducks.com). This means commercial use is ok.    %
%----------------------------------------------------------------------------------%
function plotTraceWidth (metric, small)
%Formula from: http://www.4pcb.com/trace-width-calculator.html
%sample usage: plotTraceWidth(true, false);  
%will save a .png to the current working directory;  

amps = [0.1 : 0.1 : 10];
thickness = [0.5, 1, 2];

if(small)
    amps = amps * 0.2;
end

%external layers, IPC-2221
 k = 0.048;
 b = 0.44;
 c = 0.725;
 tempRise = 10; %deg C

factor = (k*tempRise^b);

for it = 1:3
    t = thickness(it);
    area = amps./factor;
    area = area.^(1/c);
    width(it,:) = (area./(t*1.378))';
end

if (metric)
    %convert to metric
    mmPerMil = 0.0254;
    width = width .* mmPerMil;
end

plot(amps, width);
title('PCB Track Width')
xlabel('Amps')
legend('0.5 oz', '1 oz', '2 oz', 2);

name = 'track_width';
if (metric)
    ylabel('Track Width (mm)')
    ticks = [1:15];
    name = [name '_metric'];
    if(small)
        ticks  = [0.2:0.2:2];
        name = [name '_small'];
    end
else
    ylabel('Track Width (Mils)')
    name = [name '_mils'];
    ticks = [50:50:2000];
    if(small)
         ticks = [10:10:200];
        name = [name '_small'];
    end
end
set(gca,'Ytick', ticks)
grid on
saveas(gcf, [name '.png']);

Text:

• ‘Project Gutenberg’ massive collection of books older than 80 years (expired copyright). via custom iso image here, iso of popular books here, or via rsync here.
• ‘Enron corpus’  500,000ish actual emails. here
• ‘ClueWeb09 Datase’ 2009 Archive of 1 billion web pages (various languages) [5 TB, compressed. 25 TB, uncompressed.]. here
• ‘arXiv archive’. Giant collection of scientific papers in pdf format.  here
• ‘SMS Spam Collection’ 5000+ SMS messages tagged as spam or not. here
• Google n-grams (from web pages)  here
• Google n-grams (from books) here

Linguistics

• ‘Wordnet’ Database of English words.  Words are grouped, linked and organised. here.
• Yahoo labs. A collection of data from Yahoo searches/questions/ratings/images here

Knowledge

• ‘Freebase’  cira 1 billion facts. [will be retired July 2015] here
• ‘Mizar Project’ 10’s of thousands of mathematical definitions, formulas and proofs; in machine readable format. here
• ‘Stack Exchange’ Questions and answers from many popular forums. Computer readable dumps and a query API. here
• ‘DBpedia’ Parsed and structured information extracted from Wikipedia.  here
• ‘Cross-Lingual Dictionary for English Wikipedia Concepts’  Maps concepts to relevant Wikipedia articles. here

Images

• ‘Visual Dictionary’ Images for 50,000+ nouns in the English language, by MIT.  here
• ‘Imagenet’ Pictures matching the hierarchy of Word-net noun nodes. here
• ‘MNIST database’  70,000 handwritten digits. here
• ” An index to all sorts of computer vision data-sets. here
• ‘Label me’ Labeled things in images from MIT here
• ‘KTH-TIPS’ Textures under varying illumination, pose and scale. here
• ‘MS COCO’ 91 object-types, 2.5 million labels in 328,000 images. here

Music

• ‘Million Song Data Set’ Audio features and other meta data for a million modern popular music tracks. here
• ‘Last.fm API’ Access to all  last.fm user/playlist/music/artist/geo/genre/tag data. A history of who listened to what/when/where   here

Society

• WHO ‘Global Health Observatory’  Lots of usable data about all heal related issues.  here
• ‘ICPSR 4572’  Extensive stats on (USA) prisoners.  here
• Drug usage (USA) , large survey with many variables, who/what/why  here

Social Networks

• ‘Social Network Analysis Interactive Dataset Library’. Contains computer readable images of 300+ online social networks. here
• ‘Stanford Large Network Dataset Collection’ Graphs of assorted webpages (eg. Facebook / Twitter) here

Geology:

• ‘Global Historical Earthquakes’  All known earthquakes (prior to 1903). here and also this.

Misc

• ‘Open Product Data’. International set of product bar-codes. here
• ‘Amazon reviews’ 34 million product reviews covering 2 million products. here.
• ‘USDA National Nutrient Database for Standard Reference’ The nutrients (typically) found in different foods. here
• ‘Open Library Data Dumps’ Very large dump of library records (author, work, revision, etc). here
• ‘List of lists of lists’  The pages listing lists got so prolific… we needed a list of them.  here