public async Task Render_SimpleBitmap_WithTransparency() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.LightGray)) using (StandardBitmapResource bitmap = new StandardBitmapResource(new AssemblyResourceLink(this.GetType(), "Ressources.Bitmaps.Logo.png"))) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.FillRectangle(graphics.ScreenBounds, solidBrush); graphics.DrawBitmap(bitmap, new Vector2(100f, 100f)); }); //await AsyncResourceLoader.Current.WaitForAllFinishedAsync(); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleBitmap_Transparency); Assert.True(diff < 0.02, "Difference to reference image is to big!"); } }
public async Task Render_SimpleRoundedRect_Filled_Solid() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.Gray)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.FillRoundedRectangle( new RectangleF(10, 10, 512, 512), 30, 30, solidBrush); }); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleRoundedRectFilled); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } }
public async Task Render_SimpleGeometry_Ellipse() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.LightGray)) using (SolidBrushResource solidBrushBorder = new SolidBrushResource(Color4.Gray)) using (EllipseGeometryResource ellipseGeometry = new EllipseGeometryResource(new Vector2(512, 512), 400f, 300f)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.DrawGeometry(ellipseGeometry, solidBrushBorder, 3f); graphics.FillGeometry(ellipseGeometry, solidBrush); }); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleGeometry2D_Ellipse); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } }
public async Task ReadSimple_WmvVideo_Seek() { await UnitTestHelper.InitializeWithGrahicsAsync(); ResourceLink videoLink = new AssemblyResourceLink( this.GetType().Assembly, "SeeingSharp.Tests.Rendering.Ressources.Videos", "DummyVideo.wmv"); GDI.Bitmap bitmapFrame = null; using (FrameByFrameVideoReader videoReader = new FrameByFrameVideoReader(videoLink)) using (MemoryMappedTexture32bpp actFrameBuffer = new MemoryMappedTexture32bpp(videoReader.FrameSize)) { videoReader.SetCurrentPosition(TimeSpan.FromSeconds(2.0)); videoReader.ReadFrame(actFrameBuffer); actFrameBuffer.SetAllAlphaValuesToOne_ARGB(); using (bitmapFrame = GraphicsHelper.LoadBitmapFromMappedTexture(actFrameBuffer)) { Assert.NotNull(bitmapFrame); Assert.True(videoReader.CurrentPosition > TimeSpan.FromSeconds(1.9)); Assert.True(videoReader.CurrentPosition < TimeSpan.FromSeconds(2.1)); Assert.True(videoReader.Duration > TimeSpan.FromSeconds(3.9)); Assert.True(videoReader.Duration < TimeSpan.FromSeconds(4.1)); Assert.True(videoReader.IsSeekable); Assert.True( BitmapComparison.IsNearEqual(bitmapFrame, Properties.Resources.ReferenceImage_VideoFrameWmv_Seek)); } } }
public async Task Render_SimpleText_SimpleSingleColor() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.RedColor)) using (TextFormatResource textFormat = new TextFormatResource("Arial", 70)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.DrawText( string.Format("Just a dummy text ;){0}Just a dummy text ;)", Environment.NewLine), textFormat, new RectangleF(10, 10, 512, 512), solidBrush); }); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleText_SingleColor); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } }
public async Task Render_Skybox() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(-3f, -3f, -7f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { // Create pallet geometry resource PalletType pType = new PalletType(); pType.ContentColor = Color4.Transparent; var resPalletGeometry = manipulator.AddResource <GeometryResource>( () => new GeometryResource(pType)); // Create pallet object GenericObject palletObject = manipulator.AddGeneric(resPalletGeometry); palletObject.Color = Color4.GreenColor; palletObject.EnableShaderGeneratedBorder(); palletObject.BuildAnimationSequence() .RotateEulerAnglesTo(new Vector3(0f, EngineMath.RAD_180DEG, 0f), TimeSpan.FromSeconds(2.0)) .WaitFinished() .RotateEulerAnglesTo(new Vector3(0f, EngineMath.RAD_360DEG, 0f), TimeSpan.FromSeconds(2.0)) .WaitFinished() .CallAction(() => palletObject.RotationEuler = Vector3.Zero) .ApplyAndRewind(); var resSkyboxTexture = manipulator.AddTexture(new Uri("/SeeingSharp.Tests.Rendering;component/Ressources/Textures/Skybox.dds", UriKind.Relative)); // Create the skybox on a new layer manipulator.AddLayer("Skybox"); SkyboxObject skyboxObject = new SkyboxObject(resSkyboxTexture); manipulator.Add(skyboxObject, "Skybox"); }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_Skybox); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task Render_SimpleRoundedRect_Filled_Over3D() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.Gray.ChangeAlphaTo(0.5f))) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -5f); camera.Target = new Vector3(0f, 1f, 0f); camera.UpdateCamera(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { // Define object NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(new PalletStackType( NamedOrGenericKey.Empty, 10))); var newObject = manipulator.AddGeneric(geoResource); newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f); newObject.Scaling = new Vector3(2f, 2f, 2f); newObject.Color = Color4.Goldenrod; newObject.EnableShaderGeneratedBorder(); }); // Define 2D overlay await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.FillRoundedRectangle( new RectangleF(10, 10, 512, 512), 30, 30, solidBrush); }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_RoundedRectOver3D); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task Postprocessing_EdgeDetect() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -7f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { var keyPostprocess = manipulator.AddResource <EdgeDetectPostprocessEffectResource>( () => new EdgeDetectPostprocessEffectResource() { Thickness = 10f }); SceneLayer defaultLayer = manipulator.GetLayer(Scene.DEFAULT_LAYER_NAME); defaultLayer.PostprocessEffectKey = keyPostprocess; NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(new PalletType())); GenericObject newObject = manipulator.AddGeneric(geoResource); newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f); newObject.Scaling = new Vector3(2f, 2f, 2f); newObject.Color = Color4.RedColor; }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_PostProcess_EdgeDetect); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task Render3D_VideoTexture() { await UnitTestHelper.InitializeWithGrahicsAsync(); ResourceLink videoLink = new AssemblyResourceLink( this.GetType().Assembly, "SeeingSharp.Tests.Rendering.Ressources.Videos", "DummyVideo.mp4"); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -7f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { var resVideoTexture = manipulator.AddResource <VideoThumbnailTextureResource>( () => new VideoThumbnailTextureResource(videoLink, TimeSpan.FromMilliseconds(300.0))); var resVideoMaterial = manipulator.AddSimpleColoredMaterial(resVideoTexture, addToAlpha: 1f); var geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(new PalletType( palletMaterial: NamedOrGenericKey.Empty, contentMaterial: resVideoMaterial))); GenericObject newObject = manipulator.AddGeneric(geoResource); newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f); newObject.Scaling = new Vector3(2f, 2f, 2f); }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_SimpleObject_VideoTexture); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task MemoryRenderTarget_2DFallbackRendering() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (GraphicsCore.AutomatedTest_NewTestEnviornment()) { GraphicsCore.Initialize( enableDebug: false, force2DFallback: true); Assert.True(GraphicsCore.IsInitialized); Polygon2D polygon = new Polygon2D(new Vector2[] { new Vector2(10, 10), new Vector2(900, 100), new Vector2(800, 924), new Vector2(50, 1014), new Vector2(10, 10) }); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.LightGray)) using (SolidBrushResource solidBrushBorder = new SolidBrushResource(Color4.Gray)) using (PolygonGeometryResource polygonGeometry = new PolygonGeometryResource(polygon)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.DrawGeometry(polygonGeometry, solidBrushBorder, 3f); graphics.FillGeometry(polygonGeometry, solidBrush); }); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleGeometry2D); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } } }
public async Task Render_SimpleLine() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -7f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { WireObject wireObject = new WireObject(); wireObject.LineData = new Line[] { new Line( new Vector3(-0.5f, 0f, -0.5f), new Vector3(0.5f, 0f, -0.5f)), new Line( new Vector3(0.5f, 0f, -0.5f), new Vector3(0.5f, 0f, 0.5f)), new Line( new Vector3(0.5f, 0f, 0.5f), new Vector3(-0.5f, 0f, 0.5f)), new Line( new Vector3(-0.5f, 0f, 0.5f), new Vector3(-0.5f, 0f, -0.5f)), }; wireObject.LineColor = Color4.RedColor; manipulator.Add(wireObject); }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub"); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_SimpleLine); Assert.True(isNearEqual, "Difference to reference image is to big!"); } }
public async Task Render_SimpleObject_StackedGeometry() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -7f); camera.Target = new Vector3(0f, 1f, 0f); camera.UpdateCamera(); await memRenderTarget.AwaitRenderAsync(); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { PalletType palType = new PalletType(); palType.ContentHeight = 0f; StackedObjectType stackedType = new StackedObjectType(palType, 10); NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(stackedType)); GenericObject newObject = manipulator.AddGeneric(geoResource); newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f); newObject.Scaling = new Vector3(2f, 2f, 2f); newObject.TrySetInitialVisibility(memRenderTarget.RenderLoop.ViewInformation, true); }); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_SimpleObject_StackedGeometry); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task LoadAndRender_ACTexturedObject() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(-1f, 1f, -1f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // Define scene SceneObject newObject = null; await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { NamedOrGenericKey geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(ACFileLoader.ImportObjectType(new AssemblyResourceLink( Assembly.GetExecutingAssembly(), "SeeingSharp.Tests.Rendering.Ressources.Models", "ModelTextured.ac")))); newObject = manipulator.AddGeneric(geoResource); }); await memRenderTarget.Scene.WaitUntilVisibleAsync(newObject, memRenderTarget.RenderLoop); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop(TEST_DUMMY_FILE_NAME); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_TexturedObject); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task Render_SimpleBitmap_Animated() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (StandardBitmapResource bitmap = new StandardBitmapResource( new AssemblyResourceLink(this.GetType(), "Ressources.Bitmaps.Boom.png"), frameCountX: 8, frameCountY: 8)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here for (int loop = 0; loop < 8; loop++) { graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 10f), frameIndex: 7); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 100f), frameIndex: 15); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 200f), frameIndex: 23); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 300f), frameIndex: 31); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 400f), frameIndex: 39); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 500f), frameIndex: 47); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 600f), frameIndex: 55); graphics.DrawBitmap(bitmap, new Vector2(100f * loop, 700f), frameIndex: 63); } }); //await AsyncResourceLoader.Current.WaitForAllFinishedAsync(); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleBitmap_Animated); Assert.True(diff < 0.02, "Difference to reference image is to big!"); } }
public async Task Render_SimpleRoundedRect_Filled_RadialGradient() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (RadialGradientBrushResource radialGradientBrush = new RadialGradientBrushResource( new Vector2(200f, 400f), new Vector2(0f, 0f), 200f, 400f, new GradientStop[] { new GradientStop(Color4.Gray, 0f), new GradientStop(Color4.White, 0.6f), new GradientStop(Color4.BlueColor, 1f) }, extendMode: ExtendMode.Clamp)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync((graphics) => { // 2D rendering is made here graphics.FillRoundedRectangle( new RectangleF(10, 10, 900, 900), 30, 30, radialGradientBrush); }); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); // screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_SimpleRoundedRectFilled_RadialGradient); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } }
public async Task ImportAndRender_ACShadedObject() { await UnitTestHelper.InitializeWithGrahicsAsync(); IEnumerable <SceneObject> importedObjects = null; using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(-1.5f, 3f, -1.5f); camera.Target = new Vector3(1f, 0f, 1f); camera.UpdateCamera(); ResourceLink objSource = new AssemblyResourceLink( typeof(ModelLoadingAndRenderingTests), "Ressources.Models.ModelShaded.ac"); importedObjects = await memRenderTarget.Scene.ImportAsync(objSource); // Wait until ac file is completely loaded await memRenderTarget.Scene.WaitUntilVisibleAsync(importedObjects, memRenderTarget.RenderLoop); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop(TEST_DUMMY_FILE_NAME); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_ShadedObject); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); Assert.NotNull(importedObjects); Assert.True(importedObjects.Count() == 1); }
public async Task Render_ClearedScreen() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_ClearedScreen); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task ReadSimple_WmvVideo() { await UnitTestHelper.InitializeWithGrahicsAsync(); ResourceLink videoLink = new AssemblyResourceLink( this.GetType().Assembly, "SeeingSharp.Tests.Rendering.Ressources.Videos", "DummyVideo.wmv"); GDI.Bitmap bitmapFrame10 = null; using (FrameByFrameVideoReader videoReader = new FrameByFrameVideoReader(videoLink)) using (MemoryMappedTexture32bpp actFrameBuffer = new MemoryMappedTexture32bpp(videoReader.FrameSize)) { int frameIndex = 0; while (!videoReader.EndReached) { if (videoReader.ReadFrame(actFrameBuffer)) { actFrameBuffer.SetAllAlphaValuesToOne_ARGB(); frameIndex++; if (frameIndex != 10) { continue; } bitmapFrame10 = GraphicsHelper.LoadBitmapFromMappedTexture(actFrameBuffer); break; } } Assert.NotNull(bitmapFrame10); Assert.True(videoReader.Duration > TimeSpan.FromSeconds(3.9)); Assert.True(videoReader.Duration < TimeSpan.FromSeconds(4.1)); Assert.True(videoReader.IsSeekable); Assert.True( BitmapComparison.IsNearEqual(bitmapFrame10, Properties.Resources.ReferenceImage_VideoFrameWmv)); } }
public async Task LoadAndRender_StlFile() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(-4f, 4f, -4f); camera.Target = new Vector3(2f, 0f, 2f); camera.UpdateCamera(); // Import Fox model StlImportOptions importOptions = new StlImportOptions(); importOptions.ResourceCoordinateSystem = CoordinateSystem.LeftHanded_UpZ; IEnumerable <SceneObject> loadedObjects = await memRenderTarget.Scene.ImportAsync( new AssemblyResourceLink( typeof(ModelLoadingAndRenderingTests), "Ressources.Models.Fox.stl"), importOptions); // Wait for it to be visible await memRenderTarget.Scene.WaitUntilVisibleAsync(loadedObjects, memRenderTarget.RenderLoop); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); // Calculate and check difference bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_ModelStl); Assert.True(isNearEqual, "Difference to reference image is to big!"); } // Finishing checks Assert.True(GraphicsCore.Current.MainLoop.RegisteredRenderLoopCount == 0, "RenderLoops where not disposed correctly!"); }
public async Task Render_DebugLayer() { await UnitTestHelper.InitializeWithGrahicsAsync(); using (DebugDrawingLayer debugLayer = new DebugDrawingLayer()) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { // Perform rendering memRenderTarget.ClearColor = Color4.CornflowerBlue; await memRenderTarget.RenderLoop.Register2DDrawingLayerAsync(debugLayer); await memRenderTarget.AwaitRenderAsync(); // Take screenshot GDI.Bitmap screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); // Calculate and check difference float diff = BitmapComparison.CalculatePercentageDifference( screenshot, Properties.Resources.ReferenceImage_DebugDawingLayer); Assert.True(diff < 0.2, "Difference to reference image is to big!"); } }
public async Task MemoryRenderTarget_2DInitError() { await UnitTestHelper.InitializeWithGrahicsAsync(); GDI.Bitmap screenshot = null; using (UnitTestHelper.FailTestOnInternalExceptions()) using (GraphicsCore.AutomatedTest_NewTestEnviornment()) using (GraphicsCore.AutomatedTest_ForceD2DInitError()) { GraphicsCore.Initialize(); Assert.True(GraphicsCore.IsInitialized); Assert.False(GraphicsCore.Current.DefaultDevice.Supports2D); using (SolidBrushResource solidBrush = new SolidBrushResource(Color4.Gray)) using (TextFormatResource textFormat = new TextFormatResource("Arial", 36)) using (SolidBrushResource textBrush = new SolidBrushResource(Color4.RedColor)) using (MemoryRenderTarget memRenderTarget = new MemoryRenderTarget(1024, 1024)) { memRenderTarget.ClearColor = Color4.CornflowerBlue; // Get and configure the camera PerspectiveCamera3D camera = memRenderTarget.Camera as PerspectiveCamera3D; camera.Position = new Vector3(0f, 5f, -7f); camera.Target = new Vector3(0f, 0f, 0f); camera.UpdateCamera(); // 2D rendering is made here Custom2DDrawingLayer d2dDrawingLayer = new Custom2DDrawingLayer((graphics) => { RectangleF d2dRectangle = new RectangleF(10, 10, 236, 236); graphics.Clear(Color4.LightBlue); graphics.FillRoundedRectangle( d2dRectangle, 30, 30, solidBrush); d2dRectangle.Inflate(-10, -10); graphics.DrawText("Hello Direct2D!", textFormat, d2dRectangle, textBrush); }); // Define scene await memRenderTarget.Scene.ManipulateSceneAsync((manipulator) => { var resD2DTexture = manipulator.AddResource <Direct2DTextureResource>( () => new Direct2DTextureResource(d2dDrawingLayer, 256, 256)); var resD2DMaterial = manipulator.AddSimpleColoredMaterial(resD2DTexture); var geoResource = manipulator.AddResource <GeometryResource>( () => new GeometryResource(new PalletType( palletMaterial: NamedOrGenericKey.Empty, contentMaterial: resD2DMaterial))); GenericObject newObject = manipulator.AddGeneric(geoResource); newObject.RotationEuler = new Vector3(0f, EngineMath.RAD_90DEG / 2f, 0f); newObject.Scaling = new Vector3(2f, 2f, 2f); }); // Take screenshot await memRenderTarget.AwaitRenderAsync(); screenshot = await memRenderTarget.RenderLoop.GetScreenshotGdiAsync(); //screenshot.DumpToDesktop("Blub.png"); } } // Calculate and check difference Assert.NotNull(screenshot); bool isNearEqual = BitmapComparison.IsNearEqual( screenshot, Properties.Resources.ReferenceImage_SimpleObject); Assert.True(isNearEqual, "Difference to reference image is to big!"); }
private byte[] CreateImage() { if (_tile.PresentationImage == null) { DisposeSurface(); } if (Surface == null) { return(null); } if (_refreshingClient) { return(GetCurrentTileBitmap()); } IImageSopProvider sop = _tile.PresentationImage as IImageSopProvider; if (sop != null) { //TODO (CR May 2010): sops are shared between users and threads. This will be an issue //for dynamic quality changes. DicomAttribute attrib = sop.ImageSop[DicomTags.LossyImageCompression]; DicomAttribute ratioAttrib = sop.ImageSop[DicomTags.LossyImageCompressionRatio]; bool lossy = false; if (_mimeType.Equals("image/jpeg")) { lossy = true; } if (lossy) { attrib.SetStringValue("01"); } else { if (ratioAttrib.IsEmpty) { attrib.SetEmptyValue(); } } } WebViewStudyStatistics stats = new WebViewStudyStatistics(_mimeType); //long t0 = Environment.TickCount; stats.DrawToBitmapTime.Start(); Bitmap bitmap = Bitmap; using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(bitmap)) { Surface.ContextID = graphics.GetHdc(); Surface.ClipRectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height); DrawArgs drawArgs = new DrawArgs(Surface, null, Rendering.DrawMode.Render); CurrentImage.Draw(drawArgs); drawArgs = new DrawArgs(Surface, null, Rendering.DrawMode.Refresh); CurrentImage.Draw(drawArgs); graphics.ReleaseHdc(Surface.ContextID); } stats.DrawToBitmapTime.End(); Bitmap bmp1 = null; if (DiagnosticsSettings.Default.CompareImageQuality) { // make a copy in case Bitmap.Save() has any side effects. bmp1 = (Bitmap)Bitmap.Clone(); } //TODO (CR May 2010): should be in using and/or closed. Separate function? MemoryStream ms = new MemoryStream(); _quality = _defaultJpegQFactor; if (_isMouseDown && IsDynamicImageQualityEnabled) { _quality = GetOptimalQFactor(Bitmap.Width, Bitmap.Height, sop); InitOrUpdateRefreshClientTimer(); } stats.SaveTime.Start(); if (_mimeType.Equals("image/jpeg")) { EncoderParameters eps = new EncoderParameters(1); eps.Param[0] = new EncoderParameter(Encoder.Quality, _quality); ImageCodecInfo ici = GetEncoderInfo(_mimeType); bitmap.Save(ms, ici, eps); } else if (_mimeType.Equals("image/png")) { bitmap.Save(ms, ImageFormat.Png); } stats.SaveTime.End(); byte[] imageBuffer = ms.ToArray(); if (Platform.IsLogLevelEnabled(LogLevel.Debug)) { Platform.Log(LogLevel.Debug, "Render Frame #{0}. Size= {1}bytes. Q={2} {3}. Highbit={4}", sop.ImageSop.InstanceNumber, imageBuffer.Length, _quality, _isMouseDown && IsDynamicImageQualityEnabled ? "[Dynamic]" : "", sop.Frame.HighBit); } ms.Position = 0; stats.ImageSize = (ulong)imageBuffer.LongLength; _stats.AddSubStats(stats); //StatisticsLogger.Log(LogLevel.Info, false, stats); if (_stats.SubStatistics.Count > 20) { _stats.CalculateAverage(); //StatisticsLogger.Log(LogLevel.Info, false, _stats); _stats = new StatisticsSet("AverageRender"); } //Console.WriteLine("Tile {0} : DrawToBitmap (size: {3}, mime: {2}):{1}ms", tile.Identifier,Environment.TickCount - t0,mimeType, ms.Length); //TODO (CR May 2010): #if DEBUG? if (DiagnosticsSettings.Default.CompareImageQuality) { Bitmap bmp2 = new Bitmap(ms); ImageComparisonResult result = BitmapComparison.Compare(ref bmp1, ref bmp2); //TODO (CR May 2010): ConsoleHelper Console.WriteLine("BMP vs {0} w/ client size: {1}x{2}", _mimeType, bmp2.Height, bmp2.Width); Console.WriteLine("\tR: MinError={2:0.00} MaxError={3:0.00} Mean={0:0.00} STD={1:0.00}", result.Channels[0].MeanError, result.Channels[0].StdDeviation, Math.Abs(result.Channels[0].MinError), Math.Abs(result.Channels[0].MaxError)); Console.WriteLine("\tG: MinError={2:0.00} MaxError={3:0.00} Mean={0:0.00} STD={1:0.00}", result.Channels[1].MeanError, result.Channels[1].StdDeviation, Math.Abs(result.Channels[1].MinError), Math.Abs(result.Channels[1].MaxError)); Console.WriteLine("\tB: MinError={2:0.00} MaxError={3:0.00} Mean={0:0.00} STD={1:0.00}", result.Channels[2].MeanError, result.Channels[2].StdDeviation, Math.Abs(result.Channels[2].MinError), Math.Abs(result.Channels[2].MaxError)); } return(imageBuffer); }