From: HOSOKAWA Kenchi <hskwk@inter7.jp>
Date: Tue, 24 Aug 2010 04:23:12 +0000 (+0900)
Subject: Merge branch 'master' of git.sourceforge.jp:/gitroot/psychlops/silverlight
X-Git-Url: http://git.osdn.jp/view?a=commitdiff_plain;h=9f47dcd91507b95984913358b5b313f1e304a091;hp=f363b7287669ba8b29a2a8ef1fd87ab8ca703d21;p=psychlops%2Fsilverlight.git

Merge branch 'master' of git.sourceforge.jp:/gitroot/psychlops/silverlight
---

diff --git a/dev4/Pages/BinomialSolver.xaml b/dev4/Pages/BinomialSolver.xaml
new file mode 100644
index 0000000..e08c197
--- /dev/null
+++ b/dev4/Pages/BinomialSolver.xaml
@@ -0,0 +1,115 @@
+<controls:ChildWindow x:Class="PsychlopsSilverlight4.Pages.BinomialSolver"
+           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
+           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
+           xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk"
+           xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
+           Width="400" Height="300" 
+           Title="Binomial Likelihood Solver" xmlns:toolkit="http://schemas.microsoft.com/winfx/2006/xaml/presentation/toolkit">
+
+
+	<controls:ChildWindow.Resources>
+		<Style TargetType="toolkit:Chart">
+			<!-- To Remove Legend-->
+			<Setter Property="Padding" Value="10 0" />
+			<Setter Property="BorderBrush" Value="Transparent" />
+			<Setter Property="PlotAreaStyle">
+				<Setter.Value>
+					<Style TargetType="Grid">
+						<Setter Property="Margin" Value="0"/>
+					</Style>
+				</Setter.Value>
+			</Setter>
+			<Setter Property="TitleStyle">
+				<Setter.Value>
+					<Style TargetType="toolkit:Title">
+						<Setter Property="Width" Value="0"/>
+						<Setter Property="Height" Value="0"/>
+					</Style>
+				</Setter.Value>
+			</Setter>
+			<Setter Property="LegendStyle">
+				<Setter.Value>
+					<Style TargetType="toolkit:Legend">
+						<Setter Property="Width" Value="0"/>
+						<Setter Property="Height" Value="0"/>
+					</Style>
+				</Setter.Value>
+			</Setter>
+		</Style>
+		<Style TargetType="toolkit:LineSeries">
+		</Style>		
+	</controls:ChildWindow.Resources>
+
+	<Grid x:Name="LayoutRoot" Margin="2">
+        <Grid.RowDefinitions>
+            <RowDefinition />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+		<StackPanel Orientation="Horizontal">
+			<Canvas Width="250" Height="Auto">
+				<toolkit:Chart x:Name="chart1" Title="" Width="240" Height="220" Canvas.Left="0" Canvas.Top="0"
+							   FontSize="10">
+					<toolkit:Chart.Series>
+						<toolkit:LineSeries x:Name="Fitted"
+										Title="Fitted"
+										ItemsSource="{Binding}"
+										IndependentValueBinding="{Binding c_abscissa}"
+										DependentValueBinding="{Binding c_ratio}"
+										>
+							<toolkit:LineSeries.DataPointStyle>
+								<Style TargetType="Control">
+									<Setter Property="Template" Value="{x:Null}"/>
+								</Style>
+							</toolkit:LineSeries.DataPointStyle>
+
+							<toolkit:LineSeries.DependentRangeAxis>
+								<toolkit:LinearAxis Title="" ShowGridLines="False" Orientation="Y" Minimum="0" Maximum="1">
+								</toolkit:LinearAxis>
+							</toolkit:LineSeries.DependentRangeAxis>
+						</toolkit:LineSeries>
+						<toolkit:ScatterSeries x:Name="Raw"
+										Title="Fitted"
+										ItemsSource="{Binding}"
+										IndependentValueBinding="{Binding abscissa}"
+										DependentValueBinding="{Binding ratio}"
+										>
+							<!--
+						<toolkit:ScatterSeries.IndependentAxis>
+							<toolkit:LinearAxis Title="" Orientation="X" Maximum="10" Minimum="0">
+							</toolkit:LinearAxis>
+						</toolkit:ScatterSeries.IndependentAxis>
+						-->
+
+							<toolkit:ScatterSeries.DependentRangeAxis>
+								<toolkit:LinearAxis Title="" ShowGridLines="False" Orientation="Y" Minimum="0" Maximum="1">
+								</toolkit:LinearAxis>
+							</toolkit:ScatterSeries.DependentRangeAxis>
+						</toolkit:ScatterSeries>
+					</toolkit:Chart.Series>
+				</toolkit:Chart>
+				<Slider x:Name="OrdinateSlider" Canvas.Left="0" Canvas.Top="10" Orientation="Vertical"  Height="200"></Slider>
+				<Slider x:Name="AbscissaSlider" Canvas.Left="20" Canvas.Top="210" Width="200" MouseLeftButtonUp="AbscissaSlider_MouseLeftButtonUp"></Slider>
+			</Canvas>
+
+
+			<StackPanel Orientation="Vertical">
+				<sdk:DataGrid x:Name="dataGrid" Margin="0,5,0,10" RowHeight="40" AutoGenerateColumns="False" >
+					<sdk:DataGrid.Columns>
+						<sdk:DataGridTextColumn Header="Abscissa" Width="40" Binding="{Binding abscissa}" />
+						<sdk:DataGridTextColumn Header="Positive Cases" Width="40"  Binding="{Binding positive}" />
+						<sdk:DataGridTextColumn Header="Negative Cases" Width="40" Binding="{Binding negative}" />
+					</sdk:DataGrid.Columns>
+				</sdk:DataGrid>
+				<Button x:Name="AddConditionButton" Content="Add Condition" Click="AddConditionButton_Click" HorizontalAlignment="Right" FontSize="10" Margin="0,12,0,0" Grid.Row="1" />
+			</StackPanel>
+		</StackPanel>
+
+		<TextBlock Text="Mean" x:Name="Parameter0Name" Width="40" Height="23" HorizontalAlignment="Left" Margin="0,12,0,0" Grid.Row="1" />
+		<TextBox x:Name="Parameter0" IsReadOnly="True" Width="50" Height="23" HorizontalAlignment="Left" Margin="40,12,0,0" Grid.Row="1" />
+		<TextBlock Text="S.D." x:Name="Parameter1Name" Width="40" Height="23" HorizontalAlignment="Left" Margin="110,12,0,0" Grid.Row="1" />
+		<TextBox x:Name="Parameter1" IsReadOnly="True" Width="50" Height="23" HorizontalAlignment="Left" Margin="150,12,0,0" Grid.Row="1" />
+		<Button x:Name="CalcButton" Content="Calculate" Click="CalcButton_Click" Width="75" Height="23" HorizontalAlignment="Right" Margin="0,12,79,0" Grid.Row="1" />
+        <Button x:Name="OKButton" Content="OK" Click="OKButton_Click" Width="75" Height="23" HorizontalAlignment="Right" Margin="0,12,0,0" Grid.Row="1" />
+    </Grid>
+</controls:ChildWindow>
\ No newline at end of file
diff --git a/dev4/Pages/BinomialSolver.xaml.cs b/dev4/Pages/BinomialSolver.xaml.cs
new file mode 100644
index 0000000..84c26e8
--- /dev/null
+++ b/dev4/Pages/BinomialSolver.xaml.cs
@@ -0,0 +1,215 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+
+namespace PsychlopsSilverlight4.Pages
+{
+	public partial class BinomialSolver : ChildWindow
+	{
+		int func_selected;
+		Psychlops.Solver.Constants.Func1 func1;
+		Psychlops.Solver.Constants.Func2 func2;
+		Psychlops.Solver.Constants.Func3 func3;
+
+
+		public ObservableCollection<Data> data = new ObservableCollection<Data>();
+		public ObservableCollection<Data> fitted = new ObservableCollection<Data>();
+		public ObservableCollection<Data> data_ { get { return data; } }
+		public ObservableCollection<Data> fitted_ { get { return fitted; } }
+
+
+		public BinomialSolver(Psychlops.Solver.Constants.Func1 f)
+		{
+			InitializeComponent();
+			initialize();
+			func_selected = 1;
+			func1 = f;
+		}
+		public BinomialSolver(Psychlops.Solver.Constants.Func2 f)
+		{
+			InitializeComponent();
+			initialize();
+			func_selected = 2;
+			func2 = f;
+		}
+		public BinomialSolver(Psychlops.Solver.Constants.Func3 f)
+		{
+			InitializeComponent();
+			initialize();
+			func_selected = 3;
+			func3 = f;
+		}
+		public void initialize()
+		{
+			dataGrid.RowHeight = 20;
+			data = Data.GetDataList();
+			dataGrid.ItemsSource = data;
+
+			chart1.DataContext = data;
+			solver = new Psychlops.Solver.BinomialLikelihood();
+		}
+		public class Data
+		{
+			public double c_abscissa { get; set; }
+			public double c_ratio { get; set; }
+			public double abscissa { get; set; }
+			public int positive { get; set; }
+			public int negative { get; set; }
+			public double ratio { get { return (double)(positive) / (positive+negative); } }
+
+
+			public Data(double absc, int posi, int nega)
+			{
+				this.abscissa = absc;
+				this.positive = posi;
+				this.negative = nega;
+				c_abscissa = 0.0;
+				c_ratio = 0.0;
+			}
+
+			public static ObservableCollection<Data> GetDataList()
+			{
+				return new ObservableCollection<Data>(new Data[] {
+					new Data(-5, 0, 10),
+					new Data(0, 1, 9),
+					new Data(1, 3, 7),
+					new Data(2, 5, 5),
+					new Data(3, 7, 3),               
+					new Data(5, 9, 1),                
+					new Data(10, 10, 0)                
+				});
+			}
+		}
+
+		private void OKButton_Click(object sender, RoutedEventArgs e)
+		{
+			this.DialogResult = true;
+		}
+
+		double minimum, maximum;
+		Psychlops.Solver.BinomialLikelihood solver;
+		private void CalcButton_Click(object sender, RoutedEventArgs e)
+		{
+			var ber = new Psychlops.Solver.BernoulliProcess();
+			ber.elems = new Psychlops.Solver.BernoulliProcess.Data[data.Count];
+			int i = 0;
+
+			minimum = Double.PositiveInfinity;
+			maximum = Double.NegativeInfinity;
+			foreach (var d in data)
+			{
+				if (d.abscissa < minimum) { minimum = d.abscissa; }
+				if (d.abscissa > maximum) { maximum = d.abscissa; }
+				ber.elems[i].x = d.abscissa;
+				ber.elems[i].pos = d.positive;
+				ber.elems[i].neg = d.negative;
+				i++;
+			}
+
+			solver.data = ber;
+
+
+			Psychlops.Interval itvl = new Psychlops.Interval();
+			solver.itvl[0] = (-100 <= itvl <= 100);
+			solver.itvl[1] = (-100 <= itvl <= 100);
+			solver.itvl[2] = (-100 <= itvl <= 100);
+
+			switch (func_selected)
+			{
+				case 1:
+					solver.begin(func1);
+					break;
+				case 2:
+					solver.begin(func2);
+					break;
+				case 3:
+					solver.begin(func3);
+					break;
+			}
+
+			reFunc();
+		}
+		private void reFunc()
+		{
+			Data dd;
+			fitted = new ObservableCollection<Data>();
+			foreach (var d in data)
+			{
+				dd = new Data(d.abscissa, d.positive, d.negative);
+				dd.c_abscissa = minimum;
+				dd.c_ratio = 0.0;
+				fitted.Add(dd);
+			}
+			switch (func_selected)
+			{
+				case 1:
+					for (double j = minimum; j < maximum; j += (maximum - minimum)/ 100 )
+					{
+						dd = new Data(0, 0, 0);
+						dd.c_abscissa = j;
+						dd.c_ratio = func1(j, solver.champ[0]);
+						fitted.Add(dd);
+					}
+					break;
+				case 2:
+					for (double j = minimum; j < maximum; j += (maximum - minimum)/ 100 )
+					{
+						dd = new Data(0, 0, 0);
+						dd.c_abscissa = j;
+						dd.c_ratio = func2(j, solver.champ[0], solver.champ[1]);
+						fitted.Add(dd);
+					}
+					break;
+				case 3:
+					for (double j = minimum; j < maximum; j += (maximum - minimum)/ 100 )
+					{
+						dd = new Data(0, 0, 0);
+						dd.c_abscissa = j;
+						dd.c_ratio = func3(j, solver.champ[0], solver.champ[1], solver.champ[2]);
+						fitted.Add(dd);
+					}
+					break;
+			}
+
+
+			chart1.DataContext = null;
+			chart1.DataContext = fitted;
+
+			OrdinateSlider.Maximum = 1.0;
+			OrdinateSlider.Minimum = 0.0;
+			OrdinateSlider.Value = 0.5;
+
+			AbscissaSlider.Maximum = maximum;
+			AbscissaSlider.Minimum = minimum;
+			AbscissaSlider.Value = solver.champ[0];
+
+			Parameter0.Text = String.Format("{0:D4}", solver.champ[0].ToString());
+			Parameter1.Text = String.Format("{0, 4:F}", solver.champ[1].ToString());
+
+			//chart1.UpdateLayout();
+		}
+
+		private void AddConditionButton_Click(object sender, RoutedEventArgs e)
+		{
+			data.Add(new Data(0, 0, 0));
+			this.UpdateLayout();
+		}
+
+		private void AbscissaSlider_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
+		{
+			solver.champ[0] = AbscissaSlider.Value;
+			reFunc();
+		}
+
+	}
+}
+
diff --git a/dev4/PsychlopsSilverlight4.csproj b/dev4/PsychlopsSilverlight4.csproj
index 481803c..62b4e86 100644
--- a/dev4/PsychlopsSilverlight4.csproj
+++ b/dev4/PsychlopsSilverlight4.csproj
@@ -53,7 +53,10 @@
     <Reference Include="mscorlib" />
     <Reference Include="system" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Windows.Controls, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
     <Reference Include="System.Windows.Controls.Data, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
+    <Reference Include="System.Windows.Controls.DataVisualization.Toolkit, Version=4.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
+    <Reference Include="System.Windows.Controls.Toolkit, Version=4.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Net" />
     <Reference Include="System.Windows.Browser" />
@@ -63,6 +66,9 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Pages\BinomialSolver.xaml.cs">
+      <DependentUpon>BinomialSolver.xaml</DependentUpon>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="psychlops\core\app\app.cs" />
     <Compile Include="psychlops\core\app\misc.cs" />
@@ -75,6 +81,7 @@
     <Compile Include="psychlops\core\math\interval.cs" />
     <Compile Include="psychlops\core\math\matrix.cs" />
     <Compile Include="psychlops\core\math\util.cs" />
+    <Compile Include="psychlops\extention\compatibility\compatibility.cs" />
     <Compile Include="psychlops\extention\experiments\experiments.cs" />
     <Compile Include="psychlops\extention\math\BigFloat.cs" />
     <Compile Include="psychlops\extention\math\BigInt.cs" />
