public void Execute(ScriptContext context /*, System.Windows.Window window*/)
 {
     //Get correct structure set... In our case structure set is named "PSOAS"
     var ss = context.Patient.StructureSets
     .FirstOrDefault(s => s.Structures.Any(st => st.Id.Equals("PSOAS", StringComparison.InvariantCultureIgnoreCase)));
     //Find the structure named "L5_MID"
     var l5mid = ss.Structures.FirstOrDefault(s => s.Id.Equals("L5_MID", StringComparison.InvariantCultureIgnoreCase));
     double avg = double.NaN;
     if (l5mid != null)
     {
         //Create a map of slice area to image slice, so we know which slice to sample
         var l5midContours = GetSliceAreas(ss.Image, l5mid);
         //If all slices have a NaN value, then there is no contour
         if (!l5midContours.Any(p => !double.IsNaN(p.Value) && p.Value > 0))
         {
             MessageBox.Show("L5 Mid not found");
         }
         else
         {
             //Assumption is L5 contour is only on one slice, find the first slice with a valid area
             var z = l5midContours.First(p => !double.IsNaN(p.Value) && p.Value > 0).Key;
             avg = GetSliceHUAvg(ss.Image, z, l5mid);
             MessageBox.Show(string.Format("L5_MID Stats :\nArea: {0} cm^2\nHUavg = {1} HU", l5midContours[z].ToString("F2"), avg.ToString("F2")));
         }
     }
 }

        public static object Eval(XmlNode node, ScriptContext ctx)
        {
            string varName = XmlHelper.ReadAttribute(node, "var");
            string className = XmlHelper.ReadAttribute(node, "class");
            string propertyName = XmlHelper.ReadAttribute(node, "property");

            object value = ctx.Eval(node.ChildNodes);

            if (varName != null)
            {
                if (propertyName == null)//Assign a new value to the variable
                {
                    ctx.State[varName] = value;
                }
                else //assign a property of the variable
                {
                    ReflectionHelper.SetProperty(ctx.State[varName], propertyName, value);
                }
            }
            else if (className != null) //static property
            {
                throw new NotImplementedException("Static property setter not implemented");
            }

            return value;
        }

        public static object Eval(XmlNode node, ScriptContext ctx)
        {
            string varName = XmlHelper.ReadAttribute(node, "var");
            string className = XmlHelper.ReadAttribute(node, "class");
            string propertyName = XmlHelper.ReadAttribute(node, "property");

            object result = null;

            if (varName != null)
            {
                if (propertyName == null)//Get the variable itself
                {
                    result = ctx.State[varName];
                }
                else //assign a property of the variable
                {
                    result = ReflectionHelper.GetProperty(ctx.State[varName], propertyName);
                }
            }
            else if (className != null) //static property
            {
                throw new NotImplementedException("Static property getter not implemented");
            }

            return result;
        }

        public string Eval(string command, ScriptContext context = null)
        {
            if(context == null)
                context = new ScriptContext(Guid.NewGuid().ToString(), null, CancellationToken.None, _services, null);

            return _variableReplacer.Replace(command, context);
        }

        public bool Evaluate(string block, ScriptContext context)
        {
            var replacer = context.Get<IVariableReplacer>();
            var scriptLog = context.Get<IScriptLog>();

            var replaced = replacer.Replace(block, context);
            // replace single equals with double equals
            replaced = Regex.Replace(replaced, "([^=:<>])=(?!=)", "$1==");

            if(context.DebugLevel > 0) {
                scriptLog.Log(context.Name, "if {0}".ToFormat(replaced), context.LineNumber);
            }

            try
            {
                var interpreter = new Interpreter();
                var result = (bool)interpreter.Eval(replaced);
                if(context.DebugLevel > 0) {
                    scriptLog.Log(context.Name, "if result {0}".ToFormat(result.ToString().ToLower()), context.LineNumber);
                }
                return result;
            }
            catch(Exception exc)
            {
                scriptLog.Log(context.Name, "if result {0}".ToFormat(exc), context.LineNumber);

                return false;
            }
        }

 public static object Modulus(XmlNode node, ScriptContext ctx)
 {
     if(node.ChildNodes.Count != 2) throw new Exception();
     int a = (int) ctx.Eval(node.ChildNodes[0]);
     int b = (int)ctx.Eval(node.ChildNodes[1]);
     return a % b;
 }

        public override Task<CompletionEventArgs> Execute(ScriptContext context, Token token)
        {
            if(context.DebugLevel > 0) {
                context.Get<IScriptLog>().Log(context.Name, "waitforre " + token.Value, context.LineNumber);
            }

            return base.Execute(context, token);
        }

 public static ObjectValue CreatePointObject(ScriptContext ctx, float x, float y)
 {
     return ctx.Srm.CreateNewObject((obj) =>
     {
         obj["x"] = x;
         obj["y"] = y;
     });
 }

 public static object And(XmlNode node, ScriptContext ctx)
 {
     foreach(XmlNode childNode in node.ChildNodes)
     {
         if (!(bool)ctx.Eval(childNode)) return false;
     }
     return true;
 }

        public string Replace(string data, ScriptContext context)
        {
            data = SetArguments(data, context);
            data = SetLocalVars(data, context);
            data = SetGlobalVars(data, context);

            return data;
        }

 public Task Echo(string command, ScriptContext context = null)
 {
     return Publish(command, context, t => {
         t.Color = "#00FFFF";
         t.Mono = true;
         if(context != null && context.DebugLevel > 0)
             _scriptLog.Log(context.Name, "echo {0}".ToFormat(t.Text), context.LineNumber);
     });
 }

        /// <summary>
        /// Constructs a new instance of an <see cref="AppScope"/>.
        /// </summary>
        /// <param name="name">The unique name for the scope.</param>
        /// <param name="parent">The parent scope to attach to the scope.</param>
        /// <param name="context">The execution context that is used to execute scripts.</param>
        internal SessionScope(string name, AppScope parent, ScriptContext context)
            : base(name, parent, context, context.GetPrototype("Session"))
        {
            // Create a new channel linked to the session
            this.SessionChannel = new Channel(context);

            // When creating, set the current thread channel
            Channel.Current = this.SessionChannel;
        }

        public static object LessThanOrEqual(XmlNode node, ScriptContext ctx)
        {
            if(node.ChildNodes.Count != 2) throw new Exception("Expected 2 child nodes");
            object o1 = ctx.Eval(node.ChildNodes[0]);
            object o2 = ctx.Eval(node.ChildNodes[1]);

            var n1 = o1 is double ? (double) o1 : (int) o1;
            var n2 = o2 is double ? (double)o2 : (int) o2;
            return n1 <= n2;
        }

        public virtual Task<CompletionEventArgs> Execute(ScriptContext context, Token token)
        {
            Token = token;
            Context = context;
            TaskSource = new TaskCompletionSource<CompletionEventArgs>();

            execute();

            return TaskSource.Task;
        }

 public static object Add(XmlNode node, ScriptContext ctx)
 {
     double sum = 0;
     foreach(XmlNode childNode in node.ChildNodes)
     {
         object o =  ctx.Eval(childNode);
         double operand = o is int ? (int) o : (double) o;
         sum += operand;
     }
     return sum;
 }

        public static object Eval(XmlNode node, ScriptContext ctx)
        {
            XmlNode condition = node.FirstChild;

            object result = null;
            while ((bool)(ctx.Eval(condition)))
            {
                result = ctx.Eval(node.ChildNodes, 1, node.ChildNodes.Count-1);
            }
            return result;
        }

        private string SetGlobalVars(string data, ScriptContext context)
        {
            var matches = Regex.Matches(data, Global_Vars_Regex);
            foreach(Match match in matches) {
                var value = context.GlobalVar.Get(match.Groups[1].Value);
                if(!string.IsNullOrWhiteSpace(value))
                    data = Regex.Replace(data, match.Groups[0].Value.Replace("$", "\\$"), value);
            }

            return data;
        }

        public Task EchoCommand(string command, ScriptContext context = null)
        {
            var formatted = command;
            if(context != null && !string.IsNullOrWhiteSpace(context.Name)) {
                formatted = "[{0}]: {1}".ToFormat(context.Name, command);
            }

            return Publish(formatted, context, t => {
                t.Color = "ADFF2F";
            });
        }

        public ScriptBuilder(FrontContext frontContext, HtmlHelper htmlHelper)
        {
            _htmlHelper = htmlHelper;
            _frontContext = frontContext;

            var viewData = _frontContext.ViewData;
            if (viewData.ScriptContext == null)
            {
                viewData.ScriptContext = new ScriptContext();
            }
            _scriptContext = viewData.ScriptContext;
        }

        private string SetLocalVars(string data, ScriptContext context)
        {
            if(context.LocalVars != null) {
                var matches = Regex.Matches(data, Local_Vars_Regex);
                foreach(Match match in matches) {
                    var value = context.LocalVars.Get(match.Groups[1].Value);
                    if(!string.IsNullOrWhiteSpace(value))
                        data = Regex.Replace(data, match.Groups[0].Value, value);
                }
            }

            return data;
        }