clock interval

diff --git a/dev3/psychlops/core/device/clock.cs b/dev3/psychlops/core/device/clock.cs
index 2a19011..bc52821 100644 (file)
--- a/dev3/psychlops/core/device/clock.cs
+++ b/dev3/psychlops/core/device/clock.cs
@@ -3,4 +3,58 @@
 namespace Psychlops\r
 {\r
 \r
+       public struct Clock\r
+       {\r
+               long ticks;\r
+               // where ticks unit is 100 nano seconds.\r
+\r
+               public void update()\r
+               {\r
+                       ticks = DateTime.Now.Ticks;\r
+               }\r
+               public long at_msec()\r
+               {\r
+                       return ticks/10000;\r
+               }\r
+\r
+               public static Clock operator +(Clock lhs, Clock rhs)\r
+               {\r
+                       return new Clock { ticks = lhs.ticks + rhs.ticks };\r
+               }\r
+               public static Clock operator -(Clock lhs, Clock rhs)\r
+               {\r
+                       return new Clock { ticks = lhs.ticks - rhs.ticks };\r
+               }\r
+\r
+               public static bool operator ==(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks == rhs.ticks;\r
+               }\r
+               public static bool operator !=(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks != rhs.ticks;\r
+               }\r
+               public static bool operator >(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks > rhs.ticks;\r
+               }\r
+               public static bool operator <(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks < rhs.ticks;\r
+               }\r
+               public static bool operator >=(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks >= rhs.ticks;\r
+               }\r
+               public static bool operator <=(Clock lhs, Clock rhs)\r
+               {\r
+                       return lhs.ticks <= rhs.ticks;\r
+               }\r
+\r
+               public override string ToString()\r
+               {\r
+                       return ticks.ToString();\r
+               }\r
+       }\r
+\r
 }\r

diff --git a/dev3/psychlops/core/graphic/canvas.cs b/dev3/psychlops/core/graphic/canvas.cs
index 297499e..9d2cad3 100644 (file)
--- a/dev3/psychlops/core/graphic/canvas.cs
+++ b/dev3/psychlops/core/graphic/canvas.cs
@@ -207,9 +207,12 @@ namespace Psychlops
                        if (nextIntervalFrame <= 0)\r
                        {\r
                                var tmp = new System.Windows.Controls.Canvas();\r
-                               foreach (Internal.PrimitiveFigure f in stack)\r
+                               if (stack.Count > 0)\r
                                {\r
-                                       tmp.Children.Add(f.toNative());\r
+                                       foreach (Internal.PrimitiveFigure f in stack)\r
+                                       {\r
+                                               tmp.Children.Add(f.toNative());\r
+                                       }\r
                                }\r
                                api_canvas.Children.Clear();\r
                                api_canvas.Children.Add(tmp);\r

diff --git a/dev3/psychlops/core/graphic/module.cs b/dev3/psychlops/core/graphic/module.cs
index 853717e..ac8000e 100644 (file)
--- a/dev3/psychlops/core/graphic/module.cs
+++ b/dev3/psychlops/core/graphic/module.cs
@@ -43,6 +43,10 @@ namespace Psychlops
                {\r
                        return new Point(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);\r
                }\r
+               public override string ToString()\r
+               {\r
+                       return "X:"+ x.ToString() + " Y:"+ y.ToString() + " Z:"+ z.ToString();\r
+               }\r
        }\r
 \r
 \r
@@ -88,6 +92,11 @@ namespace Psychlops
                        a = alpha;\r
                }\r
 \r
+               public override string ToString()\r
+               {\r
+                       return "R:" + r.ToString() + " G:" + g.ToString() + " B:" + b.ToString() + " A:" + a.ToString();\r
+               }\r
+\r
                public static readonly Color\r
                        black = new Color(0, 0, 0, 1),\r
                        red = new Color(1, 0, 0, 1),\r

diff --git a/dev3/psychlops/core/graphic/shape.cs b/dev3/psychlops/core/graphic/shape.cs
index cbafab0..f92e989 100644 (file)
--- a/dev3/psychlops/core/graphic/shape.cs
+++ b/dev3/psychlops/core/graphic/shape.cs
@@ -165,6 +165,10 @@ namespace Psychlops{
                public Color fill { get; set; }\r
                public Stroke stroke { get; set; }\r
 \r
+               public override string ToString()\r
+               {\r
+                       return "Left:" + left.ToString() + " Top:" + top.ToString() + " Right:" + right.ToString() + " Bottom:" + bottom.ToString();\r
+               }\r
        }\r
 \r
 \r

diff --git a/dev3/psychlops/core/math/interval.cs b/dev3/psychlops/core/math/interval.cs
index fd67eb0..6426046 100644 (file)
--- a/dev3/psychlops/core/math/interval.cs
+++ b/dev3/psychlops/core/math/interval.cs
@@ -1,6 +1,188 @@
 using System;\r
