/// <summary>
/// MatをBitmapSourceに変換する.
/// </summary>
/// <param name="src">変換するIplImage</param>
/// <param name="horizontalResolution"></param>
/// <param name="verticalResolution"></param>
/// <param name="pixelFormat"></param>
/// <param name="palette"></param>
/// <returns>WPFのBitmapSource</returns>
#else
/// <summary>
/// Converts Mat to BitmapSource.
/// </summary>
/// <param name="src">Input IplImage</param>
/// <param name="horizontalResolution"></param>
/// <param name="verticalResolution"></param>
/// <param name="pixelFormat"></param>
/// <param name="palette"></param>
/// <returns>BitmapSource</returns>
#endif
public static BitmapSource ToBitmapSource(
this Mat src,
int horizontalResolution,
int verticalResolution,
PixelFormat pixelFormat,
BitmapPalette palette)
{
if (src == null)
throw new ArgumentNullException("src");
if (src.IsDisposed)
throw new ObjectDisposedException(typeof(Mat).ToString());
if (src.Dims() != 2)
throw new ArgumentException("src.Dims() != 2");
long step = src.Step();
return BitmapSource.Create(
src.Width,
src.Height,
horizontalResolution,
verticalResolution,
pixelFormat,
palette,
src.Data,
(int)(step * src.Rows),
(int)step);
}
//-----------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------
//Создание WriteableBitmap
public static WriteableBitmapWrapper Create(WriteableBitmap writeableBitmap)
{
media.PixelFormat format = writeableBitmap.Format;
if (format == media.PixelFormats.Rgb48)
{
return(new WriteableBitmapWrapperRGB48(writeableBitmap));
}
if (format == media.PixelFormats.Rgba64)
{
return(new WriteableBitmapWrapperRGBA64(writeableBitmap));
}
if (format == media.PixelFormats.Bgra32)
{
return(new WriteableBitmapWrapperBGRA32(writeableBitmap));
}
if (format == media.PixelFormats.Gray16)
{
return(new WriteableBitmapWrapperGray16(writeableBitmap));
}
if (format == media.PixelFormats.Indexed8)
{
return(new WriteableBitmapWrapperIndexed8(writeableBitmap));
}
else
{
throw new ImageException();
}
}
private static void SaveBmp(Bitmap bmp, string path)
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
BitmapData bitmapData = bmp.LockBits(rect, ImageLockMode.ReadOnly, bmp.PixelFormat);
System.Windows.Media.PixelFormat pixelFormats = ConvertBmpPixelFormat(bmp.PixelFormat);
pixelFormats = PixelFormats.Gray16;
BitmapSource source = BitmapSource.Create(bmp.Width,
bmp.Height,
bmp.HorizontalResolution,
bmp.VerticalResolution,
pixelFormats,
null,
bitmapData.Scan0,
bitmapData.Stride * bmp.Height,
bitmapData.Stride);
bmp.UnlockBits(bitmapData);
FileStream stream = new FileStream(path, FileMode.Create);
TiffBitmapEncoder encoder = new TiffBitmapEncoder();
encoder.Compression = TiffCompressOption.Zip;
encoder.Frames.Add(BitmapFrame.Create(source));
encoder.Save(stream);
stream.Close();
}
public static BitmapSource RenderToBitmap(
this Visual visual,
PixelFormat pixelFormat,
FlowDirection flowDirection = FlowDirection.LeftToRight,
double dpiX = 96.0,
double dpiY = 96.0)
{
if (visual == null)
throw new ArgumentException("visual");
var cv = visual as ContainerVisual;
if (cv != null)
{
var bounds = cv.DescendantBounds;
var size = new Size(bounds.Right, bounds.Bottom);
return visual.RenderToBitmap(size, bounds.Location, bounds.Size, pixelFormat);
}
else
{
var bounds = VisualTreeHelper.GetDescendantBounds(visual);
var size = new Size(bounds.Right, bounds.Bottom);
return visual.RenderToBitmap(size, bounds.Location, bounds.Size, pixelFormat);
}
}
public bool StartStream(string url)
{
///Оборачиваем конструктор класса VideoCapture в задачу, и ждем завершения 5 секунд.
///Это необходимо, т.к. у VideoCapture нет таймаута и если камера не ответила, то приложение зависнет.
var CaptureTask = Task.Factory.StartNew(() => Capture = new VideoCapture(url));
if (!CaptureTask.Wait(new TimeSpan(0, 0, 5)))
{
return(false);
}
///Получаем первый кадр с камеры
Capture.Grab();
///Если удачно записали его в переменную, то продолжаем
if (!Capture.Retrieve(MatFrame, 3))
{
return(false);
}
///Узнаем формат пикселей кадра
System.Windows.Media.PixelFormat pixelFormat = GetPixelFormat(MatFrame);
///Определяем сколько места занимает один кадр
pcount = (uint)(MatFrame.Width * MatFrame.Height * pixelFormat.BitsPerPixel / 8);
///Создаем объект в памяти
source = CreateFileMapping(new IntPtr(-1), IntPtr.Zero, 0x04, 0, pcount, null);
///Получаем ссылку на начальный адрес объекта
map = MapViewOfFile(source, 0xF001F, 0, 0, pcount);
///Инициализируем InteropBitmap используя созданный выше объект в памяти
Frame = Imaging.CreateBitmapSourceFromMemorySection(source, MatFrame.Width, MatFrame.Height, pixelFormat, MatFrame.Width * pixelFormat.BitsPerPixel / 8, 0) as InteropBitmap;
Capture.ImageGrabbed += Capture_ImageGrabbed;
Capture.Start();
return(true);
}
/// <summary>
/// Converts a depth frame to the corresponding System.Windows.Media.ImageSource.
/// </summary>
/// <param name="frame">The specified depth frame.</param>
/// <param name="format">Pixel format of the depth frame.</param>
/// <param name="mode">Depth frame mode.</param>
/// <returns>The corresponding System.Windows.Media.ImageSource representation of the depth frame.</returns>
public static ImageSource ToBitmap(this DepthImageFrame frame, PixelFormat format, DepthImageMode mode)
{
short[] pixelData = new short[frame.PixelDataLength];
frame.CopyPixelDataTo(pixelData);
byte[] pixels;
switch (mode)
{
case DepthImageMode.Raw:
pixels = GenerateRawFrame(frame, pixelData);
break;
case DepthImageMode.Dark:
pixels = GenerateDarkFrame(frame, pixelData);
break;
case DepthImageMode.Colors:
pixels = GenerateColoredFrame(frame, pixelData);
break;
case DepthImageMode.Player:
pixels = GeneratePlayerFrame(frame, pixelData);
break;
default:
pixels = GenerateRawFrame(frame, pixelData);
break;
}
return pixels.ToBitmap(frame.Width, frame.Height, format);
}
private void New_Click(object sender, RoutedEventArgs e) //新建白图
{
rectangle1.Visibility = Visibility.Hidden;
drawingGroup1.Children.Clear();
BitmapSource bitmap = BitmapSource.Create(1024, 800, 96, 96, PixelFormats.Pbgra32, null, array, 1024 * 4);//创建一个位图
MyImageX = bitmap.Width;
MyImageY = bitmap.Height;
MyImagePixely = bitmap.PixelHeight;
MyImagepixelX = bitmap.PixelWidth;
MyImageDpiX = bitmap.DpiX;
MyImagedpiY = bitmap.DpiY;
image.Width = bitmap.Width;
image.Height = bitmap.Height;
MyPixelFormat = bitmap.Format;
//上面是创建位图 下面因为是image 所以用image来绘制
ImageDrawing imageDrawing = new ImageDrawing();
imageDrawing.ImageSource = bitmap;
drawingGroup1.Children.Add(imageDrawing);
//绘制矩形
RectangleGeometry rect = new RectangleGeometry();
rect.Rect = new Rect(0, 0, 1024, 1024); //创建一个抽象矩形
GeometryDrawing g = new GeometryDrawing(); //用这个类来绘制
g.Geometry = rect;
g.Brush = Brushes.White;
Drawimage(g);
}
public static IEnumerable<ColorRGBA> GetPixels(byte[] pixelByteArray, PixelFormat pixelFormat)
{
if (pixelFormat == PixelFormats.Bgra32)
{
for (int i = 0; i < pixelByteArray.Length; i += 4)
{
yield return new ColorRGBA
{
Blue = pixelByteArray[i],
Green = pixelByteArray[i + 1],
Red = pixelByteArray[i + 2],
Alpha = pixelByteArray[i + 3]
};
}
}
else if (pixelFormat == PixelFormats.Bgr32)
{
for (int i = 0; i < pixelByteArray.Length; i += 4)
{
yield return new ColorRGBA
{
Blue = pixelByteArray[i],
Green = pixelByteArray[i + 1],
Red = pixelByteArray[i + 2],
Alpha = 255
};
}
}
else
{
yield break;
}
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <param name="bitmapSize"></param>
/// <param name="geometryPositionOnBitmap"></param>
/// <param name="brush">The Brush with which to fill the Geometry. This is optional, and can be null. If the brush is null, no fill is drawn.</param>
/// <param name="pen">The Pen with which to stroke the Geometry. This is optional, and can be null. If the pen is null, no stroke is drawn</param>
/// <param name="pixelFormat"></param>
/// <param name="dpiX"></param>
/// <param name="dpiY"></param>
/// <returns></returns>
public static BitmapSource RenderToBitmap(
this Geometry geometry,
Size bitmapSize,
Point geometryPositionOnBitmap,
Size geometrySize,
Brush brush,
Pen pen,
PixelFormat pixelFormat,
double dpiX = 96.0,
double dpiY = 96.0)
{
var rtb = new RenderTargetBitmap((int)(bitmapSize.Width * dpiX / 96.0),
(int)(bitmapSize.Height * dpiY / 96.0),
dpiX,
dpiY,
pixelFormat);
var dv = new DrawingVisual();
using (var cx = dv.RenderOpen())
{
cx.Render(geometry, geometryPositionOnBitmap, brush, pen);
}
rtb.Render(dv);
return rtb;
}
/// <summary>
/// Given a bitmap, process the data into a render-able <see cref="BitmapSource"/>
/// </summary>
/// <param name="image">bitmap for image we want to make render-able</param>
/// <returns>render-able image</returns>
private static BitmapSource LoadImageBitmapSource(Bitmap image)
{
// Take the bitmap data and acquire a lock to it (no corrupt bits allowed here no sir!)
BitmapData imageData =
image.LockBits(
new Rectangle(0, 0, image.Width, image.Height),
ImageLockMode.ReadWrite,
image.PixelFormat);
// This is here to support the case where not all shirt images follow the same
// pixel format, which leads to bitmapsource creation being a pain
System.Windows.Media.PixelFormat pixelFormat = PixelFormats.Bgra32;
if (image.PixelFormat.Equals(System.Drawing.Imaging.PixelFormat.Format24bppRgb))
{
pixelFormat = PixelFormats.Bgr24;
}
// Copy the bitmap source to a render-able instance
BitmapSource imageBitmap =
BitmapSource.Create(
image.Width,
image.Height,
image.HorizontalResolution,
image.VerticalResolution,
pixelFormat,
null,
imageData.Scan0,
image.Width * image.Height * 4,
imageData.Stride);
return(imageBitmap);
}
private BitmapSource ToBitmap(ColorFrame frame)
{
int width = frame.FrameDescription.Width;
int height = frame.FrameDescription.Height;
System.Windows.Media.PixelFormat format = PixelFormats.Bgr32;
byte[] pixels = new byte[width * height * ((PixelFormats.Bgr32.BitsPerPixel + 7) / 8)];
if (frame.RawColorImageFormat == ColorImageFormat.Bgra)
{
frame.CopyRawFrameDataToArray(pixels);
}
else
{
frame.CopyConvertedFrameDataToArray(pixels, ColorImageFormat.Bgra);
}
int stride = width * format.BitsPerPixel / 8;
BitmapSource bitmap = BitmapSource.Create(width, height, 96, 96, format, null, pixels, stride);
ScaleTransform scale = new ScaleTransform((1920.0 / bitmap.PixelWidth), (1080.0 / bitmap.PixelHeight));
TransformedBitmap tbBitmap = new TransformedBitmap(bitmap, scale);
return(tbBitmap);
}
/// <summary>
/// Creates bitmap from short array
/// </summary>
/// <param name="visibleImage">Visible image buffer</param>
/// <param name="width">Width in pixels</param>
/// <param name="height">Height in pixels</param>
/// <param name="pixelFormat">Pixel format</param>
/// <returns>Bitmap source instance</returns>
private static BitmapSource CreateBitmapSourceFromInfraredArray(
byte[] visibleImage,
int width,
int height,
swm.PixelFormat pixelFormat)
{
var ir = new short[visibleImage.Length / 2];
// first convert the byte array to short and track max value
short maxValue = 0;
for (int i = 0; i < ir.Length; i++)
{
ir[i] = (short)(visibleImage[i * 2] | (visibleImage[(i * 2) + 1] << 8));
maxValue = Math.Max(maxValue, ir[i]);
}
// then rescale [0,maxValue] -> [0, ushort.Max]
for (int i = 0; i < ir.Length; i++)
{
ir[i] = (short)((ushort.MaxValue * ir[i]) / maxValue);
}
var stride = (pixelFormat.BitsPerPixel / 8) * width;
return(BitmapSource.Create(
width,
height,
96,
96,
pixelFormat,
null,
ir,
stride));
}
/// <summary>
/// Converts a color frame to a System.Media.ImageSource with its background removed.
/// </summary>
/// <param name="frame">A BackgroundRemovedColorFrame generated from a Kinect sensor.</param>
/// <param name="format">The pixel format.</param>
/// <returns>The specified frame in a System.media.ImageSource format.</returns>
public static ImageSource ToBitmap(this BackgroundRemovedColorFrame frame, System.Windows.Media.PixelFormat format)
{
byte[] pixels = new byte[frame.PixelDataLength];
frame.CopyPixelDataTo(pixels);
return(pixels.ToBitmap(frame.Width, frame.Height, format));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="format">The pixel format to use for conversion.</param>
/// <param name="encoder">The encoder to use.</param>
/// <param name="rotate">Degrees of rotation to apply (counterclock whise).</param>
public BitmapSourceConverter(PixelFormat format, Encoder encoder, int rotate = 0)
{
_format = format;
_encoder = encoder;
Rotate = rotate;
}
/// <summary>
/// Construct a ColorConvertedBitmap
/// </summary>
/// <param name="source">Input BitmapSource to color convert</param>
/// <param name="sourceColorContext">Source Color Context</param>
/// <param name="destinationColorContext">Destination Color Context</param>
/// <param name="format">Destination Pixel format</param>
public ColorConvertedBitmap(BitmapSource source, ColorContext sourceColorContext, ColorContext destinationColorContext, PixelFormat format)
: base(true) // Use base class virtuals
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (sourceColorContext == null)
{
throw new ArgumentNullException("sourceColorContext");
}
if (destinationColorContext == null)
{
throw new ArgumentNullException("destinationColorContext");
}
_bitmapInit.BeginInit();
Source = source;
SourceColorContext = sourceColorContext;
DestinationColorContext = destinationColorContext;
DestinationFormat = format;
_bitmapInit.EndInit();
FinalizeCreation();
}
/// <summary>
/// 打开保存新建
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OpenBtn_Click(object sender, RoutedEventArgs e)
{
rectangle1.Visibility = Visibility.Hidden;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Title = "请打开图片";
dialog.Filter = "图像文件 | *.jpg; *.png; *.jpeg; *.bmp; *.gif | 所有文件 | *.* ";
if ((bool)dialog.ShowDialog())
{
//MessageBox.Show(drawingGroup1.Children.Count().ToString());
{
image.Stretch = Stretch.UniformToFill;
drawingGroup1.Children.Clear();
BitmapFrame bf = BitmapFrame.Create(new Uri(dialog.FileName));
MyImageX = bf.Width;
MyImageY = bf.Height;
MyImagePixely = bf.PixelHeight;
MyImagepixelX = bf.PixelWidth;
MyImageDpiX = bf.DpiX;
MyImagedpiY = bf.DpiY;
image.Width = bf.Width;
image.Height = bf.Height;
MyPixelFormat = bf.Format;
ImageDrawing imageDrawing = new ImageDrawing();
imageDrawing.Rect = new Rect(0, 0, bf.Width, bf.Height);
imageDrawing.ImageSource = bf;
Drawimage(imageDrawing);
}
}
}
/// <summary>
/// Converts the given (System.Windows.Media.PixelFormat to its WPF (System.Drawing.Imaging) equivalent.
/// </summary>
///
public static System.Drawing.Imaging.PixelFormat ToImaging(this System.Windows.Media.PixelFormat pixelFormat)
{
if (pixelFormat == PixelFormats.Indexed8)
{
return(System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
}
if (pixelFormat == PixelFormats.Gray8)
{
return(System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
}
if (pixelFormat == PixelFormats.Bgr24)
{
return(System.Drawing.Imaging.PixelFormat.Format24bppRgb);
}
if (pixelFormat == PixelFormats.Bgr32)
{
return(System.Drawing.Imaging.PixelFormat.Format32bppRgb);
}
if (pixelFormat == PixelFormats.Bgra32)
{
return(System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
if (pixelFormat == PixelFormats.Gray32Float)
{
return(System.Drawing.Imaging.PixelFormat.Extended);
}
throw new NotImplementedException(String.Format("Conversion from pixel format {0} is not supported yet, please open a new ticket in Accord.NET's issue tracker.", pixelFormat));
}
private static System.Windows.Media.PixelFormat ConvertBmpPixelFormat(System.Drawing.Imaging.PixelFormat pixelformat)
{
System.Windows.Media.PixelFormat pixelFormats = System.Windows.Media.PixelFormats.Default;
switch (pixelformat)
{
case System.Drawing.Imaging.PixelFormat.Format32bppArgb:
pixelFormats = PixelFormats.Bgr32;
break;
case System.Drawing.Imaging.PixelFormat.Format8bppIndexed:
pixelFormats = PixelFormats.Gray8;
break;
case System.Drawing.Imaging.PixelFormat.Format16bppGrayScale:
pixelFormats = PixelFormats.Gray16;
break;
case System.Drawing.Imaging.PixelFormat.Format64bppArgb:
pixelFormats = PixelFormats.Rgba64;
break;
case System.Drawing.Imaging.PixelFormat.Format32bppRgb:
pixelFormats = PixelFormats.Bgra32;
break;
}
return(pixelFormats);
}
public static ImageSource ToBitmap(this DepthFrame frame)
{
int width = frame.FrameDescription.Width;
int height = frame.FrameDescription.Height;
System.Windows.Media.PixelFormat format = PixelFormats.Bgr32;
ushort minDepth = frame.DepthMinReliableDistance;
ushort maxDepth = frame.DepthMaxReliableDistance;
ushort[] depthData = new ushort[width * height];
byte[] pixelData = new byte[width * height * (PixelFormats.Bgr32.BitsPerPixel + 7) / 8];
frame.CopyFrameDataToArray(depthData);
int colorIndex = 0;
for (int depthIndex = 0; depthIndex < depthData.Length; ++depthIndex)
{
ushort depth = depthData[depthIndex];
byte intensity = (byte)(depth >= minDepth && depth <= maxDepth ? depth : 0);
pixelData[colorIndex++] = intensity; // blue
pixelData[colorIndex++] = intensity; // green
pixelData[colorIndex++] = intensity; // red
++colorIndex;
}
int stride = width * format.BitsPerPixel / 8;
return(BitmapSource.Create(width, height, 96, 96, format, null, pixelData, stride));
}
private void GetMediaType(System.Windows.Media.PixelFormat pixelFormat, out Guid mediaSubType, out short bitCount)
{
//Very basic implementation, should look how to convert
//"System.Drawing.Imaging.PixelFormat to "System.Windows.Media.PixelFormat"
switch (pixelFormat.BitsPerPixel)
{
case 32:
bitCount = 32;
mediaSubType = MediaSubType.RGB32;
break;
case 24:
bitCount = 24;
mediaSubType = MediaSubType.RGB24;
break;
case 16:
bitCount = 16;
mediaSubType = MediaSubType.RGB565;
break;
default:
throw new Exception("Unrecognized Pixelformat in bitmap");
}
}
public static IBitmapSourceGrayScaleConverter GetConverter(PixelFormat format)
{
if (format == PixelFormats.Bgra32 || format == PixelFormats.Bgr32)
return BgrGrayScaleConverter.Instance;
throw new NotSupportedException(string.Format("PixelFormat {0} is not supported", format.GetType().Name));
}
public RenderedBitmap(int width, int height, int stride, PixelFormat format, byte[] bits)
{
this.width = width;
this.height = height;
this.stride = stride;
this.format = format;
this.bits = bits;
}
/// <summary>
/// Конвертация BitmapSource в другой формат BitmapSource.
/// </summary>
/// <param name="source">Источник для конвертации.</param>
/// <param name="destinationFormat">Новый формат.</param>
/// <param name="destinationPalette">
/// Палитра для нового формата, если конечно она нужна для нового формата, иначе передать null.
/// </param>
/// <returns>BitmapSource в новом формате.</returns>
public static BitmapSource ConvertTo(
this BitmapSource source,
PixelFormat destinationFormat,
BitmapPalette destinationPalette)
{
return new FormatConvertedBitmap(
source, destinationFormat, destinationPalette, 0);
}
/// <summary>
/// Конвертация BitmapSource в другой формат BitmapSource.
/// </summary>
/// <param name="source">Источник для конвертации.</param>
/// <param name="destinationFormat">Новый формат.</param>
/// <param name="destinationPalette">
/// Палитра для нового формата, если конечно она нужна для нового формата, иначе передать null.
/// </param>
/// <returns>BitmapSource в новом формате.</returns>
public static BitmapSource ConvertTo(
this BitmapSource source,
PixelFormat destinationFormat,
BitmapPalette destinationPalette)
{
return(new FormatConvertedBitmap(
source, destinationFormat, destinationPalette, 0));
}
/// <summary>
/// Returns the data Type (float or Int) of PixelFormat Type.
/// </summary>
/// <param name="pixelFormat"></param>
/// <returns></returns>
public static Type GetType(this System.Windows.Media.PixelFormat pixelFormat)
{
if (!DiscreteTypeDictionary.ContainsKey(pixelFormat))
{
throw new NotSupportedException("Type: " + pixelFormat + " is not supported by DiscreteTypeDictionary");
}
return(DiscreteTypeDictionary[pixelFormat]);
}
public static bool HasAlpha(this swm.PixelFormat format)
{
return(format == swm.PixelFormats.Pbgra32 ||
format == swm.PixelFormats.Prgba128Float ||
format == swm.PixelFormats.Prgba64 ||
format == swm.PixelFormats.Rgba64 ||
format == swm.PixelFormats.Rgba64);
}
public MapUpdatedEventArgs(byte[] map, int xres, int yres, int stride, PixelFormat format)
{
this.Map = map;
this.XRes = xres;
this.YRes = yres;
this.Stride = stride;
this.Format = format;
}
private static BitmapSource BitmapToBitmapSource(Bitmap bitmap, System.Windows.Media.PixelFormat pixelFormat)
{
var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
var bitmapSource = BitmapSource.Create(bitmapData.Width, bitmapData.Height, 96, 96, pixelFormat, null, bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, bitmapData.Stride);
bitmap.UnlockBits(bitmapData);
return(bitmapSource);
}
public static Bitmap ToBitmap(this DepthImageFrame image, PixelFormat format)
{
if (image == null || image.PixelDataLength == 0)
return null;
var data = new short[image.PixelDataLength];
image.CopyPixelDataTo(data);
return data.ToBitmap(image.Width, image.Height
, format);
}
/// <summary>
/// Returns the compatible type of System.Drawing.Imaging.PixelFormat for a given System.Windows.Media.PixelFormat.
/// </summary>
/// <param name="pixelFormat"></param>
/// <returns></returns>
public static System.Drawing.Imaging.PixelFormat ToDrawingPixelFormat(
this System.Windows.Media.PixelFormat pixelFormat)
{
if (!PixelFormatDictionary.ContainsKey(pixelFormat))
{
throw new NotSupportedException("Type: " + pixelFormat + " is not supported by PixelFormatDictionary.");
}
return(PixelFormatDictionary[pixelFormat]);
}
public ImageContext(int h, int w, PixelFormat f)
{
Height = h;
Width = w;
ImageFormat = f;
NStride = (Width * ImageFormat.BitsPerPixel + 7) / 8;
PixelByteArraySize = Height * NStride;
PixelByteArray = new byte[PixelByteArraySize];
}
public VlcControlWpfRendererContext(int width, int height, PixelFormat format)
{
Size = width * height * format.BitsPerPixel / 8;
Data = Marshal.AllocHGlobal(Size);
Width = width;
Height = height;
PixelFormat = format;
Stride = width * format.BitsPerPixel / 8;
}
public static BitmapImage ConvertToOtherPixelFormat(BitmapSource source, PixelFormat format)
{
var newFormatedBitmapSource = new FormatConvertedBitmap();
newFormatedBitmapSource.BeginInit();
newFormatedBitmapSource.Source = source;
newFormatedBitmapSource.DestinationFormat = format;
newFormatedBitmapSource.EndInit();
return BitmapSourceToBitmapImage(newFormatedBitmapSource.Source);
}
/// <summary>
/// MatをBitmapSourceに変換する.
/// </summary>
/// <param name="src">変換するIplImage</param>
/// <param name="horizontalResolution"></param>
/// <param name="verticalResolution"></param>
/// <param name="pixelFormat"></param>
/// <param name="palette"></param>
/// <returns>WPFのBitmapSource</returns>
#else
/// <summary>
/// Converts Mat to BitmapSource.
/// </summary>
/// <param name="src">Input IplImage</param>
/// <param name="horizontalResolution"></param>
/// <param name="verticalResolution"></param>
/// <param name="pixelFormat"></param>
/// <param name="palette"></param>
/// <returns>BitmapSource</returns>
#endif
public static BitmapSource ToBitmapSource(
this Mat src,
int horizontalResolution,
int verticalResolution,
PixelFormat pixelFormat,
BitmapPalette palette)
{
return src.ToWriteableBitmap(horizontalResolution, verticalResolution, pixelFormat, palette);
}
/// <summary>Captures a snapshot of the source element as a bitmap image. The snapshot is created based on the specified rendering parameters.</summary>
/// <param name="sourceElement">The source element.</param>
/// <param name="bitmapSize">The bitmap size.</param>
/// <param name="scalingMode">The bitmap scaling mode.</param>
/// <param name="bitmapDpi">The bitmap dpi.</param>
/// <param name="pixelFormat">The bitmap pixel format.</param>
/// <returns>The snapshot of the source element.</returns>
public static BitmapSource CaptureSnapshot(FrameworkElement sourceElement, Size bitmapSize, BitmapScalingMode scalingMode, Vector bitmapDpi, PixelFormat pixelFormat) {
if (sourceElement == null || bitmapSize.IsZero()) return null;
var snapshot = new RenderTargetBitmap((int)bitmapSize.Width, (int)bitmapSize.Height, bitmapDpi.X, bitmapDpi.Y, pixelFormat);
sourceElement.SetValue(RenderOptions.BitmapScalingModeProperty, scalingMode);
snapshot.Render(sourceElement);
sourceElement.ClearValue(RenderOptions.BitmapScalingModeProperty);
snapshot.Freeze();
return snapshot;
}
public static Bitmap SharedImageToBitmap(Shared <Image> input)
{
PixelFormat pixelFormat = SharedImageToPixelFormat(input);
WriteableBitmap VideoImage = new WriteableBitmap(input.Resource.Width, input.Resource.Height, 300, 300, pixelFormat, null);
VideoImage.WritePixels(new Int32Rect(0, 0, input.Resource.Width, input.Resource.Height), input.Resource.ImageData, input.Resource.Stride * input.Resource.Height, input.Resource.Stride);
Bitmap VideoImageBitmap = BitmapFromWriteableBitmap(VideoImage);
return(VideoImageBitmap);
}
private static System.Drawing.Imaging.PixelFormat GetBitmapPixelFormat(System.Windows.Media.PixelFormat bitmapSourcePixelFormat)
{
if (!PixelFormatTranslator.ContainsValue(bitmapSourcePixelFormat))
{
throw new ArgumentOutOfRangeException("bitmapSourcePixelFormat", bitmapSourcePixelFormat,
"Unsupported pixel format.");
}
return(PixelFormatTranslator.Single(kv => kv.Value == bitmapSourcePixelFormat).Key);
}
/// <summary>
/// MilImage ==> byte array 변환기.
/// </summary>
/// <param name="matImage">MIL 이미지.</param>
/// <returns></returns>
public static byte[] MilImageToBuffer(MilImage milImage, System.Windows.Media.PixelFormat Format)
{
byte[] buffer = new byte[milImage.GetBufferSize()];
milImage.GetColor((Format.BitsPerPixel / 8), buffer);
System.Drawing.Size imageSize = (System.Drawing.Size)milImage.GetImageSize();
return(buffer);
}
private object[] ReadOptions()
{
// TODO parse input options
_width = UtilApplication.ParseAsInt(TextBoxWidth.Text, 1);
_height = UtilApplication.ParseAsInt(TextBoxHeight.Text, 1);
_dpi = 96;
_format = System.Windows.Media.PixelFormats.Bgra32;
return(new object[] { _width, _height, _dpi, _format });
}
public static BitmapSource setPixelFormat1(BitmapSource image, System.Windows.Media.PixelFormat format)
{
var formatted = new FormatConvertedBitmap();
formatted.BeginInit();
formatted.Source = image;
formatted.DestinationFormat = format;
formatted.EndInit();
return(formatted);
}
public Bitmap2D(long width, long height, PixelFormat pf)
: base()
{
pixelFormat = pf;
bitmapWidth = width;
bitmapHeight = height;
totalNumberPixels = bitmapWidth * bitmapHeight;
maxSize = totalNumberPixels * pixelFormat.BitsPerPixel / 8;
pixelData = new byte[maxSize];
whiteOutBitmap();
}
public static void SaveImage(this UIElement element, Size size, PixelFormat pixelFormat, string fileName)
{
using var stream = File.OpenWrite(fileName);
element.Measure(size);
element.Arrange(new Rect(size));
var renderTargetBitmap = element.ToRenderTargetBitmap(size, pixelFormat);
var encoder = GetEncoder(fileName);
encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
encoder.Save(stream);
}
public static BitmapSource Stretch(IImageStatistics statistics, Bitmap img, System.Windows.Media.PixelFormat pf, double factor, double blackClipping)
{
using (MyStopWatch.Measure()) {
var filter = ImageUtility.GetColorRemappingFilter(statistics, factor, blackClipping, pf);
filter.ApplyInPlace(img);
var source = ImageUtility.ConvertBitmap(img, pf);
source.Freeze();
return(source);
}
}
/// <summary>
/// 指定したPixelFormatに適合するIplImageのチャンネル数を返す
/// </summary>
/// <param name="f"></param>
/// <returns></returns>
internal static int GetOptimumChannels(PixelFormat f)
{
try
{
return optimumChannels[f];
}
catch (KeyNotFoundException)
{
throw new ArgumentException("Not supported PixelFormat");
}
}
public void RecalcCanvas(System.Drawing.Imaging.PixelFormat format)
{
// TODO get format by url ending / mime type?
_format = UtilDrawing.ConvertPixelFormat(format);
// Calculate the number of bytes per pixel.
_bytesPerPixel = (_format.BitsPerPixel + 7) / 8;
// Stride is bytes per pixel times the number of pixels.
// Stride is the byte width of a single rectangle row.
_stride = _width * _bytesPerPixel;
}
public DrawingSettings(int pixelWidth, int pixelHeight, double dpiX, double dpiY,
PixelFormat pixelFormat,
BitmapPalette palette, int stride)
{
PixelWidth = pixelWidth;
PixelHeight = pixelHeight;
DpiX = dpiX;
DpiY = dpiY;
PixelFromatUsed = pixelFormat;
BitmapPalleteUsed = palette;
Stride = stride;
}
/// <summary>
/// Convert bmpSource to format declared in pixFormat.
/// </summary>
/// <param name="bmpSource"></param>
/// <param name="pixFormat"></param>
/// <returns></returns>
public static FormatConvertedBitmap BitmapToFormat(BitmapSource bmpSource,
PixelFormat pixFormat)
{
if (bmpSource == null) { return null; }
FormatConvertedBitmap fcb = new FormatConvertedBitmap();
fcb.BeginInit();
fcb.Source = bmpSource;
fcb.DestinationFormat = pixFormat;
fcb.EndInit();
return fcb;
}
public static Bitmap ToBitmap(this short[] data, int width, int height
, PixelFormat format)
{
var bitmap = new Bitmap(width, height, format);
var bitmapData = bitmap.LockBits(
new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.WriteOnly,
bitmap.PixelFormat);
Marshal.Copy(data, 0, bitmapData.Scan0, data.Length);
bitmap.UnlockBits(bitmapData);
return bitmap;
}
public static BitmapSource ConvertBitmap(System.Drawing.Bitmap bitmap, System.Windows.Media.PixelFormat pf)
{
var bitmapData = bitmap.LockBits(
new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height),
System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);
var bitmapSource = BitmapSource.Create(
bitmapData.Width, bitmapData.Height, 96, 96, pf, null,
bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, bitmapData.Stride);
bitmap.UnlockBits(bitmapData);
return(bitmapSource);
}
public InteropBitmapHelper(int width, int height, byte[] imageBits, PixelFormat pixelFormat)
{
_Width = width;
_Height = height;
_PixelFormat = pixelFormat;
int stride = width * pixelFormat.BitsPerPixel / 8;
_ColorByteCount = (uint)(height * stride);
var colorFileMapping = CreateFileMapping(new IntPtr(-1), IntPtr.Zero, 0x04, 0, _ColorByteCount, null);
_ImageBits = MapViewOfFile(colorFileMapping, 0xF001F, 0, 0, _ColorByteCount);
Marshal.Copy(imageBits, 0, _ImageBits, (int)_ColorByteCount);
InteropBitmap = Imaging.CreateBitmapSourceFromMemorySection(colorFileMapping, width, height, pixelFormat, stride, 0) as InteropBitmap;
}
public StarDetection(IRenderedImage renderedImage, System.Windows.Media.PixelFormat pf, StarSensitivityEnum sensitivity, NoiseReductionEnum noiseReduction)
: this(renderedImage, sensitivity, noiseReduction)
{
if (pf == PixelFormats.Rgb48)
{
using (var source = ImageUtility.BitmapFromSource(_originalBitmapSource, System.Drawing.Imaging.PixelFormat.Format48bppRgb)) {
using (var img = new Grayscale(0.2125, 0.7154, 0.0721).Apply(source)) {
_originalBitmapSource = ImageUtility.ConvertBitmap(img, System.Windows.Media.PixelFormats.Gray16);
_originalBitmapSource.Freeze();
}
}
}
}
public static System.Drawing.Imaging.PixelFormat ConvertPixelFormat2(System.Windows.Media.PixelFormat sourceFormat)
{
switch (sourceFormat.BitsPerPixel)
{
case 24:
return(System.Drawing.Imaging.PixelFormat.Format24bppRgb);
case 32:
return(System.Drawing.Imaging.PixelFormat.Format32bppRgb);
// .. as many as you need...
}
return(new System.Drawing.Imaging.PixelFormat());
}
public RenderTargetBitmap(
int pixelWidth,
int pixelHeight,
double dpiX,
double dpiY,
PixelFormat pixelFormat
) : base(true)
{
if (pixelFormat.Format == PixelFormatEnum.Default)
{
pixelFormat = PixelFormats.Pbgra32;
}
else if (pixelFormat.Format != PixelFormatEnum.Pbgra32)
{
throw new System.ArgumentException(
SR.Get(SRID.Effect_PixelFormat, pixelFormat),
"pixelFormat"
);
}
if (pixelWidth <= 0)
{
throw new ArgumentOutOfRangeException("pixelWidth", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (pixelHeight <= 0)
{
throw new ArgumentOutOfRangeException("pixelHeight", SR.Get(SRID.ParameterMustBeGreaterThanZero));
}
if (dpiX < DoubleUtil.DBL_EPSILON)
{
dpiX = 96.0;
}
if (dpiY < DoubleUtil.DBL_EPSILON)
{
dpiY = 96.0;
}
_bitmapInit.BeginInit();
_pixelWidth = pixelWidth;
_pixelHeight = pixelHeight;
_dpiX = dpiX;
_dpiY = dpiY;
_format = pixelFormat;
_bitmapInit.EndInit();
FinalizeCreation();
}
/// <summary>
/// Convert bmpSource to format declared in pixFormat.
/// </summary>
/// <param name="bmpSource"></param>
/// <param name="pixFormat"></param>
/// <returns></returns>
public static FormatConvertedBitmap BitmapToFormat(BitmapSource bmpSource,
PixelFormat pixFormat)
{
if (bmpSource == null)
{
return(null);
}
FormatConvertedBitmap fcb = new FormatConvertedBitmap();
fcb.BeginInit();
fcb.Source = bmpSource;
fcb.DestinationFormat = pixFormat;
fcb.EndInit();
return(fcb);
}
public FluentBitmap(int pixelWidth, int pixelHeight, PixelFormat pixelFormat)
{
if (pixelFormat == null)
throw new ArgumentNullException("pixelFormat", "pixelFormat is null.");
if (pixelWidth <= 0)
throw new ArgumentOutOfRangeException("pixelWidth", "pixelWidth must be greater than 0.");
if (pixelHeight <= 0)
throw new ArgumentOutOfRangeException("pixelHeight", "pixelHeight must be greater than 0.");
PixelWidth = pixelWidth;
PixelHeight = pixelHeight;
PixelFormat = pixelFormat;
StrideBytes = GetMinimumStride(pixelWidth, pixelFormat);
PixelsPerInch = 96;
}
/// <summary>
/// Строит пиксель по заданному адресу в памяти и формату
/// </summary>
/// <param name="pixelAddr">Адрес начала пикселя</param>
/// <param name="format">Формат пикселя</param>
/// <returns>Тип реализующий интерфейс IPixel или null если не существует реализации для указанного формата</returns>
public unsafe IPixel CreatePixel(byte* pixelAddr, PixelFormat format)
{
if (PixelFormats.Bgra32.Equals(format))
return new BGRA32PixelUnsafe(pixelAddr);
if (PixelFormats.Bgr24.Equals(format))
return new BGR24PixelUnsafe(pixelAddr);
if (PixelFormats.Rgb24.Equals(format))
return new RGB24PixelUnsafe(pixelAddr);
if (PixelFormats.Bgr32.Equals(format))
return new BGR24PixelUnsafe(pixelAddr);
return null;
}
/// <summary>
/// Create a BitmapSource from an array of pixels.
/// </summary>
/// <param name="pixelWidth">Width of the Bitmap</param>
/// <param name="pixelHeight">Height of the Bitmap</param>
/// <param name="dpiX">Horizontal DPI of the Bitmap</param>
/// <param name="dpiY">Vertical DPI of the Bitmap</param>
/// <param name="pixelFormat">Format of the Bitmap</param>
/// <param name="palette">Palette of the Bitmap</param>
/// <param name="pixels">Array of pixels</param>
/// <param name="stride">stride</param>
public static BitmapSource Create(
int pixelWidth,
int pixelHeight,
double dpiX,
double dpiY,
PixelFormat pixelFormat,
Imaging.BitmapPalette palette,
System.Array pixels,
int stride
)
{
return new CachedBitmap(
pixelWidth, pixelHeight,
dpiX, dpiY,
pixelFormat, palette,
pixels, stride);
}
public void MakeBitmap()
{
BitmapImage myBitmapImage = new BitmapImage();
myBitmapImage.BeginInit();
myBitmapImage.UriSource = new Uri(@text1.Text);
myBitmapImage.EndInit();
myImage.Source = myBitmapImage;
//
height = myBitmapImage.PixelHeight;
width = myBitmapImage.PixelWidth;
imageFormat = myBitmapImage.Format;
nStride = (myBitmapImage.PixelWidth * imageFormat.BitsPerPixel + 7) / 8;
pixelByteArraySize = myBitmapImage.PixelHeight * nStride;
pixelByteArrayIn = new byte[pixelByteArraySize];
myBitmapImage.CopyPixels(pixelByteArrayIn, nStride, 0);
}
private static bool TryGetComponentCount(PixelFormat format, out int componentCount)
{
// For this sample: only RGB color and 8 bit monochrome images are supported.
if (format == PixelFormats.Bgr24)
{
componentCount = 3;
}
else if (format == PixelFormats.Gray8)
{
componentCount = 1;
}
else
{
componentCount = 0;
}
return componentCount != 0;
}
unsafe internal CachedBitmap(
int pixelWidth,
int pixelHeight,
double dpiX,
double dpiY,
PixelFormat pixelFormat,
BitmapPalette palette,
IntPtr buffer,
int bufferSize,
int stride
)
: base(true) // Use base class virtuals
{
InitFromMemoryPtr(pixelWidth, pixelHeight, dpiX, dpiY,
pixelFormat, palette,
buffer, bufferSize, stride);
}
