private static Direct2D.Bitmap LoadFromFile(string filename, Direct2D.RenderTarget Direct2DTarget)
{
var factory = new WIC.ImagingFactory();
// Decode image
var decoder = new WIC.BitmapDecoder(factory, filename, WIC.DecodeOptions.CacheOnLoad);
var frameDecode = decoder.GetFrame(0);
var source = new WIC.BitmapSource(frameDecode.NativePointer);
var fc = new WIC.FormatConverter(factory);
fc.Initialize(
source,
SharpDX.WIC.PixelFormat.Format32bppPBGRA,
SharpDX.WIC.BitmapDitherType.None,
null,
0.0f,
SharpDX.WIC.BitmapPaletteType.Custom
);
double dpX = 96.0f;
double dpY = 96.0f;
fc.GetResolution(out dpX, out dpY);
Direct2D.BitmapProperties props = new Direct2D.BitmapProperties(
new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied));
WIC.Bitmap bmp = new WIC.Bitmap(factory, fc, WIC.BitmapCreateCacheOption.CacheOnLoad);
// Формируем изображения
var Direct2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap(Direct2DTarget, fc, props);
// Cleanup
factory.Dispose();
decoder.Dispose();
source.Dispose();
fc.Dispose();
return(Direct2DBitmap);
}
void ColorCameraLoop()
{
while (true)
{
var encodedColorData = camera.Client.LatestJPEGImage();
// decode JPEG
var memoryStream = new MemoryStream(encodedColorData);
var stream = new WICStream(imagingFactory, memoryStream);
// decodes to 24 bit BGR
var decoder = new SharpDX.WIC.BitmapDecoder(imagingFactory, stream, SharpDX.WIC.DecodeOptions.CacheOnLoad);
var bitmapFrameDecode = decoder.GetFrame(0);
// convert to 32 bpp
var formatConverter = new FormatConverter(imagingFactory);
formatConverter.Initialize(bitmapFrameDecode, SharpDX.WIC.PixelFormat.Format32bppBGR);
formatConverter.CopyPixels(nextColorData, Kinect2Calibration.colorImageWidth * 4); // TODO: consider copying directly to texture native memory
//lock (colorData)
// Swap<byte[]>(ref colorData, ref nextColorData);
lock (renderLock) // necessary?
{
UpdateColorImage(device.ImmediateContext, nextColorData);
}
memoryStream.Close();
memoryStream.Dispose();
stream.Dispose();
decoder.Dispose();
formatConverter.Dispose();
bitmapFrameDecode.Dispose();
}
}
private static d2.Bitmap Load(d2.DeviceContext device, wic.BitmapDecoder decoder)
{
var converter = new wic.FormatConverter(Factory);
var frame = decoder.GetFrame(0);
converter.Initialize(frame, wic.PixelFormat.Format32bppPRGBA);
var bmp = d2.Bitmap.FromWicBitmap(device, converter);
frame.Dispose();
decoder.Dispose();
converter.Dispose();
return(bmp);
}
public static WICBitmap LoadBitmap(string rele_path)
{
var Imgc = new ImagingFactory();
var Demcoder = new BitmapDecoder(Imgc, rele_path, SharpDX.IO.NativeFileAccess.Read, DecodeOptions.CacheOnLoad);
BitmapFrameDecode nm_opb = Demcoder.GetFrame(0);
var convert = new FormatConverter(Imgc);
convert.Initialize(nm_opb, SharpDX.WIC.PixelFormat.Format32bppPBGRA);
var Init_action = new WICBitmap(Imgc, convert, BitmapCreateCacheOption.CacheOnLoad);
Imgc.Dispose();
Demcoder.Dispose();
nm_opb.Dispose();
convert.Dispose();
return(Init_action);
}
public static d2.Bitmap LoadBitmap(this d2.RenderTarget renderTarget, Stream stream)
{
var bitmapDecoder = new wic.BitmapDecoder(DXGraphicsService.FactoryImaging, stream,
wic.DecodeOptions.CacheOnDemand);
wic.BitmapFrameDecode bitmapFrameDecode = bitmapDecoder.GetFrame(0);
var bitmapSource = new wic.BitmapSource(bitmapFrameDecode.NativePointer);
var formatConverter = new wic.FormatConverter(DXGraphicsService.FactoryImaging);
formatConverter.Initialize(bitmapSource, wic.PixelFormat.Format32bppPBGRA);
d2.Bitmap bitmap = d2.Bitmap.FromWicBitmap(renderTarget, formatConverter);
formatConverter.Dispose();
/* todo: check to see if I need to register to dispose of this later... Can't comment this out because server side rendering will crash */
//bitmapSource.Dispose();
bitmapFrameDecode.Dispose();
bitmapDecoder.Dispose();
return(bitmap);
}
private async Task UpdateColorTexture()
{
try
{
var encodedColorData = await _camera.Client.LatestJPEGImageAsync();
// decode JPEG
var memoryStream = new MemoryStream(encodedColorData);
var stream = new WICStream(_imagingFactory, memoryStream);
// decodes to 24 bit BGR
var decoder = new SharpDX.WIC.BitmapDecoder(_imagingFactory, stream, SharpDX.WIC.DecodeOptions.CacheOnLoad);
var bitmapFrameDecode = decoder.GetFrame(0);
// convert to 32 bpp
var formatConverter = new FormatConverter(_imagingFactory);
formatConverter.Initialize(bitmapFrameDecode, SharpDX.WIC.PixelFormat.Format32bppBGR);
formatConverter.CopyPixels(nextColorData, RoomAliveToolkit.Kinect2Calibration.colorImageWidth * 4);
UpdateColorImage(GraphicsDevice, nextColorData);
memoryStream.Close();
memoryStream.Dispose();
stream.Dispose();
decoder.Dispose();
formatConverter.Dispose();
bitmapFrameDecode.Dispose();
}
catch (System.ServiceModel.EndpointNotFoundException ex)
{
// TODO Message
LiveColor = false;
Console.WriteLine("Could not connect to Kinect for live color. Start Kinect server.");
}
catch (System.ServiceModel.CommunicationException)
{
Console.WriteLine("Connection to Kinect server for live color was lost. Restart Kinect server and the application.");
LiveDepth = false;
}
}
//-------------------------------------------------------------------------------------
// Load a WIC-supported file in memory
//-------------------------------------------------------------------------------------
internal static Image LoadFromWICMemory(IntPtr pSource, int size, bool makeACopy, GCHandle?handle)
{
var flags = WICFlags.AllFrames;
Image image = null;
// Create input stream for memory
using (var stream = new WIC.WICStream(Factory, new SDX.DataPointer(pSource, size)))
{
// If the decoder is unable to decode the image, than return null
WIC.BitmapDecoder decoder = null;
try
{
decoder = new WIC.BitmapDecoder(Factory, stream, WIC.DecodeOptions.CacheOnDemand);
using (var frame = decoder.GetFrame(0))
{
// Get metadata
Guid convertGuid;
var tempDesc = DecodeMetadata(flags, decoder, frame, out convertGuid);
// If not supported.
if (!tempDesc.HasValue)
{
return(null);
}
var mdata = tempDesc.Value;
if ((mdata.ArraySize > 1) && (flags & WICFlags.AllFrames) != 0)
{
return(DecodeMultiframe(flags, mdata, decoder));
}
image = DecodeSingleFrame(flags, mdata, convertGuid, frame);
}
}
catch
{
image = null;
}
finally
{
if (decoder != null)
{
decoder.Dispose();
}
}
}
// For WIC, we are not keeping the original buffer.
if (image != null && !makeACopy)
{
if (handle.HasValue)
{
handle.Value.Free();
}
else
{
SDX.Utilities.FreeMemory(pSource);
}
}
return(image);
}
//-------------------------------------------------------------------------------------
// Load a WIC-supported file in memory
//-------------------------------------------------------------------------------------
public static Image LoadFromWICMemory(IntPtr pSource, int size, bool makeACopy, GCHandle? handle)
{
var flags = WICFlags.AllFrames;
Image image = null;
// Create input stream for memory
using (var stream = new WICStream(Factory, new DataPointer(pSource, size)))
{
// If the decoder is unable to decode the image, than return null
BitmapDecoder decoder = null;
try
{
decoder = new BitmapDecoder(Factory, stream, DecodeOptions.CacheOnDemand);
using (var frame = decoder.GetFrame(0))
{
// Get metadata
Guid convertGuid;
var tempDesc = DecodeMetadata(flags, decoder, frame, out convertGuid);
// If not supported.
if (!tempDesc.HasValue)
return null;
var mdata = tempDesc.Value;
if ((mdata.ArraySize > 1) && (flags & WICFlags.AllFrames) != 0)
{
return DecodeMultiframe(flags, mdata, decoder);
}
image = DecodeSingleFrame(flags, mdata, convertGuid, frame);
}
}
catch
{
image = null;
}
finally
{
if (decoder != null)
decoder.Dispose();
}
}
// For WIC, we are not keeping the original buffer.
if (image != null && !makeACopy)
{
if (handle.HasValue)
{
handle.Value.Free();
}
else
{
Utilities.FreeMemory(pSource);
}
}
return image;
}
public MeshDeviceResources(Device device, SharpDX.WIC.ImagingFactory2 imagingFactory, Mesh mesh)
{
this.mesh = mesh;
// create single vertex buffer
var stream = new DataStream(mesh.vertices.Count * Mesh.VertexPositionNormalTexture.sizeInBytes, true, true);
stream.WriteRange(mesh.vertices.ToArray());
stream.Position = 0;
var vertexBufferDesc = new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
Usage = ResourceUsage.Default,
SizeInBytes = mesh.vertices.Count * Mesh.VertexPositionNormalTexture.sizeInBytes,
};
vertexBuffer = new SharpDX.Direct3D11.Buffer(device, stream, vertexBufferDesc);
stream.Dispose();
vertexBufferBinding = new VertexBufferBinding(vertexBuffer, Mesh.VertexPositionNormalTexture.sizeInBytes, 0);
foreach (var subset in mesh.subsets)
{
if (subset.material.textureFilename != null)
{
var decoder = new SharpDX.WIC.BitmapDecoder(imagingFactory, subset.material.textureFilename, SharpDX.WIC.DecodeOptions.CacheOnLoad);
var bitmapFrameDecode = decoder.GetFrame(0);
var stagingTextureDesc = new Texture2DDescription()
{
Width = bitmapFrameDecode.Size.Width,
Height = bitmapFrameDecode.Size.Height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.Write
};
var stagingTexture = new Texture2D(device, stagingTextureDesc);
var textureDesc = new Texture2DDescription()
{
Width = bitmapFrameDecode.Size.Width,
Height = bitmapFrameDecode.Size.Height,
MipLevels = 0,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var texture = new Texture2D(device, textureDesc);
// convert to 32 bpp
var formatConverter = new FormatConverter(imagingFactory);
formatConverter.Initialize(bitmapFrameDecode, SharpDX.WIC.PixelFormat.Format32bppBGR);
var dataBox = device.ImmediateContext.MapSubresource(stagingTexture, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
formatConverter.CopyPixels(dataBox.RowPitch, dataBox.DataPointer, dataBox.RowPitch * bitmapFrameDecode.Size.Height);
device.ImmediateContext.UnmapSubresource(stagingTexture, 0);
var resourceRegion = new ResourceRegion()
{
Left = 0,
Top = 0,
Right = bitmapFrameDecode.Size.Width,
Bottom = bitmapFrameDecode.Size.Height,
Front = 0,
Back = 1,
};
device.ImmediateContext.CopySubresourceRegion(stagingTexture, 0, resourceRegion, texture, 0);
var textureRV = new ShaderResourceView(device, texture);
device.ImmediateContext.GenerateMips(textureRV);
decoder.Dispose();
formatConverter.Dispose();
bitmapFrameDecode.Dispose();
textureRVs[subset] = textureRV;
}
}
}
public static MemoryStream Resize(System.IO.Stream source, int maxwidth, int maxheight, Action beforeDrawImage, Action afterDrawImage)
{
// initialize the D3D device which will allow to render to image any graphics - 3D or 2D
var defaultDevice = new SharpDX.Direct3D11.Device(SharpDX.Direct3D.DriverType.Warp,
d3d.DeviceCreationFlags.BgraSupport | d3d.DeviceCreationFlags.SingleThreaded | d3d.DeviceCreationFlags.PreventThreadingOptimizations);
var d3dDevice = defaultDevice.QueryInterface<d3d.Device1>(); // get a reference to the Direct3D 11.1 device
var dxgiDevice = d3dDevice.QueryInterface<dxgi.Device>(); // get a reference to DXGI device
var d2dDevice = new d2.Device(dxgiDevice); // initialize the D2D device
var imagingFactory = new wic.ImagingFactory2(); // initialize the WIC factory
// initialize the DeviceContext - it will be the D2D render target and will allow all rendering operations
var d2dContext = new d2.DeviceContext(d2dDevice, d2.DeviceContextOptions.None);
var dwFactory = new dw.Factory();
// specify a pixel format that is supported by both D2D and WIC
var d2PixelFormat = new d2.PixelFormat(dxgi.Format.R8G8B8A8_UNorm, d2.AlphaMode.Premultiplied);
// if in D2D was specified an R-G-B-A format - use the same for wic
var wicPixelFormat = wic.PixelFormat.Format32bppPRGBA;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// IMAGE LOADING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
var decoder = new wic.BitmapDecoder(imagingFactory,source, wic.DecodeOptions.CacheOnLoad);
// decode the loaded image to a format that can be consumed by D2D
var formatConverter = new wic.FormatConverter(imagingFactory);
formatConverter.Initialize(decoder.GetFrame(0), wicPixelFormat);
// store the image size - output will be of the same size
var inputImageSize = formatConverter.Size;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// RENDER TARGET SETUP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// create the d2d bitmap description using default flags (from SharpDX samples) and 96 DPI
var d2dBitmapProps = new d2.BitmapProperties1(d2PixelFormat, 96, 96, d2.BitmapOptions.Target | d2.BitmapOptions.CannotDraw);
//Calculate size
var resultSize = MathUtil.ScaleWithin(inputImageSize.Width,inputImageSize.Height,maxwidth,maxheight);
var newWidth = resultSize.Item1;
var newHeight = resultSize.Item2;
// the render target
var d2dRenderTarget = new d2.Bitmap1(d2dContext, new Size2(newWidth, newHeight), d2dBitmapProps);
d2dContext.Target = d2dRenderTarget; // associate bitmap with the d2d context
var bitmapSourceEffect = new d2.Effects.BitmapSourceEffect(d2dContext);
bitmapSourceEffect.WicBitmapSource = formatConverter;
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// DRAWING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
beforeDrawImage();
// slow preparations - fast drawing:
d2dContext.BeginDraw();
d2dContext.Transform = Matrix3x2.Scaling(new Vector2((float)(newWidth / (float)inputImageSize.Width), (float)(newHeight / (float)inputImageSize.Height)));
d2dContext.DrawImage(bitmapSourceEffect, d2.InterpolationMode.HighQualityCubic);
d2dContext.EndDraw();
afterDrawImage();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// IMAGE SAVING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
var ms = new MemoryStream();
// use the appropiate overload to write either to stream or to a file
var stream = new wic.WICStream(imagingFactory,ms);
// select the image encoding format HERE
var encoder = new wic.JpegBitmapEncoder(imagingFactory);
encoder.Initialize(stream);
var bitmapFrameEncode = new wic.BitmapFrameEncode(encoder);
bitmapFrameEncode.Initialize();
bitmapFrameEncode.SetSize(newWidth, newHeight);
bitmapFrameEncode.SetPixelFormat(ref wicPixelFormat);
// this is the trick to write D2D1 bitmap to WIC
var imageEncoder = new wic.ImageEncoder(imagingFactory, d2dDevice);
imageEncoder.WriteFrame(d2dRenderTarget, bitmapFrameEncode, new wic.ImageParameters(d2PixelFormat, 96, 96, 0, 0, newWidth, newHeight));
bitmapFrameEncode.Commit();
encoder.Commit();
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// CLEANUP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// dispose everything and free used resources
bitmapFrameEncode.Dispose();
encoder.Dispose();
stream.Dispose();
formatConverter.Dispose();
bitmapSourceEffect.Dispose();
d2dRenderTarget.Dispose();
decoder.Dispose();
d2dContext.Dispose();
dwFactory.Dispose();
imagingFactory.Dispose();
d2dDevice.Dispose();
dxgiDevice.Dispose();
d3dDevice.Dispose();
defaultDevice.Dispose();
return ms;
}
public MeshDeviceResources(Device device, SharpDX.WIC.ImagingFactory2 imagingFactory, Mesh mesh)
{
this.mesh = mesh;
// create single vertex buffer
var stream = new DataStream(mesh.vertices.Count * Mesh.VertexPositionNormalTexture.sizeInBytes, true, true);
stream.WriteRange(mesh.vertices.ToArray());
stream.Position = 0;
var vertexBufferDesc = new BufferDescription()
{
BindFlags = BindFlags.VertexBuffer,
CpuAccessFlags = CpuAccessFlags.None,
Usage = ResourceUsage.Default,
SizeInBytes = mesh.vertices.Count * Mesh.VertexPositionNormalTexture.sizeInBytes,
};
vertexBuffer = new SharpDX.Direct3D11.Buffer(device, stream, vertexBufferDesc);
stream.Dispose();
vertexBufferBinding = new VertexBufferBinding(vertexBuffer, Mesh.VertexPositionNormalTexture.sizeInBytes, 0);
foreach (var subset in mesh.subsets)
{
if (subset.material.textureFilename != null)
{
var decoder = new SharpDX.WIC.BitmapDecoder(imagingFactory, subset.material.textureFilename, SharpDX.WIC.DecodeOptions.CacheOnLoad);
var bitmapFrameDecode = decoder.GetFrame(0);
var stagingTextureDesc = new Texture2DDescription()
{
Width = bitmapFrameDecode.Size.Width,
Height = bitmapFrameDecode.Size.Height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Dynamic,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.Write
};
var stagingTexture = new Texture2D(device, stagingTextureDesc);
var textureDesc = new Texture2DDescription()
{
Width = bitmapFrameDecode.Size.Width,
Height = bitmapFrameDecode.Size.Height,
MipLevels = 0,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.GenerateMipMaps
};
var texture = new Texture2D(device, textureDesc);
// convert to 32 bpp
var formatConverter = new FormatConverter(imagingFactory);
formatConverter.Initialize(bitmapFrameDecode, SharpDX.WIC.PixelFormat.Format32bppBGR);
var dataBox = device.ImmediateContext.MapSubresource(stagingTexture, 0, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None);
formatConverter.CopyPixels(dataBox.RowPitch, dataBox.DataPointer, dataBox.RowPitch * bitmapFrameDecode.Size.Height);
device.ImmediateContext.UnmapSubresource(stagingTexture, 0);
var resourceRegion = new ResourceRegion()
{
Left = 0,
Top = 0,
Right = bitmapFrameDecode.Size.Width,
Bottom = bitmapFrameDecode.Size.Height,
Front = 0,
Back = 1,
};
device.ImmediateContext.CopySubresourceRegion(stagingTexture, 0, resourceRegion, texture, 0);
var textureRV = new ShaderResourceView(device, texture);
device.ImmediateContext.GenerateMips(textureRV);
decoder.Dispose();
formatConverter.Dispose();
bitmapFrameDecode.Dispose();
textureRVs[subset] = textureRV;
}
}
}