+using Psychlops.Internal;\r
+\r
 \r
 namespace Psychlops\r
 {\r
 \r
+       public struct Interval {\r
+               public enum OPERATOR { CLOSE, OPEN };\r
+               public const OPERATOR CLOSE = OPERATOR.CLOSE, OPEN = OPERATOR.OPEN;\r
+               public struct VAL {\r
+                       public double val;\r
+                       public OPERATOR op;\r
+                       public VAL(double v, OPERATOR o)\r
+                       {\r
+                               val = v;\r
+                               op = o;\r
+                       }\r
+                       public bool bounded()\r
+                       {\r
+                               return !Double.IsNaN(val) && (!Double.IsInfinity(val) || op == OPERATOR.OPEN);\r
+                       }\r
+               }\r
+               public VAL begin, end;\r
+\r
+               /*\r
+               public Interval()\r
+               {\r
+                       begin = new VAL { val = Double.PositiveInfinity, op = OPERATOR.CLOSE };\r
+                       end = new VAL { val = Double.NegativeInfinity, op = OPERATOR.CLOSE };\r
+               }\r
+               */\r
+               public Interval(double floor_val, double ceil_val)\r
+               {\r
+                       begin.val = floor_val;\r
+                       begin.op =  OPERATOR.CLOSE;\r
+                       end.val = ceil_val;\r
+                       end.op = OPERATOR.CLOSE;\r
+               }\r
+               public Interval(double floor_val, OPERATOR floor_op, double ceil_val, OPERATOR ceil_op)\r
+               {\r
+                       begin.val = floor_val;\r
+                       begin.op = floor_op;\r
+                       end.val = ceil_val;\r
+                       end.op = ceil_op;\r
+               }\r
+\r
+               /*\r
+               public int int_floor();\r
+               public int int_floor(int minval);\r
+               public int int_ceil();\r
+               public int int_ceil(int maxval);\r
+               */\r
+               bool includes(double val)\r
+               {\r
+                       bool result = false;\r
+                       switch(begin.op) {\r
+                               case OPERATOR.CLOSE:\r
+                               result = begin.val<=val ? true : false;\r
+                               break;\r
+                               case OPERATOR.OPEN:\r
+                               result = begin.val<val ? true : false;\r
+                               break;\r
+                       }\r
+                       switch(end.op) {\r
+                               case OPERATOR.CLOSE:\r
+                               result = result && ( end.val>=val ? true : false );\r
+                               break;\r
+                               case OPERATOR.OPEN:\r
+                               result = result && ( end.val>val ? true : false );\r
+                               break;\r
+                       }\r
+                       return result;\r
+               }\r
+\r
+               public bool bounded()\r
+               {\r
+                       return begin.bounded() && end.bounded();\r
+               }\r
+\r
+               System.Collections.Generic.IEnumerable<double> step(double steps)\r
+               {\r
+                       if (steps > 0) throw new Exception("Interval: step must be a positive");\r
+                       //                      return new IntervalIEnumerable(this, steps);\r
+                       Interval it = this;\r
+                       long front_step = (it.begin.op == Interval.OPERATOR.CLOSE ? -1 : 0);\r
+                       long back_step = (long)System.Math.Floor((it.end.val - it.begin.val) / steps);\r
+                       if (it.end.op == Interval.OPERATOR.OPEN && 0 == System.Math.IEEERemainder(it.end.val - it.begin.val, steps))\r
+                       {\r
+                               back_step -= 1;\r
+                       }\r
+                       while (front_step <= back_step)\r
+                               yield return steps * front_step + it.begin.val;\r
+               }\r
+\r
+\r
+               #region accessor generation\r
+\r
+               public static IntervalAcc operator <(double val, Interval rng)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(val, OPERATOR.OPEN, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+               }\r
+               public static IntervalAcc operator <=(double val, Interval rng)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(val, OPERATOR.CLOSE, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+               }\r
+               public static IntervalAcc operator >(double val, Interval rng)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.OPEN) };\r
+               }\r
+               public static IntervalAcc operator >=(double val, Interval rng)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.CLOSE) };\r
+               }\r
+               public static IntervalAcc operator <(Interval rng, double val)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.OPEN) };\r
+               }\r
+               public static IntervalAcc operator <=(Interval rng, double val)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(Double.NegativeInfinity, OPERATOR.CLOSE, val, OPERATOR.CLOSE) };\r
+               }\r
+               public static IntervalAcc operator >(Interval rng, double val)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(val, OPERATOR.OPEN, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+               }\r
+               public static IntervalAcc operator >=(Interval rng, double val)\r
+               {\r
+                       return new IntervalAcc { instance = new Interval(val, OPERATOR.CLOSE, Double.PositiveInfinity, OPERATOR.CLOSE) };\r
+               }\r
+\r
+               #endregion\r
+\r
+       }\r
+\r
+       namespace Internal\r
+       {\r
+               #region accessor definition\r
+\r
+               public struct IntervalAcc\r
+               {\r
+                       public Interval instance;\r
+\r
+                       public static IntervalAcc operator <(double val, IntervalAcc rng)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };\r
+                       }\r
+                       public static IntervalAcc operator <=(double val, IntervalAcc rng)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };\r
+                       }\r
+                       public static IntervalAcc operator >(double val, IntervalAcc rng)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };\r
+                       }\r
+                       public static IntervalAcc operator >=(double val, IntervalAcc rng)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };\r
+                       }\r
+                       public static IntervalAcc operator <(IntervalAcc rng, double val)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };\r
+                       }\r
+                       public static IntervalAcc operator <=(IntervalAcc rng, double val)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };\r
+                       }\r
+                       public static IntervalAcc operator >(IntervalAcc rng, double val)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };\r
+                       }\r
+                       public static IntervalAcc operator >=(IntervalAcc rng, double val)\r
+                       {\r
+                               return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };\r
+                       }\r
+\r
+                       public static implicit operator Interval(IntervalAcc rhs)\r
+                       {\r
+                               return rhs.instance;\r
+                       }\r
+               }\r
+\r
+               #endregion\r
+\r
+       }\r
+\r
+\r
 }
