public static List <string> List(string type)
{
var filename = ExecutableName(type);
var filepath = Executable.Relative(filename);
var pi = new ProcessStartInfo(filepath)
{
Arguments = "--list",
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
RedirectStandardInput = true,
//WorkingDirectory = Path.GetDirectoryName(filepath),
};
var disposer = new Disposer();
using (disposer)
{
var proc = Process.Start(pi);
disposer.Add(proc);
disposer.Add(proc.Kill);
var list = new List <string>();
var line = proc.StandardOutput.ReadLine();
while (line != null)
{
list.Add(line);
line = proc.StandardOutput.ReadLine();
}
return(list);
}
}
private void Loop(ProcessStartInfo pi)
{
while (!disposed)
{
try
{
var first = new Disposer();
using (var disposer = new Disposer())
{
disposer.Add(first);
var proc = Process.Start(pi);
disposer.Add(proc);
disposer.Add(proc.Kill);
var stateTask = Task.Factory.StartNew(() => ReadState(proc), opts);
var errorTask = Task.Factory.StartNew(() => ReadError(proc), opts);
first.Add(stateTask);
first.Add(errorTask);
while (true)
{
if (disposed)
{
break;
}
if (stateTask.IsCompleted && errorTask.IsCompleted)
{
break;
}
Thread.Sleep(10);
}
}
}
catch (Exception ex)
{
state.Enqueue(ex.Message);
error.Enqueue(Readable.Make(pi.FileName));
error.Enqueue(Readable.Make(pi.Arguments));
error.Enqueue(ex.Message);
var millis = 5000;
while (--millis > 0)
{
if (disposed)
{
break;
}
Thread.Sleep(1);
}
}
}
}
public void ExpectDisposes()
{
var dsp1 = new AssertDisposable();
var dsp2 = new AssertDisposable();
var dsp3 = new AssertDisposable();
var toTest = new Disposer();
toTest.Add(dsp1);
toTest.Add(dsp2);
toTest.Add(dsp3);
toTest.Dispose();
dsp1.AssertDisposed();
dsp2.AssertDisposed();
dsp3.AssertDisposed();
}
public void ThrowOnAdd()
{
var toTest = new Disposer();
toTest.Dispose();
Assert.Throws(typeof(ObjectDisposedException), () => toTest.Add(new AssertDisposable()));
}
public void ExpectNoDisposeOnAdd()
{
var dsp1 = new AssertDisposable();
var toTest = new Disposer();
toTest.Add(dsp1);
dsp1.AssertNotDisposed();
}
private static void ClientLoop(int pid, IPEndPoint local, TcpClient client, ProcessStartInfo pi)
{
var first = new Disposer();
using (var disposer = new Disposer(() => { SetState(local, pid); }))
{
disposer.Add(first);
disposer.Add(client);
var remote = client.Client.RemoteEndPoint as IPEndPoint;
SetState(local, pid, remote);
var proc = Process.Start(pi);
disposer.Add(proc);
disposer.Add(proc.Kill);
SetState(local, pid, remote, proc.Id);
var writeTask = Task.Factory.StartNew(() => WriteLine(proc, client), opts);
var readTask = Task.Factory.StartNew(() => ReadLine(proc, client), opts);
var errorTask = Task.Factory.StartNew(() => ReadError(proc, client), opts);
first.Add(writeTask);
first.Add(readTask);
first.Add(errorTask);
while (true)
{
if (writeTask.IsCompleted)
{
break;
}
if (readTask.IsCompleted && errorTask.IsCompleted)
{
break;
}
Thread.Sleep(10);
}
}
}
public void Dispose_Calls_The_Action_Added()
{
var disposer = new Disposer();
bool disposed = false;
disposer.Add(() => { disposed = true; });
disposer.Dispose();
Assert.True(disposed);
}
private void ReadLoop()
{
using (var disposer = new Disposer())
{
disposer.Add(serial);
disposer.Add(() => { input.Enqueue(new byte[] { }); });
var bytes = new byte[4096];
while (true)
{
var count = serial.Read(bytes, 0, bytes.Length);
if (count <= 0)
{
return;
}
var data = new byte[count];
Array.Copy(bytes, data, count);
input.Enqueue(data);
}
}
}
private void AcceptLoop()
{
TcpClient current = null;
Task reader = null;
Task writer = null;
var disposer = new Disposer();
//newer versions have the Active property
disposer.Add(() => { input.Enqueue(new byte[] { }); });
disposer.Add(listener.Stop);
disposer.Add(() => Disposer.Dispose(reader));
disposer.Add(() => Disposer.Dispose(writer));
disposer.Add(() => Disposer.Dispose(current));
using (disposer)
{
while (true)
{
var client = listener.AcceptTcpClient();
Disposer.Dispose(current);
Disposer.Dispose(reader);
Disposer.Dispose(writer);
current = client;
ClearOutput();
var stream = client.GetStream() as Stream;
if ("ssl" == uri.Protocol)
{
var ssl = new SslStream(client.GetStream());
ssl.AuthenticateAsServer(certificate);
stream = ssl;
}
reader = Task.Factory.StartNew(() => ReadLoop(client, stream), TaskCreationOptions.LongRunning);
writer = Task.Factory.StartNew(() => WriteLoop(client, stream), TaskCreationOptions.LongRunning);
}
}
}
protected static void DeferRestoreStateOnLevel(Disposer disposer, DataGridContext dataGridContext)
{
ToggleColumnSortCommand.ThrowIfNull(disposer, "disposer");
ToggleColumnSortCommand.ThrowIfNull(dataGridContext, "dataGridContext");
var parentDataGridContext = dataGridContext.ParentDataGridContext;
// Defer the RestoreState of each DataGridContext of the same level
// to ensure all the DataGridContext will be correctly restored once
// all of them are completely resorted
if (parentDataGridContext != null)
{
foreach (var childContext in parentDataGridContext.GetChildContexts())
{
disposer.Add(childContext.DeferRestoreState(), DisposableType.DeferRestoreState);
}
}
}
private static void AcceptLoop(int pid, TcpListener listener, Func <ProcessStartInfo> pir)
{
var disposer = new Disposer();
disposer.Add(() => Environment.Exit(1));
using (disposer)
{
while (true)
{
try
{
listener.Start();
break;
}
catch (Exception ex)
{
WriteState("Error listening on {0}", listener.LocalEndpoint);
WriteError(ex.Message);
Thread.Sleep(5000);
}
}
var endpoint = listener.LocalEndpoint as IPEndPoint;
SetState(endpoint, pid);
var currentClient = null as TcpClient;
var currentTask = null as Task;
while (true)
{
var accepted = listener.AcceptTcpClient();
Disposer.Dispose(currentClient);
if (currentTask != null)
{
currentTask.Wait();
}
currentClient = accepted;
currentTask = Task.Factory.StartNew(() => SafeClientLoop(pid, endpoint, accepted, pir()), opts);
}
}
}
private void Inject([InjectLocal] CompositeDisposable disposer)
{
Disposer.Add(disposer);
}
public void ThrowOnAdd()
{
var toTest = new Disposer();
toTest.Dispose();
Assert.Throws(typeof(ObjectDisposedException), () => toTest.Add(new AssertDisposable()));
}
public static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Create main disposer
var mainDisposer = new Disposer();
//
var random = new Random(1415926535);
#region demo setup
// show setup dialog and get setup values
var title = "Mash Room by Jolt";
var setupView = new StartupView(title);
var setupModel = new SetupModel();
var presenter = new SetupPresenter(setupView, setupModel);
setupModel.TryLoadSettings();
setupModel.SelectAdapter(0);
var dialogResult = setupView.ShowDialog();
if (dialogResult != DialogResult.OK)
return;
#if DEBUG
setupModel.SaveSettings(); // todo: remove save in release mode
#endif
#endregion
// Create Device and SwapChain
var demo = new Demo().Init(setupModel, title);
var inputHandler = new InputHandler().Bind(demo);
#region audio
//
var audioDeviceType = (setupModel.UseAudio) ? AudioDeviceType.Bass : AudioDeviceType.Silent;
var audioDeviceManager = new AudioDeviceManager();
var audioDevice = mainDisposer.Add(audioDeviceManager.CreateDevice(audioDeviceType));
//
if (setupModel.UseAudio)
{
//
BassNet.Registration(
setupModel.BassRegistrationEmail ?? "",
setupModel.BassRegistrationKey ?? "");
// 140 bpm
// delay 3.428 (dvs 2 takter i 140 bpm)
var bpm = 140;
var audioName = "Mashup_v1.00.mp3";
var audioAsset = mainDisposer.Add(demo.AudioManager[audioName]);
// init and load audio
audioDevice.Init();
audioDevice.Load(audioAsset.Value);
audioDevice.PlayPosition = setupModel.StartTime;
audioDevice.Bpm = bpm;
// use the audio device as timer
demo.Timer = audioDevice;
}
#endregion
#region sync
demo.SyncManager = new SyncManager().Init(setupModel.SyncRecordMode, demo.Timer.Bpm, 4);
demo.SyncManager.TimerDevice = demo.Timer;
#endregion
#region shaders
var planeVertexShader = demo.ShaderManager["plane.vs.cso"].VertexShader;
var planePixelShader = demo.ShaderManager["plane.ps.cso"].PixelShader;
var postPixelShader = demo.ShaderManager["post.ps.cso"].PixelShader;
var postVertexShader = demo.ShaderManager["post.vs.cso"].VertexShader;
var vanillaEffect = mainDisposer.Add(new VanillaEffect(demo).Init());
var vanillaLayout = mainDisposer.Add(vanillaEffect.InputLayout.InputLayout);
#endregion
#region models
// load all models
demo.ModelManager.LoadAll();
// make all models white (todo: why)
foreach (var model in demo.ModelManager)
{
model.Color = new Color(255, 255, 255, 255);
model.ReCreateBuffer(demo.Device);
}
#endregion
#region textures
Texture2D backBuffer = null;
Texture2D depthBuffer = null;
DepthStencilView depthView = null;
// 1D texture for scanline distortion
var distortionTexture = new Texture1D(demo.Device, new Texture1DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8G8B8A8_UNorm,
Usage = ResourceUsage.Default,
Width = 1080,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None
});
var distortionData = new byte[4 * distortionTexture.Description.Width];
var distortionSRV = new ShaderResourceView(demo.Device, distortionTexture);
// foreground texture
var foregroundTexture = new Texture2D(demo.Device, new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8_UNorm,
Usage = ResourceUsage.Default,
Width = 1920,
Height = 1080,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
var foregroundSRV = new ShaderResourceView(demo.Device, foregroundTexture);
var foregroundData = new byte[foregroundTexture.Description.Width * foregroundTexture.Description.Height];
// noise texture
var noiseTexture = new Texture2D(demo.Device, new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R8_UNorm,
Usage = ResourceUsage.Default,
Width = 1920 / 5,
Height = 1080 / 5,
ArraySize = 1,
MipLevels = 1,
BindFlags = BindFlags.ShaderResource,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
});
var noiseSRV = new ShaderResourceView(demo.Device, noiseTexture);
var noiseData = new byte[noiseTexture.Description.Width * noiseTexture.Description.Height];
#endregion
#region acts
var act0 = mainDisposer.Add(new Act0(demo).Init());
#endregion
#region effects
//var fractalCityEffect = mainDisposer.Add(new FractalCityEffect(demo).Init());
//var oceanEffect = mainDisposer.Add(new OceanEffect(demo).Init());
//var dustEffect = mainDisposer.Add(new DustEffect(demo).Init());
//var cloudEffect = mainDisposer.Add(new CloudEffect(demo).Init());
//var mandelbulbEffect = mainDisposer.Add(new MandelbulbEffect(demo).Init());
//var redPlanetEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription
//{
// PixelShaderName = "redPlanet.ps.cso",
// TextureNames = "redPlanet0.png,redPlanet1.jpg".Split(',')
//}));
//var pseudoKleinianEffect = mainDisposer.Add(new Effect(demo).Init(new EffectDescription
//{
// PixelShaderName = "pseudoKleinian.ps.cso",
//}));
//var nonameEffect00 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname00.ps.cso", TextureNames = "tex09.jpg".Split(',') }));
//var nonameEffect01 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname01.ps.cso" }));
//var nonameEffect02 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname02.ps.cso", TextureNames = "tex09.jpg,tex07.jpg".Split(',') }));
//var nonameEffect03 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname03.ps.cso" }));
//var nonameEffect04 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname04.ps.cso", TextureNames = "noise256.png".Split(',') }));
//var nonameEffect05 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname05.ps.cso" }));
//var nonameEffect06 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname06.ps.cso" }));
//var nonameEffect07 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname07.ps.cso" }));
//var nonameEffect08 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname08.ps.cso" }));
//var nonameEffect09 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname09.ps.cso" }));
//var nonameEffect10 = mainDisposer.Add(new Effect(demo).Init(new EffectDescription { PixelShaderName = "noname10.ps.cso" }));
#endregion
var fillStateMsaadesc = RasterizerStateDescription.Default();
fillStateMsaadesc.IsMultisampleEnabled = true;
var msaaFillState = new RasterizerState(demo.Device, fillStateMsaadesc);
var fillState = new RasterizerState(demo.Device, RasterizerStateDescription.Default());
var vanillaRenderContext = null as RenderContext;
var postRenderContext = null as RenderContext;
var planeRenderContext = null as RenderContext;
// Main loop
using (var renderDisposer = new Disposer())
{
RenderLoop.Run(demo.Form, () =>
{
if (demo.SyncManager.RowIndex == 0x000006d0)
{
demo.Form.Close();
return;
}
// TODO refactor: move the resize code
#region resize
if (demo.OutputWasResized)
{
demo.OutputWasResized = false;
renderDisposer.DisposeAll();
// dispose old swapchain
if (demo.SwapChain != null)
{
demo.SwapChain.Dispose();
}
// create new swapchain
demo.SwapChain = renderDisposer.Add(new SwapChain(setupModel.Factory, demo.Device, new SwapChainDescription
{
BufferCount = 1,
ModeDescription = setupModel.Mode,
IsWindowed = !setupModel.FullScreen,
OutputHandle = demo.Form.Handle,
//SampleDescription = new SampleDescription(setupModel.MultiSampleCount, setupModel.MultiSampleQuality),
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
}));
if (setupModel.FullScreen)
{
demo.SwapChain.SetFullscreenState(true, setupModel.Output);
}
//
var postOutputRenderTarget = new RenderTarget(demo.Device, demo.SwapChain);
// Get the backbuffer from the swapchain
backBuffer = renderDisposer.Add(demo.SwapChain.GetBackBuffer<Texture2D>(0));
// Setup targets and viewport for rendering
var postInputRenderTarget = new RenderTarget(
device: demo.Device,
width: setupModel.Mode.Width / 1, // todo: introduce a scalefactor
height: setupModel.Mode.Height / 1, // todo: introduce a scalefactor
sampleCount: 1, // todo: use setupModel.MultiSampleCount,
sampleQuality: 0, // todo: use setupModel.MultiSampleQuality,
format: Format.R8G8B8A8_UNorm // todo: use setupModel.Format
);
// Create the depth buffer
depthBuffer = renderDisposer.Add(new Texture2D(demo.Device, new Texture2DDescription
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = postInputRenderTarget.Width,
Height = postInputRenderTarget.Height,
SampleDescription = postInputRenderTarget.Texture.Description.SampleDescription,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
}));
// Create the depth buffer view
depthView = renderDisposer.Add(new DepthStencilView(demo.Device, depthBuffer));
vanillaRenderContext = renderDisposer.Add(new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = null,
PixelShader = null,
RasterizerState = msaaFillState,
DepthStencilView = depthView,
RenderTarget = postInputRenderTarget,
});
postRenderContext = renderDisposer.Add(new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = postVertexShader,
PixelShader = postPixelShader,
RasterizerState = fillState,
DepthStencilView = null,
RenderTarget = postOutputRenderTarget,
});
planeRenderContext = new RenderContext
{
PrimitiveTopology = PrimitiveTopology.TriangleList,
InputLayout = vanillaLayout,
VertexShader = planeVertexShader,
PixelShader = planePixelShader,
RasterizerState = fillState,
DepthStencilView = null,
RenderTarget = postOutputRenderTarget,
};
// todo: remove this hack
if (!setupModel.SyncRecordMode)
{
demo.Timer.StartPlaying();
}
if (setupModel.FullScreen)
{
Cursor.Hide();
}
}
#endregion
// todo: remove
demo.SyncManager.Update(demo.Timer.Time);
var syncRow = new
{
demo.SyncManager.Data.Part,
demo.SyncManager.Data.Lead,
};
// Present!
// a crash here is quite common when VertexShader or PixelShader is null
demo.SwapChain.Present(setupModel.UseVerticalSync ? 1 : 0, PresentFlags.None);
// horizontal distortion and color separation
random.NextBytes(distortionData);
demo.DeviceContext.UpdateSubresource(distortionData, distortionTexture);
// static noise
random.NextBytes(noiseData);
demo.DeviceContext.UpdateSubresource(noiseData, noiseTexture, 0, noiseTexture.Description.Width);
// setup for normal rendering
{
// use normal rendering
demo.DeviceContext.PixelShader.SetShaderResource(0, null);
demo.RenderContext = vanillaRenderContext;
// clear
demo.DeviceContext.ClearDepthStencilView(demo.RenderContext.DepthStencilView, DepthStencilClearFlags.Depth, 1.0f, 0);
demo.DeviceContext.ClearRenderTargetView(demo.RenderContext.RenderTarget.RenderTargetView, Color.Black);
}
// render act
act0.Render();
//
demo.DeviceContext.ClearRenderTargetView(postRenderContext.RenderTarget.RenderTargetView, Color.Black);
// render plane to screen
if (true)
{
// TODO is this really needed ?
demo.DeviceContext.OutputMerger.ResetTargets();
demo.DeviceContext.VertexShader.SetConstantBuffer(0, null);
// use post rendering
demo.RenderContext = postRenderContext;
// set textures
demo.DeviceContext.PixelShader.SetShaderResource(0, vanillaRenderContext.RenderTarget.ShaderResourceView);
demo.DeviceContext.PixelShader.SetShaderResource(1, distortionSRV);
demo.DeviceContext.PixelShader.SetShaderResource(2, noiseSRV);
// use plane model
var model = demo.ModelManager["plane2"];
// todo: make sure we have no z-buffer conflicts (might be hw dependent)
var camera = new NoCamera();
demo.Draw(model, camera);
}
});
}
// dispose
Disposer.Dispose(ref mainDisposer);
}
private DatabaseContext(IObjectContainer container, DatabaseMetaInfo metaInfo)
{
this.metaInfo = metaInfo;
disposer.Add(container);
theContainer = container;
}
public virtual T AddDisposer(Action <IContainer> disposer)
{
Disposer.Add(disposer);
return(this as T);
}
public static void Run(Options options)
{
//load the image and compute the ratio of the old height
//to the new height, clone it, and resize it
using (var disposer = new Disposer())
{
var image = new Image <Bgr, byte>(options.Image);
disposer.Add(image);
Image <Bgr, byte> orig = image.Clone();
disposer.Add(orig);
double ratio = image.Height / 500.0;
image = ImageUtil.Resize(image, height: 500);
disposer.Add(image);
Image <Gray, byte> gray = image.Convert <Gray, byte>();
disposer.Add(gray);
gray = gray.SmoothGaussian(5);
disposer.Add(gray);
Image <Gray, byte> edged = gray.Canny(75, 200);
disposer.Add(edged);
Console.WriteLine("STEP 1: Edge Detection");
CvInvoke.Imshow("Image", image);
CvInvoke.Imshow("Edged", edged);
CvInvoke.WaitKey();
CvInvoke.DestroyAllWindows();
//find the contours in the edged image, keeping only the
//largest ones, and initialize the screen contour
VectorOfVectorOfPoint cnts = new VectorOfVectorOfPoint();
disposer.Add(cnts);
using (Image <Gray, byte> edgedClone = edged.Clone())
{
CvInvoke.FindContours(edgedClone, cnts, null, RetrType.List, ChainApproxMethod.ChainApproxSimple);
}
Point[] screenCnt = null;
foreach (VectorOfPoint c in
Enumerable.Range(0, cnts.Size).Select(i => cnts[i]).OrderByDescending(c => CvInvoke.ContourArea(c)).Take(5))
{
//approximate the contour
double peri = CvInvoke.ArcLength(c, true);
using (VectorOfPoint approx = new VectorOfPoint())
{
CvInvoke.ApproxPolyDP(c, approx, 0.02 * peri, true);
if (approx.Size == 4)
{
screenCnt = approx.ToArray();
break;
}
}
}
if (screenCnt == null)
{
Console.WriteLine("Failed to find polygon with four points");
return;
}
//show the contour (outline) of the piece of paper
Console.WriteLine("STEP 2: Find contours of paper");
image.Draw(screenCnt, new Bgr(0, 255, 0), 2);
CvInvoke.Imshow("Outline", image);
CvInvoke.WaitKey();
CvInvoke.DestroyAllWindows();
//apply the four point transform to obtain a top-down
//view of the original image
Image <Bgr, byte> warped = FourPointTransform(orig, screenCnt.Select(pt => new PointF((int)(pt.X * ratio), (int)(pt.Y * ratio))));
disposer.Add(warped);
//convert the warped image to grayscale, then threshold it
//to give it that 'black and white' paper effect
Image <Gray, byte> warpedGray = warped.Convert <Gray, byte>();
disposer.Add(warpedGray);
warpedGray = warpedGray.ThresholdAdaptive(new Gray(251), AdaptiveThresholdType.GaussianC, ThresholdType.Binary, 251, new Gray(10));
disposer.Add(warpedGray);
Console.WriteLine("STEP 3: Apply perspective transform");
Image <Bgr, byte> origResized = ImageUtil.Resize(orig, height: 650);
disposer.Add(origResized);
CvInvoke.Imshow("Original", origResized);
Image <Gray, byte> warpedResized = ImageUtil.Resize(warpedGray, height: 650);
disposer.Add(warpedResized);
CvInvoke.Imshow("Scanned", warpedResized);
CvInvoke.WaitKey();
CvInvoke.DestroyAllWindows();
}
}
protected static void DeferRestoreStateOnLevel( Disposer disposer, DataGridContext dataGridContext )
{
ToggleColumnSortCommand.ThrowIfNull( disposer, "disposer" );
ToggleColumnSortCommand.ThrowIfNull( dataGridContext, "dataGridContext" );
var parentDataGridContext = dataGridContext.ParentDataGridContext;
// Defer the RestoreState of each DataGridContext of the same level
// to ensure all the DataGridContext will be correctly restored once
// all of them are completely resorted
if( parentDataGridContext != null )
{
foreach( var childContext in parentDataGridContext.GetChildContexts() )
{
disposer.Add( childContext.DeferRestoreState(), DisposableType.DeferRestoreState );
}
}
}
private bool ToggleColumnSort( ColumnBase column, bool resetSort )
{
ToggleColumnSortCommand.ThrowIfNull( column, "column" );
this.ValidateToggleColumnSort();
using( var synchronizationContext = this.StartSynchronizing( this.GetSortDescriptionsSyncContext() ) )
{
this.ValidateSynchronizationContext( synchronizationContext );
using( var disposer = new Disposer() )
{
this.DeferRestoreStateOnLevel( disposer );
// This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once!
var sortDescriptions = this.SortDescriptions;
disposer.Add( this.DeferResortHelper( sortDescriptions ), DisposableType.DeferResort );
var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection( column.SortDirection );
string columnName = column.FieldName;
int insertionIndex;
if( ( resetSort ) &&
( ( column.SortIndex == -1 ) || ( sortDescriptions.Count > 1 ) ) )
{
insertionIndex = 0;
if( sortDescriptions.Count > 0 )
{
sortDescriptions.Clear();
}
Debug.Assert( sortDescriptions.Count == 0 );
}
else
{
for( insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++ )
{
if( sortDescriptions[ insertionIndex ].PropertyName == columnName )
break;
}
}
if( insertionIndex < sortDescriptions.Count )
{
if( newSortDirection == SortDirection.None )
{
sortDescriptions.RemoveAt( insertionIndex );
}
else
{
sortDescriptions[ insertionIndex ] = new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) );
}
}
else if( newSortDirection != SortDirection.None )
{
sortDescriptions.Add( new SortDescription( columnName, ToggleColumnSortCommand.Convert( newSortDirection ) ) );
}
}
}
return true;
}
public void ExpectNoDisposeOnAdd()
{
var dsp1 = new AssertDisposable();
var toTest = new Disposer();
toTest.Add(dsp1);
dsp1.AssertNotDisposed();
}
public static void Run(Options options)
{
//load the image and compute the ratio of the old height
//to the new height, clone it, and resize it
using (var disposer = new Disposer())
{
Mat image = new Mat(options.Image);
disposer.Add(image);
Mat orig = image.Clone();
disposer.Add(orig);
double ratio = image.Height / 500.0;
image = ImageUtil.Resize(image, height: 500);
disposer.Add(image);
Mat gray = image.CvtColor(ColorConversionCodes.BGR2GRAY);
disposer.Add(gray);
gray = gray.GaussianBlur(new Size(5, 5), 0);
disposer.Add(gray);
Mat edged = gray.Canny(75, 200);
disposer.Add(edged);
Console.WriteLine("STEP 1: Edge Detection");
Cv2.ImShow("Image", image);
Cv2.ImShow("Edged", edged);
Cv2.WaitKey();
Cv2.DestroyAllWindows();
//find the contours in the edged image, keeping only the
//largest ones, and initialize the screen contour
Mat[] cnts;
using (Mat edgedClone = edged.Clone())
{
edgedClone.FindContours(out cnts, new Mat(), RetrievalModes.List, ContourApproximationModes.ApproxSimple);
}
disposer.Add(cnts);
Mat screenCnt = null;
//loop over the contours
foreach (Mat c in cnts.OrderByDescending(c => c.ContourArea()).Take(5))
{
//approximate the contour
double peri = c.ArcLength(true);
using (Mat approx = c.ApproxPolyDP(0.02 * peri, true))
{
//if our approximated contour has four points, then we
//can assume that we have found our screen
if (approx.Rows == 4)
{
screenCnt = approx.Clone();
break;
}
}
}
if (screenCnt == null)
{
Console.WriteLine("Failed to find polygon with four points");
return;
}
disposer.Add(screenCnt);
//show the contour (outline) of the piece of paper
Console.WriteLine("STEP 2: Find contours of paper");
Cv2.DrawContours(image, new[] { screenCnt }, -1, Scalar.FromRgb(0, 255, 0), 2);
Cv2.ImShow("Outline", image);
Cv2.WaitKey();
Cv2.DestroyAllWindows();
//apply the four point transform to obtain a top-down
//view of the original image
Mat warped = FourPointTransform(orig, screenCnt * ratio);
disposer.Add(warped);
//convert the warped image to grayscale, then threshold it
//to give it that 'black and white' paper effect
warped = warped.CvtColor(ColorConversionCodes.BGR2GRAY);
disposer.Add(warped);
Cv2.AdaptiveThreshold(warped, warped, 251, AdaptiveThresholdTypes.GaussianC, ThresholdTypes.Binary, 251, 10);
disposer.Add(warped);
Console.WriteLine("STEP 3: Apply perspective transform");
Mat origResized = ImageUtil.Resize(orig, height: 650);
disposer.Add(origResized);
Cv2.ImShow("Original", origResized);
Mat warpedResized = ImageUtil.Resize(warped, height: 650);
disposer.Add(warpedResized);
Cv2.ImShow("Scanned", warpedResized);
Cv2.WaitKey();
Cv2.DestroyAllWindows();
}
}
private bool ToggleColumnSort(ColumnBase column, bool resetSort)
{
ToggleColumnSortCommand.ThrowIfNull(column, "column");
this.ValidateToggleColumnSort();
using (var synchronizationContext = this.StartSynchronizing(this.GetSortDescriptionsSyncContext()))
{
this.ValidateSynchronizationContext(synchronizationContext);
using (var disposer = new Disposer())
{
this.DeferRestoreStateOnLevel(disposer);
// This will ensure that all DataGridCollectionViews mapped to the SortDescriptions collection will only refresh their sorting once!
var sortDescriptions = this.SortDescriptions;
disposer.Add(this.DeferResortHelper(sortDescriptions), DisposableType.DeferResort);
var newSortDirection = ToggleColumnSortCommand.GetNextSortDirection(column.SortDirection);
string columnName = column.FieldName;
int insertionIndex;
if ((resetSort) &&
((column.SortIndex == -1) || (sortDescriptions.Count > 1)))
{
insertionIndex = 0;
if (sortDescriptions.Count > 0)
{
sortDescriptions.Clear();
}
Debug.Assert(sortDescriptions.Count == 0);
}
else
{
for (insertionIndex = 0; insertionIndex < sortDescriptions.Count; insertionIndex++)
{
if (sortDescriptions[insertionIndex].PropertyName == columnName)
{
break;
}
}
}
if (insertionIndex < sortDescriptions.Count)
{
if (newSortDirection == SortDirection.None)
{
sortDescriptions.RemoveAt(insertionIndex);
}
else
{
sortDescriptions[insertionIndex] = new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection));
}
}
else if (newSortDirection != SortDirection.None)
{
sortDescriptions.Add(new SortDescription(columnName, ToggleColumnSortCommand.Convert(newSortDirection)));
}
}
}
return(true);
}
public static Mat ColorTransfer(Mat source, Mat target)
{
using (var disposer = new Disposer())
{
//convert the images from the RGB to L*ab* color space, being
//sure to utilizing the floating point data type (note: OpenCV
//expects floats to be 32-bit, so use that instead of 64-bit)
source = source.CvtColor(ColorConversionCodes.BGR2Lab);
disposer.Add(source);
target = target.CvtColor(ColorConversionCodes.BGR2Lab);
disposer.Add(target);
//compute color statistics for the source and target images
var sourceStats = ImageStats(source);
double lMeanSrc = sourceStats.Item1,
lStdSrc = sourceStats.Item2,
aMeanSrc = sourceStats.Item3,
aStdSrc = sourceStats.Item4,
bMeanSrc = sourceStats.Item5,
bStdSrc = sourceStats.Item6;
var targetStates = ImageStats(target);
double lMeanTar = targetStates.Item1,
lStdTar = targetStates.Item2,
aMeanTar = targetStates.Item3,
aStdTar = targetStates.Item4,
bMeanTar = targetStates.Item5,
bStdTar = targetStates.Item6;
//subtract the means from the target image
Mat[] targetChannels = target.Split();
disposer.Add(targetChannels);
Mat l = targetChannels[0] - lMeanTar;
Mat a = targetChannels[1] - aMeanTar;
Mat b = targetChannels[2] - bMeanTar;
//scale by the standard deviations
l = lStdTar / lStdSrc * l;
a = aStdTar / aStdSrc * a;
b = bStdTar / bStdSrc * b;
//add in the source mean
l += lMeanSrc;
a += aMeanSrc;
b += bMeanSrc;
//clip the pixel intensities to [0, 255] if they fall outside
//this range
//NB: in the original code the values of l, a, and b are cliped to ensure they fall within the expected range.
//This is not needed here as it is handled by the color space conversion.
//merge the channels together and convert back to the RGB color
//space, being sure to utilize the 8-bit unsigned integer data
//type
Mat transfer = new Mat();
disposer.Add(transfer);
Cv2.Merge(new[] { l, a, b }, transfer);
transfer = transfer.CvtColor(ColorConversionCodes.Lab2BGR);
return(transfer);
}
}
/****************************************************************************************************
*
****************************************************************************************************/
public RenderContext()
{
_disposer = new Disposer();
ShaderEnvironment = _disposer.Add(new ShaderEnvironment());
}
public static void Run(Options options)
{
//In order to playback video opencv_ffmpeg*.dll must be found.
string includePath = Environment.Is64BitProcess ? @".\dll\x64" : @".\dll\x86";
foreach (string file in Directory.EnumerateFiles(includePath, "*.dll"))
{
File.Copy(file, Path.GetFileName(file), true);
}
//define the upper and lower boundaries of the HSV pixel
//intensities to be considered 'skin'
var lower = new Scalar(0, 48, 80);
var upper = new Scalar(20, 255, 255);
//if a video path was not supplied, grab the reference
//to the gray
//otherwise, load the video
VideoCapture camera = string.IsNullOrEmpty(options.Video)
? VideoCapture.FromCamera(CaptureDevice.Any)
: new VideoCapture(Path.GetFullPath(options.Video));
if (!camera.IsOpened())
{
Console.WriteLine("Failed to initialize video");
return;
}
using (camera)
{
//keep looping over the frames in the video
while (true)
{
//grab the current frame
using (var frame = new Mat())
using (var disposer = new Disposer())
{
bool grabbed = camera.Read(frame);
//if we are viewing a video and we did not grab a
//frame, then we have reached the end of the video
if (!grabbed || frame.Width == 0 || frame.Height == 0)
{
if (!string.IsNullOrEmpty(options.Video))
{
break;
}
continue;
}
//resize the frame, convert it to the HSV color space,
//and determine the HSV pixel intensities that fall into
//the speicifed upper and lower boundaries
Mat resizedFrame = ImageUtil.Resize(frame, width: 400);
disposer.Add(resizedFrame);
Mat converted = resizedFrame.CvtColor(ColorConversionCodes.BGR2HSV);
disposer.Add(converted);
Mat skinMask = new Mat();
disposer.Add(skinMask);
Cv2.InRange(converted, lower, upper, skinMask);
//apply a series of erosions and dilations to the mask
//using an elliptical kernel
using (Mat kernel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(11, 11)))
{
skinMask = skinMask.Erode(kernel, iterations: 2);
disposer.Add(skinMask);
skinMask = skinMask.Dilate(kernel, iterations: 2);
disposer.Add(skinMask);
}
//blur the mask to help remove noise, then apply the
//mask to the frame
skinMask = skinMask.GaussianBlur(new Size(3, 3), 0);
disposer.Add(skinMask);
Mat skin = new Mat();
disposer.Add(skin);
Cv2.BitwiseAnd(resizedFrame, resizedFrame, skin, skinMask);
//show the skin in the image along with the mask
Cv2.ImShow("images", resizedFrame);
Cv2.ImShow("mask", skin);
//if the 'q' key is pressed, stop the loop
if ((Cv2.WaitKey(1) & 0xff) == 'q')
{
break;
}
}
}
}
Cv2.DestroyAllWindows();
}
/****************************************************************************************************
*
****************************************************************************************************/
public Demo()
{
_disposer = new Disposer();
RenderHandle = _disposer.Add(new AutoResetEvent(false));
}
private IDisposable DeferResortHelper( DetailConfiguration detailConfiguration )
{
ColumnSortCommand.ThrowIfNull( detailConfiguration, "detailConfiguration" );
IDisposable defer;
if( this.TryDeferResort( detailConfiguration, out defer ) )
return defer;
var disposer = new Disposer();
foreach( var dataGridContext in DetailConfigurationUpdateColumnSortCommand.GetDataGridContexts( detailConfiguration ) )
{
disposer.Add( this.DeferResortHelper( dataGridContext.ItemsSourceCollection, dataGridContext.Items ), DisposableType.DeferResort );
}
return disposer;
}
public void ExpectDisposes()
{
var dsp1 = new AssertDisposable();
var dsp2 = new AssertDisposable();
var dsp3 = new AssertDisposable();
var toTest = new Disposer();
toTest.Add(dsp1);
toTest.Add(dsp2);
toTest.Add(dsp3);
toTest.Dispose();
dsp1.AssertDisposed();
dsp2.AssertDisposed();
dsp3.AssertDisposed();
}