@@ -86,6 +93,12 @@
     <Compile Include="psychlops\psychlops.cs" />
     <Compile Include="psychlops\core\graphic\shape.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <Page Include="Pages\BinomialSolver.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </Page>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Silverlight\$(SilverlightVersion)\Microsoft.Silverlight.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/dev4/WriteableBitmapEx/Readme.txt b/dev4/WriteableBitmapEx/Readme.txt
index d271870..9165bc1 100644
--- a/dev4/WriteableBitmapEx/Readme.txt
+++ b/dev4/WriteableBitmapEx/Readme.txt
@@ -1,8 +1,8 @@
 Description
 °°°°°°°°°°°
 
-The WriteableBitmapEx library is a collection of extension methods for Silverlight's WriteableBitmap. The WriteableBitmap class was added in Silverlight 3. It allows the direct manipulation of a bitmap and could be used to generate fast procedural images by drawing directly to a bitmap. The WriteableBitmap API is very minimalistic and there's only the raw Pixels array for such operations. The WriteableBitmapEx library tries to compensate that with extensions methods that are easy to use like built in methods. The library extends the WriteableBitmap class with elementary (2D drawing) functionality, supporting common shapes like point, line, ellipse, polyline, quad, rectangle, triangle, cubic Beziér and Cardinal spline. Conversion methods and functions to combine WriteableBitmaps (Blitting) are part of it too. 
-It is possible to use the built assembly that contains all extension methods or just specific methods by using the source CS files directly. The extension methods are grouped into multiple CS files.
+The WriteableBitmapEx library is a collection of extension methods for Silverlight's WriteableBitmap. The WriteableBitmap class that was added in Silverlight 3, allows the direct manipulation of a bitmap and could be used to generate fast procedural images by drawing directly to a bitmap. The WriteableBitmap API is very minimalistic and there's only the raw Pixels array for such operations. The WriteableBitmapEx library tries to compensate that with extensions methods that are easy to use like built in methods and offer GDI+ like functionality. The library extends the WriteableBitmap class with elementary and fast (2D drawing) functionality, conversion methods and functions to combine (blit) WriteableBitmaps. 
+The extension methods are grouped into different CS files with a partial class. It is possible to include just a few methods by using the specific source CS files directly or all extension methods through the built library assembly.
 
 See http://writeablebitmapex.codeplex.com
 
diff --git a/dev4/WriteableBitmapEx/WriteableBitmapEx.XML b/dev4/WriteableBitmapEx/WriteableBitmapEx.XML
index 5d8eaeb..a307dd7 100644
--- a/dev4/WriteableBitmapEx/WriteableBitmapEx.XML
+++ b/dev4/WriteableBitmapEx/WriteableBitmapEx.XML
@@ -6,9 +6,6 @@
     <members>
         <member name="T:System.Windows.Media.Imaging.WriteableBitmapExtensions">
             <summary>
-            Collection of blit (copy) extension methods for the Silverlight WriteableBitmap class.
-            </summary>
-            <summary>
             Collection of interchange extension methods for the Silverlight WriteableBitmap class.
             </summary>
             <summary>
@@ -18,49 +15,17 @@
             Collection of draw extension methods for the Silverlight WriteableBitmap class.
             </summary>
             <summary>
-            Collection of draw spline extension methods for the Silverlight WriteableBitmap class.
+            Collection of blit (copy) extension methods for the Silverlight WriteableBitmap class.
             </summary>
-        </member>
-        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
             <summary>
-            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            Collection of draw extension methods for the Silverlight WriteableBitmap class.
             </summary>
-            <param name="bmp">The destination WriteableBitmap.</param>
-            <param name="destRect">The rectangle that defines the destination region.</param>
-            <param name="source">The source WriteableBitmap.</param>
-            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
-            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
-        </member>
-        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect)">
             <summary>
-            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            Collection of draw spline extension methods for the Silverlight WriteableBitmap class.
             </summary>
-            <param name="bmp">The destination WriteableBitmap.</param>
-            <param name="destRect">The rectangle that defines the destination region.</param>
-            <param name="source">The source WriteableBitmap.</param>
-            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
-        </member>
-        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Point,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Color,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
             <summary>
-            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            Collection of transformation extension methods for the Silverlight WriteableBitmap class.
             </summary>
-            <param name="bmp">The destination WriteableBitmap.</param>
-            <param name="destPosition">The destination position in the destination bitmap.</param>
-            <param name="source">The source WriteableBitmap.</param>
-            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
-            <param name="color">If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent.</param>
-            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
-        </member>
-        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Color,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
-            <summary>
-            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
-            </summary>
-            <param name="bmp">The destination WriteableBitmap.</param>
-            <param name="destRect">The rectangle that defines the destination region.</param>
-            <param name="source">The source WriteableBitmap.</param>
-            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
-            <param name="color">If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent.</param>
-            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.ToByteArray(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32)">
             <summary>
@@ -88,27 +53,30 @@
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FromByteArray(System.Windows.Media.Imaging.WriteableBitmap,System.Byte[],System.Int32,System.Int32)">
             <summary>
-            Copies color information from an ARGB byte array into the WriteableBitmap starting at a specific buffer index.
+            Copies color information from an ARGB byte array into this WriteableBitmap starting at a specific buffer index.
             </summary>
             <param name="bmp">The WriteableBitmap.</param>
             <param name="offset">The starting index in the buffer.</param>
             <param name="count">The number of bytes to copy from the buffer.</param>
             <param name="buffer">The color buffer as byte ARGB values.</param>
+            <returns>The WriteableBitmap that was passed as parameter.</returns>
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FromByteArray(System.Windows.Media.Imaging.WriteableBitmap,System.Byte[],System.Int32)">
             <summary>
-            Copies color information from an ARGB byte array into the WriteableBitmap.
+            Copies color information from an ARGB byte array into this WriteableBitmap.
             </summary>
             <param name="bmp">The WriteableBitmap.</param>
             <param name="count">The number of bytes to copy from the buffer.</param>
             <param name="buffer">The color buffer as byte ARGB values.</param>
+            <returns>The WriteableBitmap that was passed as parameter.</returns>
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FromByteArray(System.Windows.Media.Imaging.WriteableBitmap,System.Byte[])">
             <summary>
-            Copies all the color information from an ARGB byte array into the WriteableBitmap.
+            Copies all the color information from an ARGB byte array into this WriteableBitmap.
             </summary>
             <param name="bmp">The WriteableBitmap.</param>
             <param name="buffer">The color buffer as byte ARGB values.</param>
+            <returns>The WriteableBitmap that was passed as parameter.</returns>
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.WriteTga(System.Windows.Media.Imaging.WriteableBitmap,System.IO.Stream)">
             <summary>
@@ -118,6 +86,14 @@
             <param name="bmp">The WriteableBitmap.</param>
             <param name="destination">The destination stream.</param>
         </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FromResource(System.Windows.Media.Imaging.WriteableBitmap,System.String)">