\ No newline at end of file

diff --git a/dev3/psychlops/extention/standard/widget.cs b/dev3/psychlops/extention/standard/widget.cs
index d0a74c9..e68e396 100644 (file)
--- a/dev3/psychlops/extention/standard/widget.cs
+++ b/dev3/psychlops/extention/standard/widget.cs
@@ -18,6 +18,14 @@ namespace Psychlops
 \r
                class Slider\r
                {\r
+                       double val;\r
+                       public Slider()\r
+                       {\r
+                       }\r
+                       public static implicit operator double(Slider s)\r
+                       {\r
+                               return s.val;\r
+                       }\r
                }\r
 \r
 \r

diff --git a/test3/MainPage.xaml b/test3/MainPage.xaml
index b7dd27b..11b3532 100644 (file)
--- a/test3/MainPage.xaml
+++ b/test3/MainPage.xaml
@@ -13,6 +13,6 @@
                        </StackPanel>\r
                        <Canvas x:Name="LayoutRoot" Grid.Column="1"></Canvas>\r
                </Grid>\r
-               <TextBlock x:Name="AppStatusBar">Status OK</TextBlock>\r
+               <TextBlock x:Name="AppStatusBar" Height="20">Status OK</TextBlock>\r
        </StackPanel>\r
 </UserControl>\r

diff --git a/test3/MainPage.xaml.cs b/test3/MainPage.xaml.cs
index e1f3496..d0bcae8 100644 (file)
--- a/test3/MainPage.xaml.cs
+++ b/test3/MainPage.xaml.cs
@@ -36,6 +36,7 @@ namespace PsychlopsSilverlight3test
 \r
                        Psychlops.Internal.Main.statusBar = AppStatusBar;\r
                        Psychlops.Internal.Main.widgetStack = Controller;\r
+                       AppStatusBar.Text = System.Windows.Application.Current.Host.Settings.EnableGPUAcceleration.ToString();\r
                }\r
                protected void getFocusMouseEnter(object sender, System.Windows.Input.MouseEventArgs e) {\r
                        this.Focus();\r

diff --git a/test3/PsychlopsMain.cs b/test3/PsychlopsMain.cs
index 1991b9d..bef253a 100644 (file)
--- a/test3/PsychlopsMain.cs
+++ b/test3/PsychlopsMain.cs
@@ -41,7 +41,7 @@ namespace PsychlopsSilverlight3test
 \r
                                //Figures.drawGabor(ref img, 20, 100, 1, 0, frames * 2.0 * Math.PI / tfreq / 60);\r
                                //Figures.drawGaussian(ref img, 20, 1);\r
-                               Figures.drawGrating(ref img, 100, 100, 20, 1, 2, frames * 2.0 * Math.PI / tfreq / 60);\r
+                               Figures.drawGrating(ref img, 300, 300, 20, 1, 2, frames * 2.0 * Math.PI / tfreq / 60);\r
                                img.centering(Mouse.position);\r
                                img.draw();\r
 \r
@@ -53,7 +53,6 @@ namespace PsychlopsSilverlight3test
 \r
                                fixation.shift(100,100);\r
                                fixation.draw(new Stroke(Color.blue, 3));\r
-                               AppState.statusBar = "dhdyr";\r
 \r
                                cnvs.flip();\r
                        }\r