+            <summary>
+            Loads an image from the applications resource file and fills this WriteableBitmap with it.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="relativePath">Only the relative path to the resource file. The assembly name is retrieved automatically.</param>
+            <returns>The WriteableBitmap that was passed as parameter.</returns>
+        </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawLineBresenham(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
             <summary>
             Draws a colored line by connecting two points using the Bresenham algorithm.
@@ -378,6 +354,24 @@
             <param name="bmp">The WriteableBitmap.</param>
             <param name="func">The function to apply. With parameters x, y, source color and a color as a result</param>
         </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.GetPixeli(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32)">
+            <summary>
+            Gets the color of the pixel at the x, y coordinate as integer.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x">The x coordinate of the pixel.</param>
+            <param name="y">The y coordinate of the pixel.</param>
+            <returns>The color of the pixel at x, y.</returns>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.GetPixel(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32)">
+            <summary>
+            Gets the color of the pixel at the x, y coordinate as a Color struct.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x">The x coordinate of the pixel.</param>
+            <param name="y">The y coordinate of the pixel.</param>
+            <returns>The color of the pixel at x, y as a Color struct.</returns>
+        </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.SetPixeli(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Byte,System.Byte,System.Byte)">
             <summary>
             Sets the color of the pixel using a precalculated index (faster).
@@ -475,6 +469,286 @@
             <param name="y">The y coordinate (column).</param>
             <param name="color">The color.</param>
         </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
+            <summary>
+            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            </summary>
+            <param name="bmp">The destination WriteableBitmap.</param>
+            <param name="destRect">The rectangle that defines the destination region.</param>
+            <param name="source">The source WriteableBitmap.</param>
+            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
+            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect)">
+            <summary>
+            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            </summary>
+            <param name="bmp">The destination WriteableBitmap.</param>
+            <param name="destRect">The rectangle that defines the destination region.</param>
+            <param name="source">The source WriteableBitmap.</param>
+            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Point,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Color,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
+            <summary>
+            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            </summary>
+            <param name="bmp">The destination WriteableBitmap.</param>
+            <param name="destPosition">The destination position in the destination bitmap.</param>
+            <param name="source">The source WriteableBitmap.</param>
+            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
+            <param name="color">If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent.</param>
+            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Blit(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect,System.Windows.Media.Color,System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode)">
+            <summary>
+            Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).
+            </summary>
+            <param name="bmp">The destination WriteableBitmap.</param>
+            <param name="destRect">The rectangle that defines the destination region.</param>
+            <param name="source">The source WriteableBitmap.</param>
+            <param name="sourceRect">The rectangle that will be copied from the source to the destination.</param>
+            <param name="color">If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent.</param>
+            <param name="BlendMode">The blending mode <see cref="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode"/>.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillRectangle(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
+            <summary>
+            Draws a filled rectangle.
+            x2 has to be greater than x1 and y2 has to be greater than y1.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the bounding rectangle's left side.</param>
+            <param name="y1">The y-coordinate of the bounding rectangle's top side.</param>
+            <param name="x2">The x-coordinate of the bounding rectangle's right side.</param>
+            <param name="y2">The y-coordinate of the bounding rectangle's bottom side.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillRectangle(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Draws a filled rectangle.
+            x2 has to be greater than x1 and y2 has to be greater than y1.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the bounding rectangle's left side.</param>
+            <param name="y1">The y-coordinate of the bounding rectangle's top side.</param>
+            <param name="x2">The x-coordinate of the bounding rectangle's right side.</param>
+            <param name="y2">The y-coordinate of the bounding rectangle's bottom side.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillEllipse(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
+            <summary>
+            A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf 
+            x2 has to be greater than x1 and y2 has to be greater than y1.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the bounding rectangle's left side.</param>
+            <param name="y1">The y-coordinate of the bounding rectangle's top side.</param>
+            <param name="x2">The x-coordinate of the bounding rectangle's right side.</param>
+            <param name="y2">The y-coordinate of the bounding rectangle's bottom side.</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillEllipse(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf 
+            x2 has to be greater than x1 and y2 has to be greater than y1.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the bounding rectangle's left side.</param>
+            <param name="y1">The y-coordinate of the bounding rectangle's top side.</param>
+            <param name="x2">The x-coordinate of the bounding rectangle's right side.</param>
+            <param name="y2">The y-coordinate of the bounding rectangle's bottom side.</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillEllipseCentered(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
+            <summary>
+            A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf 
+            Uses a different parameter representation than DrawEllipse().
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="xc">The x-coordinate of the ellipses center.</param>
+            <param name="yc">The y-coordinate of the ellipses center.</param>
+            <param name="xr">The radius of the ellipse in x-direction.</param>
+            <param name="yr">The radius of the ellipse in y-direction.</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillEllipseCentered(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf 
+            Uses a different parameter representation than DrawEllipse().
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="xc">The x-coordinate of the ellipses center.</param>
+            <param name="yc">The y-coordinate of the ellipses center.</param>
+            <param name="xr">The radius of the ellipse in x-direction.</param>
+            <param name="yr">The radius of the ellipse in y-direction.</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillPolygon(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Windows.Media.Color)">
+            <summary>
+            Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn).</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillPolygon(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Int32)">
+            <summary>
+            Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn).</param>
+            <param name="color">The color for the line.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillQuad(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
+            <summary>
+            Draws a filled quad.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the 1st point.</param>
+            <param name="y1">The y-coordinate of the 1st point.</param>
+            <param name="x2">The x-coordinate of the 2nd point.</param>
+            <param name="y2">The y-coordinate of the 2nd point.</param>
+            <param name="x3">The x-coordinate of the 3rd point.</param>
+            <param name="y3">The y-coordinate of the 3rd point.</param>
+            <param name="x4">The x-coordinate of the 4th point.</param>
+            <param name="y4">The y-coordinate of the 4th point.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillQuad(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Draws a filled quad.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the 1st point.</param>
+            <param name="y1">The y-coordinate of the 1st point.</param>
+            <param name="x2">The x-coordinate of the 2nd point.</param>
+            <param name="y2">The y-coordinate of the 2nd point.</param>
+            <param name="x3">The x-coordinate of the 3rd point.</param>
+            <param name="y3">The y-coordinate of the 3rd point.</param>
+            <param name="x4">The x-coordinate of the 4th point.</param>
+            <param name="y4">The y-coordinate of the 4th point.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillTriangle(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
+            <summary>
+            Draws a filled triangle.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the 1st point.</param>
+            <param name="y1">The y-coordinate of the 1st point.</param>
+            <param name="x2">The x-coordinate of the 2nd point.</param>
+            <param name="y2">The y-coordinate of the 2nd point.</param>
+            <param name="x3">The x-coordinate of the 3rd point.</param>
+            <param name="y3">The y-coordinate of the 3rd point.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillTriangle(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Draws a filled triangle.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x1">The x-coordinate of the 1st point.</param>
+            <param name="y1">The y-coordinate of the 1st point.</param>
+            <param name="x2">The x-coordinate of the 2nd point.</param>
+            <param name="y2">The y-coordinate of the 2nd point.</param>
+            <param name="x3">The x-coordinate of the 3rd point.</param>
+            <param name="y3">The y-coordinate of the 3rd point.</param>
+            <param name="color">The color.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.ComputeBezierPoints(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32[],System.Int32,System.Int32)">
+            <summary>
+            Draws a filled, cubic Beziér spline defined by start, end and two control points.
+            </summary>
+            <param name="x1">The x-coordinate of the start point.</param>
+            <param name="y1">The y-coordinate of the start point.</param>
+            <param name="cx1">The x-coordinate of the 1st control point.</param>
+            <param name="cy1">The y-coordinate of the 1st control point.</param>
+            <param name="cx2">The x-coordinate of the 2nd control point.</param>
+            <param name="cy2">The y-coordinate of the 2nd control point.</param>
+            <param name="x2">The x-coordinate of the end point.</param>
+            <param name="y2">The y-coordinate of the end point.</param>
+            <param name="color">The color.</param>
+            <param name="pixels">The pixels array.</param>
+            <param name="w">The width of the bitmap.</param>
+            <param name="h">The height of the bitmap.</param> 
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillBeziers(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Windows.Media.Color)">
+            <summary>
+            Draws a series of filled, cubic Beziér splines each defined by start, end and two control points. 
+            The ending point of the previous curve is used as starting point for the next. 
+            Therfore the inital curve needs four points and the subsequent 3 (2 control and 1 end point).
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, cx1, cy1, cx2, cy2, x2, y2, cx3, cx4 ..., xn, yn).</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillBeziers(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Int32)">
+            <summary>
+            Draws a series of filled, cubic Beziér splines each defined by start, end and two control points. 
+            The ending point of the previous curve is used as starting point for the next. 
+            Therfore the inital curve needs four points and the subsequent 3 (2 control and 1 end point).
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, cx1, cy1, cx2, cy2, x2, y2, cx3, cx4 ..., xn, yn).</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.ComputeSegmentPoints(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Single,System.Int32,System.Int32[],System.Int32,System.Int32)">
+            <summary>
+            Computes the discrete segment points of a Cardinal spline (cubic) defined by four control points.
+            </summary>
+            <param name="x1">The x-coordinate of the 1st control point.</param>
+            <param name="y1">The y-coordinate of the 1st control point.</param>
+            <param name="x2">The x-coordinate of the 2nd control point.</param>
+            <param name="y2">The y-coordinate of the 2nd control point.</param>
+            <param name="x3">The x-coordinate of the 3rd control point.</param>
+            <param name="y3">The y-coordinate of the 3rd control point.</param>
+            <param name="x4">The x-coordinate of the 4th control point.</param>
+            <param name="y4">The y-coordinate of the 4th control point.</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color.</param>
+            <param name="pixels">The pixels array.</param>
+            <param name="w">The width of the bitmap.</param>
+            <param name="h">The height of the bitmap.</param> 
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillCurve(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Windows.Media.Color)">
+            <summary>
+            Draws a filled Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillCurve(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Int32)">
+            <summary>
+            Draws a filled Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillCurveClosed(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Windows.Media.Color)">
+            <summary>
+            Draws a filled, closed Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.FillCurveClosed(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Int32)">
+            <summary>
+            Draws a filled, closed Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawBezier(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Windows.Media.Color)">
             <summary>
             Draws a cubic Beziér spline defined by start, end and two control points.
@@ -525,11 +799,10 @@
             <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, cx1, cy1, cx2, cy2, x2, y2, cx3, cx4 ..., xn, yn).</param>
             <param name="color">The color for the spline.</param>
         </member>
-        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawCurve(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Single,System.Int32)">
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawCurveSegment(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Single,System.Int32,System.Int32[],System.Int32,System.Int32)">
             <summary>
-            Draws a Cardinal spline (cubic) defined by four control points.
+            Draws a segment of a Cardinal spline (cubic) defined by four control points.
             </summary>
-            <param name="bmp">The WriteableBitmap.</param>
             <param name="x1">The x-coordinate of the 1st control point.</param>
             <param name="y1">The y-coordinate of the 1st control point.</param>
             <param name="x2">The x-coordinate of the 2nd control point.</param>
@@ -540,6 +813,9 @@
             <param name="y4">The y-coordinate of the 4th control point.</param>
             <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
             <param name="color">The color.</param>
+            <param name="pixels">The pixels array.</param>
+            <param name="w">The width of the bitmap.</param>
+            <param name="h">The height of the bitmap.</param> 
         </member>
         <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawCurve(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Windows.Media.Color)">
             <summary>
@@ -561,12 +837,61 @@
             <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
             <param name="color">The color for the spline.</param>
         </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawCurveClosed(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Windows.Media.Color)">
+            <summary>
+            Draws a closed Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.DrawCurveClosed(System.Windows.Media.Imaging.WriteableBitmap,System.Int32[],System.Single,System.Int32)">
+            <summary>
+            Draws a closed Cardinal spline (cubic) defined by a point collection. 
+            The cardinal spline passes through each point in the collection.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="points">The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn).</param>
+            <param name="tension">The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line.</param>
+            <param name="color">The color for the spline.</param>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Crop(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Creates a new cropped WriteableBitmap.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="x">The x coordinate of the rectangle that defines the crop region.</param>
+            <param name="y">The y coordinate of the rectangle that defines the crop region.</param>
+            <param name="width">The width of the rectangle that defines the crop region.</param>
+            <param name="height">The height of the rectangle that defines the crop region.</param>
+            <returns>A new WriteableBitmap that is a cropped version of the input.</returns>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Crop(System.Windows.Media.Imaging.WriteableBitmap,System.Windows.Rect)">
+            <summary>
+            Creates a new cropped WriteableBitmap.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="region">The rectangle that defines the crop region.</param>
+            <returns>A new WriteableBitmap that is a cropped version of the input.</returns>
+        </member>
+        <member name="M:System.Windows.Media.Imaging.WriteableBitmapExtensions.Resize(System.Windows.Media.Imaging.WriteableBitmap,System.Int32,System.Int32,System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation)">
+            <summary>
+            Creates a new resized WriteableBitmap.
+            </summary>
+            <param name="bmp">The WriteableBitmap.</param>
+            <param name="width">The new desired width.</param>
+            <param name="height">The new desired height.</param>
+            <param name="interpolation">The interpolation method that should be used.</param>
+            <returns>A new WriteableBitmap that is a resized version of the input.</returns>
+        </member>
         <member name="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode">
             <summary>
             The blending mode.
             </summary>
         </member>
-        <member name="F:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode.AlphaBlend">
+        <member name="F:System.Windows.Media.Imaging.WriteableBitmapExtensions.BlendMode.Alpha">
             <summary>
             Alpha blendiing uses the alpha channel to combine the source and destination. 
             </summary>
@@ -596,5 +921,20 @@
             No blending just copies the pixels from the source.
             </summary>
         </member>
+        <member name="T:System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation">
+            <summary>
+            The interpolation method.
+            </summary>
+        </member>
+        <member name="F:System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation.NearestNeighbor">
+            <summary>
+            The nearest neighbor algorithm simply selects the color of the nearest pixel.
+            </summary>
+        </member>
+        <member name="F:System.Windows.Media.Imaging.WriteableBitmapExtensions.Interpolation.Bilinear">
+            <summary>
+            Linear interpolation in 2D using the average of 3 neighboring pixels.
+            </summary>
+        </member>
     </members>
 </doc>
diff --git a/dev4/WriteableBitmapEx/WriteableBitmapEx.dll b/dev4/WriteableBitmapEx/WriteableBitmapEx.dll
index 498272f..72956f0 100644
Binary files a/dev4/WriteableBitmapEx/WriteableBitmapEx.dll and b/dev4/WriteableBitmapEx/WriteableBitmapEx.dll differ
diff --git a/dev4/WriteableBitmapEx/WriteableBitmapEx.pdb b/dev4/WriteableBitmapEx/WriteableBitmapEx.pdb
index 8ab76d3..cc55600 100644
Binary files a/dev4/WriteableBitmapEx/WriteableBitmapEx.pdb and b/dev4/WriteableBitmapEx/WriteableBitmapEx.pdb differ
diff --git a/dev4/psychlops/core/device/clock.cs b/dev4/psychlops/core/device/clock.cs
index bc52821..f4a3ebf 100644
--- a/dev4/psychlops/core/device/clock.cs
+++ b/dev4/psychlops/core/device/clock.cs
@@ -34,6 +34,10 @@ namespace Psychlops
 		{
 			return lhs.ticks != rhs.ticks;
 		}
+		public override int GetHashCode()
+		{
+			return ticks.GetHashCode();
+		}
 		public static bool operator >(Clock lhs, Clock rhs)
 		{
 			return lhs.ticks > rhs.ticks;
diff --git a/dev4/psychlops/core/graphic/canvas.cs b/dev4/psychlops/core/graphic/canvas.cs
index fdc3987..be3cbae 100644
--- a/dev4/psychlops/core/graphic/canvas.cs
+++ b/dev4/psychlops/core/graphic/canvas.cs
@@ -9,11 +9,21 @@ using System.Windows.Media.Imaging;
 using System.Windows.Shapes;
 using System.Windows.Browser;
 
+using System.Collections.Generic;
+
 
 
 namespace Psychlops
 {
 
+	internal static partial class CONST
+	{
+		internal static readonly Int32 MAX_OBJ_N = 1500;
+		internal static readonly Int32 MOBJ_N = 1000;
+		internal static readonly Int32 COBJ_N = 300;
+		internal static readonly Int32 HOBJ_N = 100;
+	}
+
 	namespace Templates
 	{
 
@@ -21,105 +31,61 @@ namespace Psychlops
 		{
 //			protected System.Collections.Generic.Queue<Internal.PrimitiveFigure> stack;
 			internal Internal.PrimitiveFigure[] stack;
-			internal int stackN;
+			internal int stackN = 0;
 			internal Line[] lineStack;
-			internal int lineStackN;
+			internal int lineStackN = 0;
 			internal Rectangle[] rectStack;
-			internal int rectStackN;
+			internal int rectStackN = 0;
 			internal Ellipse[] ellipseStack;
-			internal int ellipseStackN;
+			internal int ellipseStackN = 0;
 			internal Polygon[] polygonStack;
-			internal int polygonStackN;
+			internal int polygonStackN = 0;
 			internal Letters[] lettersStack;
-			internal int lettersStackN;
+			internal int lettersStackN = 0;
 			internal Image[] imageStack;
-			internal int imageStackN;
+			internal int imageStackN = 0;
 			internal Group[] groupStack;
-			internal int groupStackN;
+			internal int groupStackN = 0;
 
 
 			public StackableDrawable()
 			{
-//				stack = new System.Collections.Generic.Queue<Internal.PrimitiveFigure>();
-				stack = new Internal.PrimitiveFigure[10000];
-				lineStack = new Line[2000];
-				rectStack = new Rectangle[2000];
-				ellipseStack = new Ellipse[2000];
-				polygonStack = new Polygon[1000];
-				lettersStack = new Letters[1000];
-				imageStack = new Image[100];
-				groupStack = new Group[100];
-				for (int i = 0; i < 2000; i++)
+				stack = new Internal.PrimitiveFigure[CONST.MAX_OBJ_N];
+				lineStack = new Line[CONST.MOBJ_N];
+				rectStack = new Rectangle[CONST.MOBJ_N];
+				ellipseStack = new Ellipse[CONST.MOBJ_N];
+				polygonStack = new Polygon[CONST.COBJ_N];
+				lettersStack = new Letters[CONST.COBJ_N];
+				imageStack = new Image[CONST.HOBJ_N];
+				groupStack = new Group[CONST.HOBJ_N];
+				for (int i = 0; i < CONST.MOBJ_N; i++)
 				{
 					lineStack[i] = new Line(0,0,0,0);
 					rectStack[i] = new Rectangle();
 					ellipseStack[i] = new Ellipse();
 				}
-				for (int i = 0; i < 1000; i++)
+				for (int i = 0; i < CONST.COBJ_N; i++)
 				{
 					polygonStack[i] = new Polygon();
 					lettersStack[i] = new Letters();
 				}
-				for (int i = 0; i < 100; i++)
+				for (int i = 0; i < CONST.HOBJ_N; i++)
 				{
 					imageStack[i] = new Image(1, 1);
 					groupStack[i] = new Group();
 				}
 			}
 
-			public void clear()
-			{
-				clear(Color.black);
-			}
-			public virtual void clear(Color col)
-			{
-				//rect(back_panel, col);
-			}
-
-			public virtual void pix(int x, int y, Color col)
-			{
-			}
-
-			public virtual void line(Line drawee)
-			{
-				//				stack.Enqueue(drawee.clone());
-				drawee.copyToStack(this);
-			}
-
-			public virtual void rect(Rectangle drawee)
-			{
-				//stack.Enqueue(drawee.clone());
-//				stack.Enqueue(drawee.copyToStack(this));
-				drawee.copyToStack(this);
-			}
-
-			public virtual void ellipse(Ellipse drawee)
-			{
-				//				stack.Enqueue(drawee.clone());
-				drawee.copyToStack(this);
-			}
-
-			public virtual void polygon(Polygon drawee)
-			{
-				//				stack.Enqueue(drawee.clone());
-				drawee.copyToStack(this);
-			}
-
-			public virtual void letters(Letters drawee)
-			{
-				//				stack.Enqueue(drawee.clone());
-				drawee.copyToStack(this);
-			}
-
-			public virtual void image(Image drawee)
-			{
-				//				stack.Enqueue(drawee.clone());
-				drawee.copyToStack(this);
-			}
-			public virtual void group(Group drawee)
-			{
-				drawee.copyToStack(this);
-			}
+			public void clear() { clear(Color.black); }
+			public virtual void clear(Color col) { } //rect(back_panel, col); }
+			public virtual void pix(int x, int y, Color col) { }
+			public virtual void line(Line drawee) { drawee.copyToStack(this); }
+			public virtual void rect(Rectangle drawee) { drawee.copyToStack(this); }
+			public virtual void ellipse(Ellipse drawee) { drawee.copyToStack(this); }
+			public virtual void polygon(Polygon drawee) { drawee.copyToStack(this); }
+			public virtual void letters(Letters drawee) { drawee.copyToStack(this); }
+			public virtual void image(Image drawee) { drawee.copyToStack(this); }
+			public virtual void group(Group drawee) { drawee.copyToStack(this); }
 
 			public void msg(string str, double x, double y) { msg(str, x, y, Color.white); }
 			public virtual void msg(string dstr, double x, double y, Color col)
@@ -139,7 +105,6 @@ namespace Psychlops
 
 	public class Canvas : Templates.StackableDrawable
 	{
-
 		internal System.Windows.Controls.Canvas masterPool, prevPool;
 		internal System.Windows.Point[] pointPool;
 		internal int pointPoolN;
@@ -148,6 +113,7 @@ namespace Psychlops
 
 		internal System.Windows.Controls.Canvas[] UIElementPool;
 		internal int UIElementPoolN;
+		internal int lastVisibleN;
 
 		internal System.Windows.Shapes.Line[] linePool;
 		internal int linePoolN;
@@ -162,6 +128,7 @@ namespace Psychlops
 		internal int lettersPoolN;
 		internal System.Windows.Controls.Image[] imagePool;
 		internal int imagePoolN;
+		internal Dictionary<int, bool> imagePoolT;
 		internal System.Windows.Controls.Canvas[] groupPool;
 		internal int groupPoolN;
 
@@ -171,14 +138,11 @@ namespace Psychlops
 		internal delegate void SimpleProcedure();
 		SimpleProcedure flipexec;
 
-		//public static System.Windows.Controls.Image default_buffer_frame;
 		public static System.Windows.Controls.UserControl default_panel;
 		public static System.Windows.Controls.Canvas default_api_canvas;
 		public static WriteableBitmap default_buffer;
-		//WriteableBitmap buffer;
-		//System.Windows.Controls.Image instance;
-		System.Windows.Controls.Canvas api_canvas;
-		System.Windows.Controls.UserControl panel;
+		internal System.Windows.Controls.Canvas api_canvas;
+		internal System.Windows.Controls.UserControl panel;
 		Rectangle back_panel;
 		double width_, height_;
 		Clock before;
@@ -234,79 +198,79 @@ namespace Psychlops
 			htmlHost.SetStyleAttribute("height", (20+hei).ToString() + "px");
 			htmlHost.SetStyleAttribute("margin", "2em auto auto auto");
 
-			UIElementPool = new System.Windows.Controls.Canvas[2000];
-			pointPool = new System.Windows.Point[2000];
-			brushPool = new SolidColorBrush[2000];
-			linePool = new System.Windows.Shapes.Line[2000];
-			rectPool = new System.Windows.Shapes.Rectangle[2000];
-			dummyRectPool = new System.Windows.Shapes.Rectangle[2000];
-			ellipsePool = new System.Windows.Shapes.Ellipse[2000];
-			for (int i = 0; i < 2000; i++)
+			pointPool = new System.Windows.Point[CONST.MOBJ_N];
+			brushPool = new SolidColorBrush[CONST.MOBJ_N];
+			linePool = new System.Windows.Shapes.Line[CONST.MOBJ_N];
+			rectPool = new System.Windows.Shapes.Rectangle[CONST.MOBJ_N];
+			ellipsePool = new System.Windows.Shapes.Ellipse[CONST.MOBJ_N];
+			for (int i = 0; i < CONST.MOBJ_N; i++)
 			{
-				UIElementPool[i] = new System.Windows.Controls.Canvas();
 				pointPool[i] = new System.Windows.Point();
 				brushPool[i] = new SolidColorBrush();
 				linePool[i] = new System.Windows.Shapes.Line();
 				rectPool[i] = new System.Windows.Shapes.Rectangle();
-				dummyRectPool[i] = new System.Windows.Shapes.Rectangle();
 				ellipsePool[i] = new System.Windows.Shapes.Ellipse();
 			}
-			polygonPool = new System.Windows.Shapes.Polygon[1000];
-			lettersPool = new System.Windows.Controls.TextBlock[1000];
-			for (int i = 0; i < 1000; i++)
+			polygonPool = new System.Windows.Shapes.Polygon[CONST.COBJ_N];
+			lettersPool = new System.Windows.Controls.TextBlock[CONST.COBJ_N];
+			for (int i = 0; i < CONST.COBJ_N; i++)
 			{
 				polygonPool[i] = new System.Windows.Shapes.Polygon();
 				lettersPool[i] = new System.Windows.Controls.TextBlock();
 			}
-			imagePool = new System.Windows.Controls.Image[100];
-			groupPool = new System.Windows.Controls.Canvas[100];
-			for (int i = 0; i < 100; i++)
+			imagePool = new System.Windows.Controls.Image[CONST.HOBJ_N];
+			imagePoolT = new Dictionary<int, bool>(CONST.HOBJ_N);
+			groupPool = new System.Windows.Controls.Canvas[CONST.HOBJ_N];
+			for (int i = 0; i < CONST.HOBJ_N; i++)
 			{
 				imagePool[i] = new System.Windows.Controls.Image();
+				imagePoolT.Add(imagePool[i].GetHashCode(), false);
 				groupPool[i] = new System.Windows.Controls.Canvas();
 			}
 
 			masterPool = new System.Windows.Controls.Canvas();
 			prevPool = new System.Windows.Controls.Canvas();
 			api_canvas.Children.Add(masterPool);
+
 			//api_canvas.Children.Remove(Internal.Main.widgetStack);
+			Psychlops.Internal.Main.widgetStack = new StackPanel();
+			Psychlops.Internal.Main.widgetStack.Orientation = Orientation.Vertical;
+			Psychlops.Internal.Main.widgetStack.Height = hei;
+			api_canvas.Children.Add(Psychlops.Internal.Main.widgetStack);
+			
+
 
-			for (int i = 0; i < 2000; i++)
+			UIElementPool = new System.Windows.Controls.Canvas[CONST.MAX_OBJ_N];
+			dummyRectPool = new System.Windows.Shapes.Rectangle[CONST.MAX_OBJ_N];
+			for (int i = 0; i < CONST.MAX_OBJ_N; i++)
 			{
+				UIElementPool[i] = new System.Windows.Controls.Canvas();
 				masterPool.Children.Add(UIElementPool[i]);
+				dummyRectPool[i] = new System.Windows.Shapes.Rectangle();
 				UIElementPool[i].Children.Add(dummyRectPool[i]);
+				dummyRectPool[i].Visibility = Visibility.Collapsed;
 			}
 
 
 			AsyncInitBool = true;
 		}
 
+		internal int findEmptyInPool(Dictionary<int, bool> pool)
+		{
+			/*
+			foreach( KeyValuePair<int, bool> elem in pool)
+			{
+				if(elem) 
+			}*/
+			return 0;
+		}
+
 		#endregion
 
 		#region static initializer
 		/*
-		static System.Windows.Shapes.Line api_line;
-		static System.Windows.Shapes.Path api_curve;
-		static System.Windows.Shapes.Rectangle api_rect;
-		static System.Windows.Shapes.Ellipse api_ellipse;
-		static System.Windows.Shapes.Polygon api_polygon;
-		static System.Windows.Shapes.Polyline api_polyline;
-		static System.Windows.Media.Color api_color;
-		static System.Windows.Media.SolidColorBrush api_fill;
-		static System.Windows.Media.SolidColorBrush api_stroke;
-		static System.Windows.Media.TranslateTransform api_translation;
 		static Canvas()
 		{
-			api_line = new System.Windows.Shapes.Line();
-			api_curve    = new System.Windows.Shapes.Path();
-			api_rect     = new System.Windows.Shapes.Rectangle();
-			api_ellipse  = new System.Windows.Shapes.Ellipse();
-			api_polygon  = new System.Windows.Shapes.Polygon();
-			api_polyline = new System.Windows.Shapes.Polyline();
-			api_color       = new System.Windows.Media.Color();
-			api_fill        = new System.Windows.Media.SolidColorBrush();
-			api_stroke      = new System.Windows.Media.SolidColorBrush();
-			api_translation = new System.Windows.Media.TranslateTransform();
 		}
 		*/
 		#endregion
@@ -328,7 +292,6 @@ namespace Psychlops
 				chacked = 1;
 			}
 			//pointStackN = 0;
-			//brushStackN = 0;
 			lineStackN = 0;
 			rectStackN = 0;
 			polygonStackN = 0;
@@ -337,6 +300,8 @@ namespace Psychlops
 			imageStackN = 0;
 			groupStackN = 0;
 
+			UIElementPoolN = 0;
+			brushPoolN = 0;
 			/*
 			pointPoolN = 0;
 			brushPoolN = 0;
@@ -385,113 +350,109 @@ namespace Psychlops
 				nextIntervalFrame--;
 			}
 
-
-
-			var en = masterPool.Children.GetEnumerator();
-			bool full = en.MoveNext();
-			var cnv = en.Current as System.Windows.Controls.Canvas;
+			var cnv = UIElementPool[0];
 			if (nextIntervalFrame <= 0)
 			{
 				if (chacked > 0)
 				{
 					if (stackN > 0)
 					{
-						for (int i = 0; i < stackN - 2; i++)
+						for (int i = 0; i < stackN; i++)
 						{
-							if (full == false)
+							if( null != (rectS = stack[i] as Rectangle) )
 							{
-								break;
+								if (null != (rectP = cnv.Children[0] as System.Windows.Shapes.Rectangle))
+								{
+									rectS.modifyNative(rectP, this);
+								}
+								else
+								{
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
+								}
 							}
-							else
+							else if (null != (lineS = stack[i] as Line))
 							{
-								if( null != (rectS = stack[i] as Rectangle) )
+								if (null != (lineP = cnv.Children[0] as System.Windows.Shapes.Line))
 								{
-									if (null != (rectP = cnv.Children[0] as System.Windows.Shapes.Rectangle))
-									{
-										rectS.modifyNative(rectP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									lineS.modifyNative(lineP, this);
 								}
-								else if (null != (lineS = stack[i] as Line))
+								else
 								{
-									if (null != (lineP = cnv.Children[0] as System.Windows.Shapes.Line))
-									{
-										lineS.modifyNative(lineP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
 								}
-								else if (null != (ellipseS = stack[i] as Ellipse))
+							}
+							else if (null != (ellipseS = stack[i] as Ellipse))
+							{
+								if (null != (ellipseP = cnv.Children[0] as System.Windows.Shapes.Ellipse))
 								{
-									if (null != (ellipseP = cnv.Children[0] as System.Windows.Shapes.Ellipse))
-									{
-										ellipseS.modifyNative(ellipseP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									ellipseS.modifyNative(ellipseP, this);
 								}
-								else if (null != (polygonS = stack[i] as Polygon))
+								else
 								{
-									if (null != (polygonP = cnv.Children[0] as System.Windows.Shapes.Polygon))
-									{
-										polygonS.modifyNative(polygonP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
 								}
-								else if (null != (lettersS = stack[i] as Letters))
+							}
+							else if (null != (polygonS = stack[i] as Polygon))
+							{
+								if (null != (polygonP = cnv.Children[0] as System.Windows.Shapes.Polygon))
 								{
-									if (null != (lettersP = cnv.Children[0] as System.Windows.Controls.TextBlock))
-									{
-										lettersS.modifyNative(lettersP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									polygonS.modifyNative(polygonP, this);
 								}
-								else if (null != (imageS = stack[i] as Image))
+								else
 								{
-									if (null != (imageP = cnv.Children[0] as System.Windows.Controls.Image))
-									{
-										imageS.modifyNative(imageP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
 								}
-								else if (null != (groupS = stack[i] as Group))
+							}
+							else if (null != (lettersS = stack[i] as Letters))
+							{
+								if (null != (lettersP = cnv.Children[0] as System.Windows.Controls.TextBlock))
 								{
-									if (null != (groupP = cnv.Children[0] as System.Windows.Controls.Canvas))
-									{
-										groupS.modifyNative(groupP, this);
-									}
-									else
-									{
-										cnv.Children.Clear();
-										cnv.Children.Add(stack[i].poolNative(this));
-									}
+									lettersS.modifyNative(lettersP, this);
+								}
+								else
+								{
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
+								}
+							}
+							else if (null != (imageS = stack[i] as Image))
+							{
+								if (null != (imageP = cnv.Children[0] as System.Windows.Controls.Image))
+								{
+									imageS.modifyNative(imageP, this);
+								}
+								else
+								{
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
 								}
-								full = en.MoveNext();
-								cnv = en.Current as System.Windows.Controls.Canvas;
 							}
+							else if (null != (groupS = stack[i] as Group))
+							{
+								if (null != (groupP = cnv.Children[0] as System.Windows.Controls.Canvas))
+								{
+									groupS.modifyNative(groupP, this);
+								}
+								else
+								{
+									cnv.Children.Clear();
+									cnv.Children.Add(stack[i].poolNative(this));
+								}
+							}
+							cnv.Visibility = Visibility.Visible;
+							UIElementPoolN++;
+							cnv = UIElementPool[UIElementPoolN];
+						}
+						for (int i = UIElementPoolN; i < lastVisibleN; i++)
+						{
+							cnv = UIElementPool[i];
+							cnv.Visibility = Visibility.Collapsed;
 						}
+						lastVisibleN = UIElementPoolN;
 						stackN = 0;
 					}
 					lock (this)
@@ -676,12 +637,46 @@ namespace Psychlops
 		#endregion
 
 
+		#region compatibitily trick
+
+		public enum Mode { window, fullscreen }
+		public static readonly Mode window = Mode.window, fullscreen = Mode.fullscreen;
+
+		public Canvas(int wid, int hei, Mode mod)
+		{
+			panel = default_panel;
+			api_canvas = default_api_canvas;
+			initialize(500, 500);
+		}
+		public Canvas(Mode mod) : base()
+		{
+			panel = default_panel;
+			api_canvas = default_api_canvas;
+			initialize(500, 500);
+		}
+
+
+		public void showFPS(bool sw = true) { }
+		public void watchFPS(bool sw = true) { }
+
+
+		public void clear(double lum)
+		{
+			clear(new Color(lum));
+		}
+
+		#endregion
+
+
 	}
 
 
 
 	#region primitive tokenizer
 
+
+	#region primitive
+
 	partial struct Point
 	{
 		public static implicit operator System.Windows.Point(Point d)
@@ -700,6 +695,14 @@ namespace Psychlops
 		{
 			return new SolidColorBrush { Color = d };
 		}
+		public System.Windows.Media.SolidColorBrush getNativeFromStack(Canvas d)
+		{
+			var tmp = d.brushPool[d.brushPoolN];
+			tmp.Color = this;
+			d.brushPoolN++;
+			return tmp;
+		}
+
 	}
 
 	partial struct Stroke
@@ -714,7 +717,18 @@ namespace Psychlops
 		{
 			return new SolidColorBrush { Color = d.color };
 		}
+		public System.Windows.Media.SolidColorBrush getNativeFromStack(Canvas d)
+		{
+			var tmp = d.brushPool[d.brushPoolN];
+			tmp.Color = this.color;
+			d.brushPoolN++;
+			return tmp;
+		}
 	}
+	
+	#endregion
+	
+	#region Line
 
 	partial class Line
 	{
@@ -755,7 +769,7 @@ namespace Psychlops
 			tmp.Y1 = begin.y;
 			tmp.X2 = end.x;
 			tmp.Y2 = end.y;
-			if (stroke.thick == 0.0) tmp.Stroke = fill;
+			if (stroke.thick == 0.0) tmp.Stroke = fill.getNativeFromStack(d);
 			else stroke.apply(tmp);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
@@ -769,13 +783,17 @@ namespace Psychlops
 			tmp.Y1 = begin.y;
 			tmp.X2 = end.x;
 			tmp.Y2 = end.y;
-			if (stroke.thick == 0.0) tmp.Stroke = fill;
+			if (stroke.thick == 0.0) tmp.Stroke = fill.getNativeFromStack(d);
 			else stroke.apply(tmp);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
 			tmp.Visibility = Visibility.Visible;
 		}
 	}
+	
+	#endregion
+		
+	#region Rectangle
 
 	partial class Rectangle
 	{
@@ -816,7 +834,7 @@ namespace Psychlops
 			var tmp = d.rectPool[d.rectPoolN];
 			tmp.Width = width;
 			tmp.Height = height;
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
 			tmp.Visibility = Visibility.Visible;
@@ -827,12 +845,16 @@ namespace Psychlops
 		{
 			tmp.Width = width;
 			tmp.Height = height;
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
 			tmp.Visibility = Visibility.Visible;
 		}
 	}
+	
+	#endregion
+
+	#region Ellipse
 
 	partial class Ellipse
 	{
@@ -871,7 +893,7 @@ namespace Psychlops
 			var tmp = d.ellipsePool[d.ellipsePoolN];
 			tmp.Width = width;
 			tmp.Height = height;
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
 			tmp.Visibility = Visibility.Visible;
@@ -882,13 +904,17 @@ namespace Psychlops
 		{
 			tmp.Width = width;
 			tmp.Height = height;
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, left);
 			System.Windows.Controls.Canvas.SetTop(tmp, top);
 			tmp.Visibility = Visibility.Visible;
 		}
 	}
 
+	#endregion
+
+	#region Polygon
+
 	partial class Polygon
 	{
 		public Polygon dup()
@@ -930,7 +956,7 @@ namespace Psychlops
 		public UIElement poolNative(Canvas d)
 		{
 			var tmp = d.polygonPool[d.polygonPoolN];
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			tmp.Points.Clear();
 			foreach (var v in vertices)
 			{
@@ -944,7 +970,7 @@ namespace Psychlops
 		}
 		public void modifyNative(System.Windows.Shapes.Polygon tmp, Canvas d)
 		{
-			tmp.Fill = fill;
+			tmp.Fill = fill.getNativeFromStack(d);
 			tmp.Points.Clear();
 			foreach (var v in vertices)
 			{
@@ -956,7 +982,11 @@ namespace Psychlops
 		}
 
 	}
-	
+		
+	#endregion
+
+	#region Letters
+
 	partial class Letters
 	{
 		#region static initializer
@@ -1033,7 +1063,7 @@ namespace Psychlops
 			tmp.FontStyle = FONT_STYLE_BRIDGE[font.style];
 			tmp.FontWeight = FONT_WEIGHT_BRIDGE[font.weight];
 			tmp.TextAlignment = LETTERS_H_ALIGN_BRIDGE[align];
-			tmp.Foreground = fill;
+			tmp.Foreground = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, datum.x);
 			System.Windows.Controls.Canvas.SetTop(tmp, datum.y);
 			tmp.Visibility = Visibility.Visible;
@@ -1050,25 +1080,66 @@ namespace Psychlops
 			tmp.FontStyle = FONT_STYLE_BRIDGE[font.style];
 			tmp.FontWeight = FONT_WEIGHT_BRIDGE[font.weight];
 			tmp.TextAlignment = LETTERS_H_ALIGN_BRIDGE[align];
-			tmp.Foreground = fill;
+			tmp.Foreground = fill.getNativeFromStack(d);
 			System.Windows.Controls.Canvas.SetLeft(tmp, datum.x);
 			System.Windows.Controls.Canvas.SetTop(tmp, datum.y);
 			tmp.Visibility = Visibility.Visible;
 		}
 	}
+	
+	#endregion
+	
+	#region Image
 
 	partial class Image
 	{
 		internal void initialize__(int wid, int hei)
 		{
+			AsyncBool = false;
 			Canvas.default_api_canvas.Dispatcher.BeginInvoke(new Canvas.TwoIntProcedure(create__), wid, hei);
-			//buffer = new WriteableBitmap(wid, hei);
+			while (!AsyncBool) { System.Threading.Thread.Sleep(10); }
 		}
 		internal void create__(int wid, int hei)
 		{
 			buffer = new WriteableBitmap(wid, hei);
 			AsyncBool = true;
 		}
+		internal void load__(string uri)
+		{
+			AsyncBool = false;
+			var ur = new System.Uri(uri,  System.UriKind.RelativeOrAbsolute);
+			Canvas.default_api_canvas.Dispatcher.BeginInvoke(new Action<Uri>(load_), ur);
+			while (!AsyncBool) { System.Threading.Thread.Sleep(10); }
+		}
+		internal void load_(Uri uri)
+		{
+			var bitmap = new BitmapImage();
+			bitmap.CreateOptions = BitmapCreateOptions.None;
+			bitmap.UriSource = uri;
+			try
+			{
+				var wbm = new System.Windows.Media.Imaging.WriteableBitmap(bitmap);
+				buffer = wbm;
+			}
+			catch (Exception e)
+			{
+				buffer = new WriteableBitmap(64, 64);
+				buffer.ForEach(bitmap_drawChecker);
+			}
+			self_rect.set(buffer.PixelWidth, buffer.PixelHeight);
+			AsyncBool = true;
+		}
+		static System.Windows.Media.Color[] CHECKER_C;
+		static Image()
+		{
+			CHECKER_C = new System.Windows.Media.Color[2];
+			CHECKER_C[0] = System.Windows.Media.Color.FromArgb(0, 0, 0, 0);
+			CHECKER_C[1] = System.Windows.Media.Color.FromArgb(128,128,128,128);
+		}
+		static System.Windows.Media.Color bitmap_drawChecker(int x, int y)
+		{
+			return ((x / 4) + (y / 4)) % 2 == 0 ? CHECKER_C[0] : CHECKER_C[1];
+		}
 		delegate void FieldFunc1(System.Func<int, int, System.Windows.Media.Color> func);
 		delegate void FieldFunc2(System.Func<int, int, System.Windows.Media.Color, System.Windows.Media.Color> func);
 		public void field__(System.Func<int, int, System.Windows.Media.Color> func)
@@ -1134,6 +1205,9 @@ namespace Psychlops
 
 	}
 
+	#endregion
+
+	#region Group
 
 	partial class Group
 	{
@@ -1215,6 +1289,7 @@ namespace Psychlops
 		}
 
 	}
+	#endregion
 	
 	#endregion
 
diff --git a/dev4/psychlops/core/graphic/image.cs b/dev4/psychlops/core/graphic/image.cs
index 6d5f3f5..f4c48d9 100644
--- a/dev4/psychlops/core/graphic/image.cs
+++ b/dev4/psychlops/core/graphic/image.cs
@@ -21,12 +21,23 @@ namespace Psychlops{
 		public Rectangle self_rect;
 		protected bool AsyncBool;
 
+		public Image(string uri)
+		{
+			self_rect = new Rectangle();
+			load__(uri);
+		}
+
 		public Image(int wid, int hei)
 		{
-			AsyncBool = false;
+			self_rect = new Rectangle(wid, hei);
 			initialize__(wid, hei);
+		}
+
+		public Image set(int wid, int hei)
+		{
 			self_rect = new Rectangle(wid, hei);
-			while (!AsyncBool) { }
+			initialize__(wid, hei);
+			return this;
 		}
 
 		public Figure shift(Point p)
@@ -53,22 +64,23 @@ namespace Psychlops{
 		public void field(System.Func<int, int, System.Windows.Media.Color> func)
 		{
 			field__(func);
-			//buffer.ForEach(func);
 		}
 		public void field(System.Func<int, int, System.Windows.Media.Color, System.Windows.Media.Color> func)
 		{
 			field__(func);
-			//buffer.ForEach(func);
 		}
 		public void each(System.Func<int, int, System.Windows.Media.Color> func)
 		{
 			field__(func);
-			//buffer.ForEach(func);
 		}
 		public void each(System.Func<int, int, System.Windows.Media.Color, System.Windows.Media.Color> func)
 		{
 			field__(func);
-			//buffer.ForEach(func);
+		}
+
+		public void load(string uri)
+		{
+			load__(uri);
 		}
 
 		public void draw()
diff --git a/dev4/psychlops/core/graphic/shape.cs b/dev4/psychlops/core/graphic/shape.cs
index 9cebe91..23cbeca 100644
--- a/dev4/psychlops/core/graphic/shape.cs
+++ b/dev4/psychlops/core/graphic/shape.cs
@@ -19,6 +19,10 @@ namespace Psychlops{
 	}
 	public static class ShapeExtention
 	{
+		public static void draw(this Shape drawee, double c)
+		{
+			drawee.draw( new Color(c) );
+		}
 		public static void draw(this Shape drawee, Color c)
 		{
 			Color tmp_col = drawee.fill;
diff --git a/dev4/psychlops/core/math/interval.cs b/dev4/psychlops/core/math/interval.cs
index 6426046..843338f 100644
--- a/dev4/psychlops/core/math/interval.cs
+++ b/dev4/psychlops/core/math/interval.cs
@@ -9,66 +9,92 @@ namespace Psychlops
 		public enum OPERATOR { CLOSE, OPEN };
 		public const OPERATOR CLOSE = OPERATOR.CLOSE, OPEN = OPERATOR.OPEN;
 		public struct VAL {
-			public double val;
+			public double value;
 			public OPERATOR op;
+			/*public VAL()
+			{
+				val = Double.NaN;
+				op = OPERATOR.CLOSE;
+			}*/
 			public VAL(double v, OPERATOR o)
 			{
-				val = v;
+				value = v;
 				op = o;
 			}
 			public bool bounded()
 			{
-				return !Double.IsNaN(val) && (!Double.IsInfinity(val) || op == OPERATOR.OPEN);
+				return !Double.IsNaN(value) && (!Double.IsInfinity(value) || op == OPERATOR.OPEN);
 			}
 		}
 		public VAL begin, end;
 
-		/*
-		public Interval()
+		
+		/*public Interval()
 		{
 			begin = new VAL { val = Double.PositiveInfinity, op = OPERATOR.CLOSE };
 			end = new VAL { val = Double.NegativeInfinity, op = OPERATOR.CLOSE };
-		}
-		*/
+		}*/
 		public Interval(double floor_val, double ceil_val)
 		{
-			begin.val = floor_val;
+			begin.value = floor_val;
 			begin.op =  OPERATOR.CLOSE;
-			end.val = ceil_val;
+			end.value = ceil_val;
 			end.op = OPERATOR.CLOSE;
 		}
 		public Interval(double floor_val, OPERATOR floor_op, double ceil_val, OPERATOR ceil_op)
 		{
-			begin.val = floor_val;
+			begin.value = floor_val;
 			begin.op = floor_op;
-			end.val = ceil_val;
+			end.value = ceil_val;
 			end.op = ceil_op;
 		}
 
-		/*
-		public int int_floor();
-		public int int_floor(int minval);
-		public int int_ceil();
-		public int int_ceil(int maxval);
-		*/
+
+		public int int_floor()
+		{
+			double v = Math.ceil(begin.value);
+			if (begin.op == OPEN && v == begin.value) { return (int)v + 1; }
+			else return (int)v;
+		}
+		public int int_floor(int minval)
+		{
+			if(begin.value<minval) return minval;
+			double v = Math.ceil(begin.value);
+			if (begin.op == OPEN && v == begin.value) { return (int)v + 1; }
+			else return (int)v;
+		}
+		public int int_ceil()
+		{
+			double v = Math.floor(end.value);
+			if (end.op == OPEN && v == end.value) { return (int)v - 1; }
+			else return (int)v;
+		}
+		public int int_ceil(int maxval)
+		{
+			if(end.value>maxval) return maxval;
+			double v = Math.floor(end.value);
+			if (end.op == OPEN && v == end.value) { return (int)v - 1; }
+			else return (int)v;
+		}
+		
 		bool includes(double val)
 		{
 			bool result = false;
 			switch(begin.op) {
 				case OPERATOR.CLOSE:
-				result = begin.val<=val ? true : false;
-				break;
+					result = begin.value <= val ? true : false;
+					break;
 				case OPERATOR.OPEN:
-				result = begin.val<val ? true : false;
-				break;
+					result = begin.value < val ? true : false;
+					break;
 			}
 			switch(end.op) {
 				case OPERATOR.CLOSE:
-				result = result && ( end.val>=val ? true : false );
-				break;
+					result = result && (end.value >= val ? true : false);
+					break;
 				case OPERATOR.OPEN:
-				result = result && ( end.val>val ? true : false );
-				break;
+					result = result && (end.value > val ? true : false);
+					break;
 			}
 			return result;
 		}
@@ -84,13 +110,13 @@ namespace Psychlops
 			//			return new IntervalIEnumerable(this, steps);
 			Interval it = this;
 			long front_step = (it.begin.op == Interval.OPERATOR.CLOSE ? -1 : 0);
-			long back_step = (long)System.Math.Floor((it.end.val - it.begin.val) / steps);
-			if (it.end.op == Interval.OPERATOR.OPEN && 0 == System.Math.IEEERemainder(it.end.val - it.begin.val, steps))
+			long back_step = (long)System.Math.Floor((it.end.value - it.begin.value) / steps);
+			if (it.end.op == Interval.OPERATOR.OPEN && 0 == System.Math.IEEERemainder(it.end.value - it.begin.value, steps))
 			{
 				back_step -= 1;
 			}
 			while (front_step <= back_step)
-				yield return steps * front_step + it.begin.val;
+				yield return steps * front_step + it.begin.value;
 		}
 
 
@@ -143,35 +169,35 @@ namespace Psychlops
 
 			public static IntervalAcc operator <(double val, IntervalAcc rng)
 			{
-				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };
+				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.value, rng.instance.end.op) };
 			}
 			public static IntervalAcc operator <=(double val, IntervalAcc rng)
 			{
-				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };
+				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.value, rng.instance.end.op) };
 			}
 			public static IntervalAcc operator >(double val, IntervalAcc rng)
 			{
-				return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };
+				return new IntervalAcc { instance = new Interval(rng.instance.begin.value, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };
 			}
 			public static IntervalAcc operator >=(double val, IntervalAcc rng)
 			{
-				return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };
+				return new IntervalAcc { instance = new Interval(rng.instance.begin.value, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };
 			}
 			public static IntervalAcc operator <(IntervalAcc rng, double val)
 			{
-				return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };
+				return new IntervalAcc { instance = new Interval(rng.instance.begin.value, rng.instance.begin.op, val, Interval.OPERATOR.OPEN) };
 			}
 			public static IntervalAcc operator <=(IntervalAcc rng, double val)
 			{
-				return new IntervalAcc { instance = new Interval(rng.instance.begin.val, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };
+				return new IntervalAcc { instance = new Interval(rng.instance.begin.value, rng.instance.begin.op, val, Interval.OPERATOR.CLOSE) };
 			}
 			public static IntervalAcc operator >(IntervalAcc rng, double val)
 			{
-				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.val, rng.instance.end.op) };
+				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.OPEN, rng.instance.end.value, rng.instance.end.op) };
 			}
 			public static IntervalAcc operator >=(IntervalAcc rng, double val)
 			{
-				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.val, rng.instance.end.op) };
+				return new IntervalAcc { instance = new Interval(val, Interval.OPERATOR.CLOSE, rng.instance.end.value, rng.instance.end.op) };
 			}
 
 			public static implicit operator Interval(IntervalAcc rhs)
diff --git a/dev4/psychlops/core/math/matrix.cs b/dev4/psychlops/core/math/matrix.cs
index 9bd895f..de4a836 100644
--- a/dev4/psychlops/core/math/matrix.cs
+++ b/dev4/psychlops/core/math/matrix.cs
@@ -13,11 +13,25 @@ namespace Psychlops
 		}
 
 		/*
+		public abstract Internal.MatrixExpression this[Interval row, Interval col]
+		{
+			get;
+			set;
+		}
+
+
+		/*
 		public static Matrix operator +(Matrix m, double d)
 		{
 			return new Internal.MatrixExpression();
 		}
 		*/
+
+		public abstract int rows { get; }
+		public abstract int cols { get; }
+		public int getRows() { return rows; }
+		public int getCols() { return cols; }
+
 	}
 
 
@@ -26,41 +40,56 @@ namespace Psychlops
 
 		public class MatrixImplementation : Matrix
 		{
-			internal double[] elements;
-			readonly int nrow, ncol;
+			internal double[,] elements;
 
 			public MatrixImplementation(int dnrow, int dncol)
 			{
-				nrow = dnrow;
-				ncol = dncol;
-				elements = new double[nrow * ncol];
+				elements = new double[dnrow, dncol];
 			}
 
 			public override double this[int row, int col]
 			{
 				get
 				{
-					return elements[(row - 1) * ncol + (col - 1)];
+					return elements[row - 1, col - 1];
 				}
 				set
 				{
-					elements[(row - 1) * ncol + (col - 1)] = value;
+					elements[row - 1, col - 1] = value;
 				}
 			}
+			/*
+			public override MatrixExpression this[Interval row, Interval col]
+			{
+				get
+				{
+					return new MatrixExpression(this, row.int_floor(), col.int_floor(), row.int_ceil(), col.int_ceil());
+				}
+				set
+				{
+					for(int r = 0, r<)
+					elements[row - 1, col - 1] = value;
+				}
+			}
+			 * */
+
+			public override int rows { get { return elements.GetLength(0); } }
+			public override int cols { get { return elements.GetLength(1); } }
+
 		}
 
 		public class MatrixExpression : Matrix
 		{
 			MatrixImplementation imp;
-			readonly int nrow, ncol;
-			readonly int drow, dcol;
-			
-			public MatrixExpression(MatrixImplementation target, int ddrow, int ddcol, int dnrow, int dncol)
+			readonly int brow, bcol;
+			readonly int erow, ecol;
+
+			internal MatrixExpression(MatrixImplementation target, int dbrow, int dbcol, int derow, int decol)
 			{
-				nrow = dnrow;
-				ncol = dncol;
-				drow = ddrow;
-				dcol = ddcol;
+				brow = dbrow;
+				bcol = dbcol;
+				erow = derow;
+				ecol = decol;
 				imp = target;
 			}
 
@@ -68,13 +97,16 @@ namespace Psychlops
 			{
 				get
 				{
-					return imp.elements[(row - drow) * ncol + (col - dcol)];
+					return imp.elements[(row - 1 - brow), (col - 1 - bcol)];
 				}
 				set
 				{
-					imp.elements[(row - drow) * ncol + (col - dcol)] = value;
+					imp.elements[(row - 1 - brow), (col - 1 - bcol)] = value;
 				}
 			}
+
+			public override int rows { get { return erow - brow + 1; } }
+			public override int cols { get { return ecol - bcol + 1; } }
 		}
 	}
 
diff --git a/dev4/psychlops/core/math/util.cs b/dev4/psychlops/core/math/util.cs
index 85134a9..20886e0 100644
--- a/dev4/psychlops/core/math/util.cs
+++ b/dev4/psychlops/core/math/util.cs
@@ -5,20 +5,20 @@ namespace Psychlops
 
 	public static class Math
 	{
-		public static readonly double PI = 3.14159265, E = 2.718281828459045, LOG2E = 1.44269504088896340736;
+		public const double PI = 3.14159265, E = 2.718281828459045, LOG2E = 1.44269504088896340736;
 		public static Random random_generator;
 		static Math()
 		{
 			random_generator = new Random();
 		}
 
-		public static double max(double val1, double val2)
+		public static T max<T>(T val1, T val2) where T : IComparable
 		{
-			return val1 > val2 ? val1 : val2;
+			return val1.CompareTo(val2) > 0 ? val1 : val2;
 		}
-		public static double min(double val1, double val2)
+		public static T min<T>(T val1, T val2) where T : IComparable
 		{
-			return val1 < val2 ? val1 : val2;
+			return val1.CompareTo(val2) < 0 ? val1 : val2;
 		}
 		public static void shuffle<X>(X[] array, int n)
 		{
@@ -41,6 +41,14 @@ namespace Psychlops
 		{
 			return System.Math.Abs(x);
 		}
+		public static double floor(double x)
+		{
+			return System.Math.Floor(x);
+		}
+		public static double ceil(double x)
+		{
+			return System.Math.Ceiling(x);
+		}
 		public static double sin(double x)
 		{
 			return System.Math.Sin(x);
@@ -53,6 +61,26 @@ namespace Psychlops
 		{
 			return System.Math.Tan(x);
 		}
+		public static double asin(double x)
+		{
+			return System.Math.Asin(x);
+		}
+		public static double acos(double x)
+		{
+			return System.Math.Acos(x);
+		}
+		public static double atan(double x)
+		{
+			return System.Math.Atan(x);
+		}
+		public static double atan(double y, double x)
+		{
+			return System.Math.Atan2(y, x);
+		}
+		public static double atan2(double y, double x)
+		{
+			return System.Math.Atan2(y, x);
+		}
 		public static double sqrt(double x)
 		{
 			return System.Math.Sqrt(x);
@@ -69,11 +97,10 @@ namespace Psychlops
 		{
 			return log(val) * LOG2E;
 		}
-		/*public static int round(double val)
+		public static double round(double val)
 		{
-			double integer_part, particle = modf(val, &integer_part);
-			return ((particle < 0.5 | (particle == 0.5 && (int)integer_part % 2 == 0)) ? (int)integer_part : (int)integer_part + 1);
-		}*/
+			return System.Math.Round(val);
+		}
 
 		public static double radius(double x, double y)
 		{
@@ -102,6 +129,131 @@ namespace Psychlops
 		{
 			return exp(- (x*x) / (2*sigma*sigma));
 		}
+
+		public static double normalDistibution(double x, double mu, double sigma)
+		{
+			return exp( -( (x-mu)*(x-mu) / (2*sigma*sigma) ) ) / sqrt(2*PI*sigma*sigma);
+		}
+
+		public static double cumulativeNormalDistibution(double x, double mu, double sigma)
+		{
+			return .5 + .5*Internal.GammaFunction.erf( (x-mu)/(sigma*sqrt(2.0) ) );
+		}
+
 	}
 
+	namespace Internal
+	{
+		public static class GammaFunction
+		{
+			/************ loggamma(x) -- gamma.c より再掲 *************/
+
+			static readonly double PI      = 3.14159265358979324;  /* $\pi$ */
+			static readonly double LOG_2PI = 1.83787706640934548;  /* $\log 2\pi$ */
+			static readonly double N       = 8;
+
+			static readonly double B0  = 1            ;     /* 以下はBernoulli数 */
+			static readonly double B1  = (-1.0 / 2.0);
+			static readonly double B2  = ( 1.0 / 6.0);
+			static readonly double B4  = (-1.0 / 30.0);
+			static readonly double B6  = ( 1.0 / 42.0);
+			static readonly double B8  = (-1.0 / 30.0);
+			static readonly double B10 = ( 5.0 / 66.0);
+			static readonly double B12 = (-691.0 / 2730.0);
+			static readonly double B14 = ( 7.0 / 6.0);
+			static readonly double B16 = (-3617.0 / 510.0);
+
+			public static double loggamma(double x)  /* ガンマ関数の対数 */
+			{
+				double v, w;
+
+				v = 1;
+				while (x < N) {  v *= x;  x++;  }
+				w = 1 / (x * x);
+				return ((((((((B16 / (16 * 15))  * w + (B14 / (14 * 13))) * w
+							+ (B12 / (12 * 11))) * w + (B10 / (10 *  9))) * w
+							+ (B8  / ( 8 *  7))) * w + (B6  / ( 6 *  5))) * w
+							+ (B4  / ( 4 *  3))) * w + (B2  / ( 2 *  1))) / x
+							+ 0.5 * LOG_2PI - Math.log(v) - x + (x - 0.5) * Math.log(x);
+			}
+
+			public static double p_gamma(double a, double x, double loggamma_a)  /* 本文参照 */
+			{
+				int k;
+				double result, term, previous;
+
+				if (x >= 1 + a) return 1 - q_gamma(a, x, loggamma_a);
+				if (x == 0)     return 0;
+				result = term = Math.exp(a * Math.log(x) - x - loggamma_a) / a;
+				for (k = 1; k < 1000; k++) {
+					term *= x / (a + k);
+					previous = result;  result += term;
+					if (result == previous) return result;
+				}
+				//throw new Exception("p_gamma(): the sequence is not convergent.");
+				return result;
+			}
+
+			public static double q_gamma(double a, double x, double loggamma_a)  /* 本文参照 */
+			{
+				int k;
+				double result, w, temp, previous;
+				double la = 1, lb = 1 + x - a;  /* Laguerreの多項式 */
+
+				if (x < 1 + a) return 1 - p_gamma(a, x, loggamma_a);
+				w = Math.exp(a * Math.log(x) - x - loggamma_a);
+				result = w / lb;
+				for (k = 2; k < 1000; k++) {
+					temp = ((k - 1 - a) * (lb - la) + (k + x) * lb) / k;
+					la = lb;  lb = temp;
+					w *= (k - 1 - a) / k;
+					temp = w / (la * lb);
+					previous = result;  result += temp;
+					if (result == previous) return result;
+				}
+				//throw new Exception("q_gamma(): the sequence is not convergent.");
+				return result;
+			}
+
+			public static double p_chisq(double chisq, int df)  /* カイ2乗分布の下側確率 */
+			{
+				return p_gamma(0.5 * df, 0.5 * chisq, loggamma(0.5 * df));
+			}
+
+			public static double q_chisq(double chisq, int df)  /* カイ2乗分布の上側確率 */
+			{
+				return q_gamma(0.5 * df, 0.5 * chisq, loggamma(0.5 * df));
+			}
+
+			static readonly double LOG_PI = 1.14472988584940017;  /* $\log_e \pi$ */
+
+			public static double erf(double x)  /* Gaussの誤差関数 ${\rm erf}(x)$ */
+			{
+				if (x >= 0) return   p_gamma(0.5, x * x, LOG_PI / 2);
+				else        return - p_gamma(0.5, x * x, LOG_PI / 2);
+			}
+
+			public static double erfc(double x)  /* $1 - {\rm erf}(x)$ */
+			{
+				if (x >= 0) return  q_gamma(0.5, x * x, LOG_PI / 2);
+				else        return  1 + p_gamma(0.5, x * x, LOG_PI / 2);
+			}
+
+			public static double p_normal(double x)  /* 標準正規分布の下側確率 */
+			{
+				if (x >= 0) return
+					0.5 * (1 + p_gamma(0.5, 0.5 * x * x, LOG_PI / 2));
+				else return
+					0.5 * q_gamma(0.5, 0.5 * x * x, LOG_PI / 2);
+			}
+
+			public static double q_normal(double x)  /* 標準正規分布の上側確率 */
+			{
+				if (x >= 0) return
+					0.5 * q_gamma(0.5, 0.5 * x * x, LOG_PI / 2);
+				else return
+					0.5 * (1 + p_gamma(0.5, 0.5 * x * x, LOG_PI / 2));
+			}
+		}
+	}
 }
\ No newline at end of file
diff --git a/dev4/psychlops/extention/compatibility/compatibility.cs b/dev4/psychlops/extention/compatibility/compatibility.cs
new file mode 100644
index 0000000..f43b5d5
--- /dev/null
+++ b/dev4/psychlops/extention/compatibility/compatibility.cs
@@ -0,0 +1,68 @@
+
+
+
+namespace Psychlops
+{
+
+	/*
+	namespace Internal
+	{
+		public class IndependentAccessor
+		{
+			Widgets.Slider sld; 
+			public static IndependentAccessor operator <<( IndependentAccessor ind, Widgets.Slider sl )
+			{
+				ind.sld = sl;
+				Psychlops.Main.canvas.independent_list.Add(sl);
+				return ind;
+			}
+			public static IndependentAccessor operator | (IndependentAccessor ind, string str)
+			{
+				label = l;
+				Psychlops.Main.canvas.independent_list.Add(sl);
+				return ind;
+			}
+		}
+	}
+	 **/
+
+	public static class Display
+	{
+		public static void pix(int x, int y, Color col) { Main.canvas.pix(x, y, col); }
+		public static void line(Line drawee) { Main.canvas.line(drawee); }
+		public static void rect(Rectangle drawee) { Main.canvas.rect(drawee); }
+		public static void ellipse(Ellipse drawee) { Main.canvas.ellipse(drawee); }
+		public static void polygon(Polygon drawee) { Main.canvas.polygon(drawee); }
+		public static void letters(Letters drawee) { Main.canvas.letters(drawee); }
+		public static void image(Image drawee) { Main.canvas.image(drawee); }
+		public static void group(Group drawee) { Main.canvas.group(drawee); }
+
+
+		public static void msg(string str, double x, double y) { Main.canvas.msg(str, x, y, Color.white); }
+		public static void msg(string dstr, double x, double y, Color col) { Main.canvas.msg(dstr, x, y, col); }
+		public static void var<Type>(Type val, double x, double y) { Main.canvas.var(val, x, y, Color.white); }
+		public static void var<Type>(Type val, double x, double y, Color col) { Main.canvas.var(val, x, y, col); }
+
+
+
+		public static void clear() { Main.canvas.clear(Color.black); }
+		public static void clear(double lum) { Main.canvas.clear(lum); }
+		public static void clear(Color col) { Main.canvas.clear(col); }
+		public static void flip(int n = 1) { Main.canvas.flip(n); }
+
+		public static double width { get { return Main.canvas.width; } }
+		public static double height { get { return Main.canvas.height; } }
+		public static Point center { get { return Main.canvas.center; } }
+		public static double getWidth() { return width; }
+		public static double getHeight() { return height; }
+		public static Point getCenter() { return center; }
+		public static double getHCenter() { return Main.canvas.getHCenter(); }
+		public static double getVCenter() { return Main.canvas.getVCenter(); }
+		public static double getRefreshRate() { return Main.canvas.getRefreshRate(); }
+
+		public static void showFPS(bool sw = true) { Main.canvas.showFPS(sw); }
+		public static void watchFPS(bool sw = true) { Main.canvas.watchFPS(sw); }
+
+	}
+
+}
diff --git a/dev4/psychlops/extention/math/solver.cs b/dev4/psychlops/extention/math/solver.cs
index e26365f..2bca111 100644
--- a/dev4/psychlops/extention/math/solver.cs
+++ b/dev4/psychlops/extention/math/solver.cs
@@ -7,6 +7,10 @@ namespace Psychlops
 
 	namespace Solver
 	{
+		internal static class CONST
+		{
+			public static readonly uint MAX_ARG = 5;
+		}
 
 		
 		static public class Constants
@@ -34,7 +38,8 @@ namespace Psychlops
 			}
 			public static double combination(int nn, int kk)
 			{
-				//return (double)(Int64)(factorial(n) / (factorial(kk) * factorial(n - kk)));
+				return (double)(Int64)(factorial(nn) / (factorial(kk) * factorial(nn - kk)));
+				/*
 				BigInt n = new BigInt((Int64)nn, new PrecisionSpec());
 				BigInt k = new BigInt((Int64)kk, new PrecisionSpec());
 				BigInt n_k = n - k;
@@ -42,6 +47,7 @@ namespace Psychlops
 				k.Factorial();
 				n_k.Factorial();
 				return (double)(Int64)(n / (k * n_k) );
+				 * */
 			}
 			public static double likelihood(double pp, int yes, int no)
 			{
@@ -112,22 +118,27 @@ namespace Psychlops
 
 			public BinomialLikelihoodThread()
 			{
+				itvl = new Interval[CONST.MAX_ARG];
+				step = new double[CONST.MAX_ARG];
+				champ = new double[CONST.MAX_ARG];
+				data = new BernoulliProcess();
 			}
 			public void waitLoop()
 			{
 				finished = false;
-				for(int i=0; i<10; i++) {
+				for (int i = 0; i < CONST.MAX_ARG; i++)
+				{
 					champ[i] = 0;
 				}
 				current = this;
 				started = false;
 			}
 
-			public void loop1() { waitLoop(); th = new Thread(new ThreadStart(loop1_)); }
-			public void loop2() { waitLoop(); th = new Thread(new ThreadStart(loop2_)); }
-			public void loop3() { waitLoop(); th = new Thread(new ThreadStart(loop3_)); }
-			public void loop4() { waitLoop(); th = new Thread(new ThreadStart(loop4_)); }
-			public void loop5() { waitLoop(); th = new Thread(new ThreadStart(loop5_)); }
+			public void loop1() { waitLoop(); th = new Thread(new ThreadStart(loop1_)); th.Start(); }
+			public void loop2() { waitLoop(); th = new Thread(new ThreadStart(loop2_)); th.Start(); }
+			public void loop3() { waitLoop(); th = new Thread(new ThreadStart(loop3_)); th.Start(); }
+			public void loop4() { waitLoop(); th = new Thread(new ThreadStart(loop4_)); th.Start(); }
+			public void loop5() { waitLoop(); th = new Thread(new ThreadStart(loop5_)); th.Start(); }
 			void loop1_()
 			{
 				started = true;
@@ -135,7 +146,7 @@ namespace Psychlops
 				double like = 1.0;
 				champ_like=0.0;
 				int L = data.length;
-				for (double a = itvl[0].begin.val; a < itvl[0].end.val; a += step[0])
+				for (double a = itvl[0].begin.value; a < itvl[0].end.value; a += step[0])
 				{
 					like = 1.0;
 					for(int i=0; i<L; i++) {
@@ -152,13 +163,13 @@ namespace Psychlops
 			void loop2_()
 			{
 				started = true;
-				double p;
+				double p = 0.0;
 				double like = 1.0;
 				champ_like = 0.0;
 				int L = data.length;
-				for (double a = itvl[0].begin.val; a < itvl[0].end.val; a += step[0])
+				for (double a = itvl[0].begin.value; a < itvl[0].end.value; a += step[0])
 				{
-					for (double b = itvl[1].begin.val; b < itvl[1].end.val; b += step[1])
+					for (double b = itvl[1].begin.value; b < itvl[1].end.value; b += step[1])
 					{
 						like = 1.0;
 						for (int i = 0; i < L; i++)
@@ -170,6 +181,7 @@ namespace Psychlops
 						{
 							champ_like = like;
 							champ[0] = a;
+							champ[1] = b;
 						}
 					}
 				}
@@ -182,11 +194,11 @@ namespace Psychlops
 				double like = 1.0;
 				champ_like = 0.0;
 				int L = data.length;
-				for (double a = itvl[0].begin.val; a < itvl[0].end.val; a += step[0])
+				for (double a = itvl[0].begin.value; a < itvl[0].end.value; a += step[0])
 				{
-					for (double b = itvl[1].begin.val; b < itvl[1].end.val; b += step[1])
+					for (double b = itvl[1].begin.value; b < itvl[1].end.value; b += step[1])
 					{
-						for (double c = itvl[2].begin.val; c < itvl[2].end.val; c += step[2])
+						for (double c = itvl[2].begin.value; c < itvl[2].end.value; c += step[2])
 						{
 							like = 1.0;
 							for (int i = 0; i < L; i++)
@@ -198,6 +210,8 @@ namespace Psychlops
 							{
 								champ_like = like;
 								champ[0] = a;
+								champ[1] = b;
+								champ[1] = c;
 							}
 						}
 					}
@@ -218,8 +232,36 @@ namespace Psychlops
 
 
 
-		class BinomialLikelihood
+		public class BinomialLikelihood
 		{
+			public static void showWindow(Constants.Func1 f)
+			{
+				Main.canvas.api_canvas.Dispatcher.BeginInvoke(new Action<Constants.Func1>(showWindow_), f);
+			}
+			internal static void showWindow_(Constants.Func1 f)
+			{
+				System.Windows.Controls.ChildWindow page = new PsychlopsSilverlight4.Pages.BinomialSolver(f);
+				page.Show();
+			}
+			public static void showWindow(Constants.Func2 f)
+			{
+				Main.canvas.api_canvas.Dispatcher.BeginInvoke(new Action<Constants.Func2>(showWindow_), f);
+			}
+			internal static void showWindow_(Constants.Func2 f)
+			{
+				System.Windows.Controls.ChildWindow page = new PsychlopsSilverlight4.Pages.BinomialSolver(f);
+				page.Show();
+			}
+			public static void showWindow(Constants.Func3 f)
+			{
+				Main.canvas.api_canvas.Dispatcher.BeginInvoke(new Action<Constants.Func3>(showWindow_), f);
+			}
+			internal static void showWindow_(Constants.Func3 f)
+			{
+				System.Windows.Controls.ChildWindow page = new PsychlopsSilverlight4.Pages.BinomialSolver(f);
+				page.Show();
+			}
+
 			public int iteration;
 
 			public Interval[] itvl;
@@ -237,6 +279,9 @@ namespace Psychlops
 
 			public BinomialLikelihood()
 			{
+				itvl = new Interval[CONST.MAX_ARG];
+				step = new double[CONST.MAX_ARG];
+				champ = new double[CONST.MAX_ARG];
 				iteration = 2;
 			}
 
@@ -247,12 +292,10 @@ namespace Psychlops
 				func1 = d_func;
 
 				BinomialLikelihoodThread[] l = new BinomialLikelihoodThread[4];
+				for (int i = 0; i < 4; i++) { l[i] = new BinomialLikelihoodThread(); }
 
-				double r, low, high;
 				for (int k = 0; k < iteration; k++)
 				{
-					champ_like = 0;
-
 					begin_base(l);
 					for (int i = 0; i < 4; i++)
 					{
@@ -261,14 +304,6 @@ namespace Psychlops
 						l[i].loop1();
 					}
 					end_base(l);
-
-					for (int j = 0; j < Constants.LIMIT; j++)
-					{
-						r = itvl[j].end.val - itvl[j].begin.val;
-						low = champ[j] - r / 8.0 < itvl[j].begin.val ? itvl[j].begin.val : champ[j] - r / 8.0;
-						high = champ[j] + r / 8.0 > itvl[j].end.val ? itvl[j].end.val : champ[j] + r / 8.0;
-						itvl[j] = new Interval(low, high);
-					}
 				}
 			}
 			public void begin(Constants.Func2 d_func)
@@ -276,12 +311,10 @@ namespace Psychlops
 				func2 = d_func;
 
 				BinomialLikelihoodThread[] l = new BinomialLikelihoodThread[4];
+				for (int i = 0; i < 4; i++) { l[i] = new BinomialLikelihoodThread(); }
 
-				double r, low, high;
 				for (int k = 0; k < iteration; k++)
 				{
-					champ_like = 0;
-
 					begin_base(l);
 					for (int i = 0; i < 4; i++)
 					{
@@ -290,14 +323,6 @@ namespace Psychlops
 						l[i].loop2();
 					}
 					end_base(l);
-
-					for (int j = 0; j < Constants.LIMIT; j++)
-					{
-						r = itvl[j].end.val - itvl[j].begin.val;
-						low = champ[j] - r / 8.0 < itvl[j].begin.val ? itvl[j].begin.val : champ[j] - r / 8.0;
-						high = champ[j] + r / 8.0 > itvl[j].end.val ? itvl[j].end.val : champ[j] + r / 8.0;
-						itvl[j] = new Interval(low, high);
-					}
 				}
 			}
 			public void begin(Constants.Func3 d_func)
@@ -305,12 +330,10 @@ namespace Psychlops
 				func3 = d_func;
 
 				BinomialLikelihoodThread[] l = new BinomialLikelihoodThread[4];
+				for (int i = 0; i < 4; i++) { l[i] = new BinomialLikelihoodThread(); }
 
-				double r, low, high;
 				for (int k = 0; k < iteration; k++)
 				{
-					champ_like = 0;
-
 					begin_base(l);
 					for(int i=0; i<4; i++) {
 						l[i].data = data;
@@ -318,14 +341,6 @@ namespace Psychlops
 						l[i].loop3();
 					}
 					end_base(l);
-
-					for (int j = 0; j < Constants.LIMIT; j++)
-					{
-						r = itvl[j].end.val - itvl[j].begin.val;
-						low  = champ[j]-r/8.0 < itvl[j].begin.val ? itvl[j].begin.val : champ[j]-r/8.0;
-						high = champ[j]+r/8.0 > itvl[j].end.val   ? itvl[j].end.val   : champ[j]+r/8.0;
-						itvl[j] = new Interval(low, high);
-					}
 				}
 			}
 
@@ -338,16 +353,18 @@ namespace Psychlops
 
 			void begin_base(BinomialLikelihoodThread[] l)
 			{
+				champ_like = 0;
+
 				data.length = data.elems.GetLength(0);
 				for (int i = 0; i < data.elems.GetLength(0); i++)
 				{
 					data.elems[i].comb = (int)Binomial.combination(data.elems[i].pos + data.elems[i].neg, data.elems[i].pos);
 				}
 
-				for (int j = 0; j < Constants.LIMIT; j++) { step[j] = (itvl[j].end.val - itvl[j].begin.val) / 256.0; }
+				for (int j = 0; j < Constants.LIMIT; j++) { step[j] = (itvl[j].end.value - itvl[j].begin.value) / 256.0; }
 				for (int i = 0; i < 4; i++)
 				{
-					l[i].itvl[0] = new Interval((itvl[0].begin.val) + (i * step[0] * 64), (itvl[0].begin.val) + ((i + 1) * step[0] * 64));
+					l[i].itvl[0] = new Interval((itvl[0].begin.value) + (i * step[0] * 64), (itvl[0].begin.value) + ((i + 1) * step[0] * 64));
 					l[i].step[0] = step[0];
 					for (int j = 1; j < Constants.LIMIT; j++)
 					{
@@ -360,12 +377,11 @@ namespace Psychlops
 
 			void end_base(BinomialLikelihoodThread[] l)
 			{
-				for (int i = 0; i < 4; i++)
-				{
-					l[i].th.Join();
-				}
+				//for (int i = 0; i < 4; i++) { l[i].th.Join(); }
+				while (!l[0].finished || !l[1].finished || !l[2].finished || !l[3].finished) { Thread.Sleep(100);  } 
 
 				for(int j=0; j<Constants.LIMIT; j++) { champ[j] = 0; }
+				champ_like = 0.0;
 				for(int i=0; i<4; i++) {
 					if(champ_like < l[i].champ_like) {
 						champ_like = l[i].champ_like;
@@ -373,6 +389,15 @@ namespace Psychlops
 					}
 				}
 
+				double r, low, high;
+				for (int j = 0; j < Constants.LIMIT; j++)
+				{
+					r = itvl[j].end.value - itvl[j].begin.value;
+					low = champ[j] - r / 8.0 < itvl[j].begin.value ? itvl[j].begin.value : champ[j] - r / 8.0;
+					high = champ[j] + r / 8.0 > itvl[j].end.value ? itvl[j].end.value : champ[j] + r / 8.0;
+					itvl[j] = new Interval(low, high);
+				}
+
 			}
 
 
diff --git a/dev4/psychlops/extention/standard/widget.cs b/dev4/psychlops/extention/standard/widget.cs
index 4fe21e7..42e7668 100644
--- a/dev4/psychlops/extention/standard/widget.cs
+++ b/dev4/psychlops/extention/standard/widget.cs
@@ -8,6 +8,7 @@ using System.Windows.Media.Animation;
 using System.Windows.Media.Imaging;
 using System.Windows.Shapes;
 using System.Windows.Browser;
+using System.Windows.Data;
 
 
 
@@ -79,33 +80,107 @@ namespace Psychlops
 			public WidgetRect& pushThis();
 		};
 		*/
+		
 		/*
 		public class Slider
 		{
+			public string label;
 			public Rectangle outer;
+			public Rectangle inner;
+			public Stroke outer_strk;
+
+			public Slider()
+			{
+				set(0, 0);
+			}
+			public Slider(double width, double height)
+			{
+				set(width, height);
+			}
+			public Slider set(double width, double height)
+			{
+				outer = new Rectangle(width, height);
+				outer.fill = Color.gray;
+				inner = new Rectangle();
+				inner.fill = Color.blue;
+				outer_strk = new Stroke();
+				outer_strk.color = Color.white;
+				outer_strk.thick = 1;
+				return this;
+			}
+			public void checkClick()
+			{
+				if (outer.include(Mouse.position))
+				{
+					outer.stroke = outer_strk;
+				}
+			}
 		}
-		*/
+		 */
+
 
 		public class Slider
 		{
+			public static Color bgcolor;
+
 			internal System.Windows.UIElement instance;
 			internal System.Windows.Controls.Slider uislider;
+			internal System.Windows.Controls.TextBlock uilabel;
+			internal System.Windows.Controls.TextBox uibox;
 			internal string label;
 			internal Interval range;
+			internal SelfDelegate get_;
+			internal SelfDelegate set_;
+			internal double retval;
+			internal bool setted_;
 
-			public Slider(string l, Interval r)
+			static Slider()
 			{
+				bgcolor.set(.5,.5, .5, .3);
+			}
+
+			public Slider(string l, Interval r, double initialvalue)
+			{
+				retval = initialvalue;
 				range = r;
 				label = l;
+				setted_ = false;
 				Psychlops.Widgets.Connector.stackSlider(this);
+				get_ = new SelfDelegate(get__);
+				set_ = new SelfDelegate(set__);
+				while (!setted_) { System.Threading.Thread.Sleep(10); }
 			}
 			public static implicit operator double(Slider s)
 			{
 				return s.value;
 			}
-			public double value {
-				get { return uislider.Value; }
-				set { if(uislider!=null) uislider.Dispatcher.BeginInvoke( new Action<System.Windows.Controls.Slider, double>(Connector.sliderSet) , uislider, value ); }
+
+			public delegate void SelfDelegate(System.Windows.Controls.Slider s);
+			public void get__(System.Windows.Controls.Slider s) { retval = s.Value; }
+			public void set__(System.Windows.Controls.Slider s) { s.Value = retval; }
+
+			public double getValue()
+			{
+				if (uislider != null) {
+					uislider.Dispatcher.BeginInvoke(get_, uislider);
+					return retval;
+				} else {
+					return 0;
+				}
+			}
+			public void setValue(double v)
+			{
+				if (uislider != null)
+				{
+					retval = v;
+					uislider.Dispatcher.BeginInvoke(set_, uislider);
+				}
+			}
+
+			public double value
+			{
+				get { return getValue(); }
+				set { setValue(value); }
 			}
 			public bool changed { get; set; }
 		}
@@ -178,13 +253,34 @@ namespace Psychlops
 		}
 
 
-
 		internal static class Connector
 		{
 			internal delegate void VoidString(string s);
 			internal delegate void VoidStringObject(String s, System.Object o);
-			
 
+			public class Double02fFormatter : IValueConverter
+			{
+				public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
+				{
+					string formatString = parameter as string;
+					if (!string.IsNullOrEmpty(formatString))
+					{
+						return string.Format(culture, formatString, value);
+					}
+					return string.Format("{0, -8:F}", value);
+				}
+				public object ConvertBack(object val, Type targetType, object parameter, System.Globalization.CultureInfo culture)
+				{
+					string str = val.ToString();
+					double result;
+					var objCultureInfo = new System.Globalization.CultureInfo("en-US");
+					if (Double.TryParse(str, System.Globalization.NumberStyles.Number, objCultureInfo, out result))
+					{
+						return result;
+					}
+					return val;
+				}
+			}
 
 			delegate void StackSlider_(Slider s);
 			internal static void stackSlider(Slider s)
@@ -193,46 +289,49 @@ namespace Psychlops
 			}
 			static void stackSlider__(Slider ss)
 			{
-				var holder = new System.Windows.Controls.Canvas { Width = 200 };
+				var label = new System.Windows.Controls.TextBlock { Text = ss.label };
+				label.Foreground = Color.white;
+				System.Windows.Controls.Canvas.SetLeft(label, 3);
+				System.Windows.Controls.Canvas.SetTop(label, 3);
+				ss.uilabel = label;
+
+				var holder = new System.Windows.Controls.Canvas { Width = 200, Height = 50 };
 				var val = new System.Windows.Controls.TextBox { Width = 100 };
 				System.Windows.Controls.Canvas.SetLeft(val, 100);
 				var slide = new System.Windows.Controls.Slider {
-						Minimum = ss.range.begin.val, Maximum = ss.range.end.val,
+						Minimum = ss.range.begin.value, Maximum = ss.range.end.value,
 						Name = ss.label,
+						Value = ss.retval,
 						Tag = ss, Width = 200,
 				};
-				System.Windows.Controls.Canvas.SetTop(slide, 25);
+				System.Windows.Controls.Canvas.SetTop(slide, label.ActualHeight - 3);
 				var b = new System.Windows.Data.Binding {
 						Path = new PropertyPath("Value"),
 						Mode = System.Windows.Data.BindingMode.TwoWay,
 						Source = slide,
+						Converter = new Double02fFormatter()
 				};
 				val.SetBinding(TextBox.TextProperty, b);
 				ss.uislider = slide;
-				//var b2 = new System.Windows.Data.Binding
-				//{
-				//	Path = new PropertyPath("value"),
-				//	Mode = System.Windows.Data.BindingMode.TwoWay,
-				//	Source = ss,
-				//};
-				//val.SetBinding(System.Windows.Controls.Slider.ValueProperty, b2);
-				var label = new System.Windows.Controls.TextBlock { Text = ss.label };
-				System.Windows.Controls.Canvas.SetLeft(label, 3);
-				System.Windows.Controls.Canvas.SetTop(label, 3);
+				ss.uibox = val;
+				val.Background = Color.null_color;
+				val.BorderBrush = Color.null_color;
+				val.Foreground = Color.white;
+				val.TextAlignment = TextAlignment.Right;
+
+				holder.Background = Slider.bgcolor;
 
 				holder.Children.Add(label);
-				holder.Children.Add(slide);
 				holder.Children.Add(val);
+				holder.Children.Add(slide);
+				holder.Height = label.ActualHeight + slide.ActualHeight + val.ActualHeight + 15;
 				ss.instance = holder;
 				Internal.Main.widgetStack.Children.Add(ss.instance);
+				ss.setted_ = true;
 			}
-			public static void sliderSet(System.Windows.Controls.Slider s, double v)
-			{
-				s.Value = v;
-			}
-
 		}
 
 	}
 
-}
\ No newline at end of file
+}
+
diff --git a/test4/MainPage.xaml.cs b/test4/MainPage.xaml.cs
index 685c460..a303773 100644
--- a/test4/MainPage.xaml.cs
+++ b/test4/MainPage.xaml.cs
@@ -38,8 +38,18 @@ namespace PsychlopsSilverlight4test
 			//main_routine = main.psychlops_main();
 
 			Psychlops.Internal.Main.statusBar = AppStatusBar;
-			Psychlops.Internal.Main.widgetStack = Controller;
+			//Psychlops.Internal.Main.widgetStack = Controller;
 			AppStatusBar.Text = "Now starting Psychlops environment... please wait a minute";
+
+
+			var ur = new System.Uri("Resources/logo.png", System.UriKind.RelativeOrAbsolute);
+			var bitmap = new System.Windows.Media.Imaging.BitmapImage(ur);
+			var img = new System.Windows.Controls.Image();
+			img.Source = bitmap;
+			System.Windows.Controls.Canvas.SetLeft(img, 100);
+			System.Windows.Controls.Canvas.SetTop(img, 100);
+			LayoutRoot.Children.Add(img);
+
 		}
 		protected void getFocusMouseEnter(object sender, System.Windows.Input.MouseEventArgs e) {
 			this.Focus();
diff --git a/test4/PsychlopsMain.cs b/test4/PsychlopsMain.cs
index e7b6754..f5df20f 100644
--- a/test4/PsychlopsMain.cs
+++ b/test4/PsychlopsMain.cs
@@ -1,4 +1,70 @@
-/*using Psychlops;
+
+using Psychlops;
+
+namespace PsychlopsSilverlight4test
+{
+
+	public class PsychlopsMain
+	{
+
+		Psychlops.Widgets.Slider rect_size;
+		Psychlops.Widgets.Slider rect_lum;
+		Psychlops.Widgets.Slider bg_lum;
+
+
+		void RectLuminance()
+		{
+			Canvas display = new Canvas(Canvas.window);
+			Interval rng = new Interval();
+			rect_size = new Psychlops.Widgets.Slider("Rect Size", 1 < rng < 500, 10.0);
+			rect_lum = new Psychlops.Widgets.Slider("Rect Luminance", 0.0 <= rng <= 1.0, 0.1);
+			bg_lum = new Psychlops.Widgets.Slider("BG Luminance", 0.0 <= rng <= 1.0, 0.1);
+			Ellipse drawee = new Ellipse(100, 100);
+			display.showFPS();
+			display.watchFPS();
+
+			Rectangle rect = new Rectangle(rect_size, rect_size);
+			rect.centering();
+
+
+			Clock before = new Clock(), after = new Clock();
+			while (!Keyboard.esc.pushed())
+			{
+				Display.clear(bg_lum);
+				rect.resize(rect_size, rect_size).draw(rect_lum);
+				after.update();
+				display.var((after - before).at_msec(), 100, 100, Color.green);
+				display.var((after - before).at_msec(), 100, 200, Color.green);
+				drawee.centering().shift(Math.random(100), 0);
+				drawee.draw(Color.black);
+				Display.flip();
+			}
+
+		}
+
+
+		public void psychlops_main()
+		{
+			RectLuminance();
+		}
+
+
+	}
+
+}
+
+
+
+
+
+
+
+
+
+
+
+/*
+ using Psychlops;
 
 namespace PsychlopsSilverlight4test
 {
@@ -14,12 +80,25 @@ namespace PsychlopsSilverlight4test
 		double TargetEcce = 100.0, TargetSize = 5.0, TargetNumber = 5, Rotate = 0.0;
 
 		//Set Background Initial Value
-		double DotNumber = 50, thetaSpeed = 3.0, Axis = 0.0, BGRadii = 150, BGSize = 5.0;
+		double Axis = 0.0, BGRadii = 150, BGSize = 5.0;
+		Psychlops.Widgets.Slider thetaSpeed, DotNumber;
+		Image img;
+
+
 
 		public void psychlops_main()
 		{
 			cnvs = new Canvas(500, 500);
 
+			Psychlops.Solver.BinomialLikelihood.showWindow(Math.cumulativeNormalDistibution);
+
+
+			img = new Image("Resources/logo.png");
+
+			Interval rng = new Interval();
+			thetaSpeed = new Psychlops.Widgets.Slider("Label", -10 <= rng <= 10, 3.0);
+			DotNumber  = new Psychlops.Widgets.Slider("DotNum",   0 <= rng <= 100, 50.0);
+
 			//Declare background dots and target
 			Rectangle[] BGDot = new Rectangle[2048];
 			for(int i=0; i<2048; i++){
@@ -56,11 +135,11 @@ namespace PsychlopsSilverlight4test
 			for(int i=0; i<10; i++)Target[i].set(TargetSize, TargetSize);
 
 			double COS, SIN;
-			DotNumber = 200;
+			//DotNumber = 200;
 			//Main stimulus loop
 			while(true){
 				//Clear the main window
-				cnvs.clear(Color.green);
+				cnvs.clear();
 
 
 				temp=Axis/360*2*Math.PI;
@@ -101,6 +180,11 @@ namespace PsychlopsSilverlight4test
 					Target[i].draw();
 				}
 
+				img.centering(Mouse.position).draw();
+
+				cnvs.var(Mouse.position.x, 100, 100);
+				cnvs.var(Mouse.position.y, 100, 140);
+
 				//Reflect drawing at the next frame;
 				cnvs.flip();
 			}
@@ -110,6 +194,7 @@ namespace PsychlopsSilverlight4test
 }
 */
 
+
 /*using Psychlops;
 
 namespace PsychlopsSilverlight4test
@@ -156,10 +241,10 @@ namespace PsychlopsSilverlight4test
 
 }
 
-*/
 
 
 
+/*
 using Psychlops;
 
 namespace Psychlops
@@ -224,7 +309,7 @@ namespace PsychlopsSilverlight4test
 			shape = poly;
 
 			var rng = new Interval();
-			var slider = new Psychlops.Widgets.Slider("tesrt", 0 <= rng <= 5);
+			var slider = new Psychlops.Widgets.Slider("tesrt", -100 <= rng <= 100);
 
 			dots = new RandomDots();
 
@@ -241,36 +326,37 @@ namespace PsychlopsSilverlight4test
 				{
 					fixation.centering().shift(100, 100);
 					fixation.draw(new Stroke(Color.blue, 3));
-				}*/
+				}* /
 
-				fixation.centering();
+				fixation.centering().shift(slider, 0);
 				fixation.draw(Color.red);
 
 				//Figures.drawGabor(ref img, 20, 100, 1, 0, frames * 2.0 * Math.PI / tfreq / 60);
 				//Figures.drawGaussian(ref img, 20, 1);
 				//Figures.drawGrating(ref img, 200, 200, 20, 1, 2, frames * 2.0 * Math.PI / tfreq / 60);
-				img.centering(Mouse.position);
-				img.draw();
-				//g.centering(Mouse.position).draw();
-				//g.rotation += 1;
+				//img.centering(Mouse.position);
+				//img.draw();
+				g.centering(Mouse.position).draw();
+				g.rotation += 1;
 
 				shape.centering(Mouse.position).shift(100, 0);
 				shape.draw();
 				if (Keyboard.spc.pressed()) cnvs.var(Mouse.x, 100, 100);
 
 				cnvs.var(frames, 0, 20);
-				slider.value = frames / 100.0;
+				//slider.value = frames / 100.0;
 
 				/*if (frames % 2 != 0)
 				{
 					fixation.shift(100, 100);
 					fixation.draw(new Stroke(Color.green, 3));
-				}*/
+				}* /
 
 				for (int i = 0; i < dots.cood.Length; i++)
 				{
 					dots.cood[i].set(Math.random(500), Math.random(500));
 				}
+				cnvs.var((double)slider, 200, 200);
 				dots.draw();
 
 				cnvs.flip();
@@ -279,3 +365,45 @@ namespace PsychlopsSilverlight4test
 	}
 }
 
+**/
+
+
+/*
+
+using Psychlops;
+namespace PsychlopsSilverlight4test
+{
+
+	public class PsychlopsMain
+	{
+		Canvas cnvs;
+		Rectangle[] rect;
+		int n;
+
+		public void psychlops_main()
+		{
+			n = 1;
+			cnvs = new Canvas(500, 500);
+			rect = new Rectangle[n];
+			for (int i = 0; i < n; i++)
+			{
+				rect[i] = new Rectangle(10, 10);
+				rect[i].fill = Color.red;
+			}
+			Interval rng = new Interval();
+			var slider = new Psychlops.Widgets.Slider("Label", -100 <= rng <= 100);
+
+			while (true)
+			{
+				cnvs.clear();
+				for (int i = 0; i < n; i++)
+				{
+					rect[i].centering().shift(slider * i*3, i*3).draw();
+				}
+				cnvs.flip();
+			}
+		}
+	}
+}
+
+*/
\ No newline at end of file
diff --git a/test4/PsychlopsSilverlight4test.csproj b/test4/PsychlopsSilverlight4test.csproj
index 5b49ffc..c6601b6 100644
--- a/test4/PsychlopsSilverlight4test.csproj
+++ b/test4/PsychlopsSilverlight4test.csproj
@@ -70,6 +70,7 @@
     <Reference Include="system" />
     <Reference Include="System.Core" />
     <Reference Include="System.Net" />
+    <Reference Include="System.Windows.Controls, Version=2.0.5.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
     <Reference Include="System.Xml" />
     <Reference Include="System.Windows.Browser" />
   </ItemGroup>
@@ -102,6 +103,7 @@
     <None Include="Properties\AppManifest.xml" />
   </ItemGroup>
   <ItemGroup>
+    <Resource Include="Resources\logo.png" />
     <Content Include="TestPage.html" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Silverlight\$(SilverlightVersion)\Microsoft.Silverlight.CSharp.targets" />
diff --git a/test4/Resources/logo.png b/test4/Resources/logo.png
new file mode 100644
index 0000000..ebdc130
Binary files /dev/null and b/test4/Resources/logo.png differ
diff --git a/test4/TestPage.html b/test4/TestPage.html
index 1bcd588..23aee1f 100644
--- a/test4/TestPage.html
+++ b/test4/TestPage.html
@@ -62,14 +62,14 @@
 
     <form id="form1" runat="server" style="height:60%">
     <div id="silverlightControlHost">
-        <object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="90%" height="80%">
+        <object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
 		  <param name="source" value="Bin/Debug/PsychlopsSilverlight4test.xap"/>
 		  <param name="onError" value="onSilverlightError" />
 		  <param name="background" value="white" />
 		  <param name="minRuntimeVersion" value="3.0.40624.0" />
 		  <param name="autoUpgrade" value="true" />
 		  <param name="enableHtmlAccess" value="true" />
-		  <param name="enableGPUAcceleration" value="true" />
+		  <param name="enableGPUAcceleration" value="false" />
 		  <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40624.0" style="text-decoration:none">
  			  <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Microsoft Silverlight を入手" style="border-style:none"/>
 		  </a>