public static Uri Create(string filename, string text, SolidColorBrush backgroundColor, double textSize, Size size)
{
var background = new Rectangle();
background.Width = size.Width;
background.Height = size.Height;
background.Fill = backgroundColor;
var textBlock = new TextBlock();
textBlock.Width = 500;
textBlock.Height = 500;
textBlock.TextWrapping = TextWrapping.Wrap;
textBlock.Text = text;
textBlock.FontSize = textSize;
textBlock.Foreground = new SolidColorBrush(Colors.White);
textBlock.FontFamily = new FontFamily("Segoe WP");
var tileImage = "/Shared/ShellContent/" + filename;
using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
{
var bitmap = new WriteableBitmap((int)size.Width, (int)size.Height);
bitmap.Render(background, new TranslateTransform());
bitmap.Render(textBlock, new TranslateTransform() { X = 39, Y = 88 });
var stream = store.CreateFile(tileImage);
bitmap.Invalidate();
bitmap.SaveJpeg(stream, (int)size.Width, (int)size.Height, 0, 99);
stream.Close();
}
return new Uri("ms-appdata:///local" + tileImage, UriKind.Absolute);
}
private static void SaveTileBackgroundImage(TileViewModel model)
{
string xamlCode;
using (var tileStream = Application.GetResourceStream(new Uri("/WP7LiveTileDemo;component/Controls/CustomTile.xaml", UriKind.Relative)).Stream)
{
using (var reader = new StreamReader(tileStream))
{
xamlCode = reader.ReadToEnd();
}
}
var control = (Control)XamlReader.Load(xamlCode);
control.DataContext = model;
var bitmap = new WriteableBitmap(173, 173);
bitmap.Render(control, new TranslateTransform());
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (var stream = store.CreateFile(TileBackgroundPath))
{
bitmap.Invalidate();
bitmap.SaveJpeg(stream, 173, 173, 0, 100);
stream.Close();
}
}
}
private void Render(DrawingContext drawingContext)
{
if (_width > 0 && _height > 0)
{
if (_bitmap == null || _bitmap.Width != _width || _bitmap.Height != _height)
{
_bitmap = new WriteableBitmap(_width, _height, 96, 96, PixelFormats.Pbgra32, null);
}
_bitmap.Lock();
using (var surface = SKSurface.Create(_width, _height, SKImageInfo.PlatformColorType, SKAlphaType.Premul, _bitmap.BackBuffer, _bitmap.BackBufferStride))
{
var canvas = surface.Canvas;
canvas.Scale((float)_dpiX, (float)_dpiY);
canvas.Clear();
using (new SKAutoCanvasRestore(canvas, true))
{
Presenter.Render(canvas, Renderer, Container, _offsetX, _offsetY);
}
}
_bitmap.AddDirtyRect(new Int32Rect(0, 0, _width, _height));
_bitmap.Unlock();
drawingContext.DrawImage(_bitmap, new Rect(0, 0, _actualWidth, _actualHeight));
}
}
internal void SetIcon(string fileName)
{
var bitmapSource = new BitmapImage();
bitmapSource.BeginInit();
bitmapSource.UriSource = new Uri(fileName);
// ensure that we resize to the correct dimensions
bitmapSource.DecodePixelHeight = 46;
bitmapSource.DecodePixelWidth = 46;
bitmapSource.EndInit();
var pbgra32Image = new FormatConvertedBitmap(bitmapSource, System.Windows.Media.PixelFormats.Pbgra32, null, 0);
var bmp = new System.Windows.Media.Imaging.WriteableBitmap(pbgra32Image);
var images = new List <BandIcon>()
{
bmp.ToBandIcon(), bmp.ToBandIcon()
};
Strapp.SetImageList(Strapp.TileId, images, 0);
_tiles.UpdateStrapp(Strapp);
// this should refresh all bindings into the Strapp (in particular, the image)
NotifyPropertyChanged("Strapp");
}
void myChooser_KinectChanged(object sender, KinectChangedEventArgs e)
{
if (null != e.OldSensor)
{
//Alten Kinect deaktivieren
if (mySensor != null)
{
mySensor.Dispose();
}
}
if (null != e.NewSensor)
{
mySensor = e.NewSensor;
mySensor.AudioSource.Start();
mySensor.AudioSource.BeamAngleChanged += new EventHandler<BeamAngleChangedEventArgs>(AudioSource_BeamAngleChanged);
mySensor.AudioSource.SoundSourceAngleChanged += new EventHandler<SoundSourceAngleChangedEventArgs>(AudioSource_SoundSourceAngleChanged);
myBitmap = new WriteableBitmap(640,480, 96.0, 96.0, PixelFormats.Pbgra32, null);
image1.Source = myBitmap;
try
{
this.mySensor.Start();
SensorChooserUI.Visibility = Visibility.Hidden;
}
catch (IOException)
{
this.mySensor = null;
}
}
}
private void Init(int width, int height)
{
_bitmap = BitmapFactory.New(width, height);
_bytes = new byte[width * height * 4];
_dirtyRect = new Int32Rect(0, 0, width, height);
}
void t_Completed(object sender, Microsoft.Phone.Tasks.PhotoResult e)
{
if (e.TaskResult == Microsoft.Phone.Tasks.TaskResult.OK)
{
System.Windows.Media.Imaging.WriteableBitmap wb = new System.Windows.Media.Imaging.WriteableBitmap(480, 800);
BitmapImage bimg = new BitmapImage();
bimg.SetSource(e.ChosenPhoto);
Image img = new Image();
img.Width = 480;
img.Height = 800;
img.Source = bimg;
img.Stretch = Stretch.UniformToFill;
wb.Render(img, null);
wb.Invalidate();
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (var st = new IsolatedStorageFileStream("slideshow_" + (DateTime.Now.Day.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString() + DateTime.Now.Hour.ToString()) + ".jpg", FileMode.Create, FileAccess.Write, store))
{
System.Windows.Media.Imaging.Extensions.SaveJpeg(wb, st, 480, 800, 0, 100);
}
}
updateList();
}
else
{
MessageBox.Show("It looks like your phone is syncing; couldn't open the chooser.");
}
}
public static ImageTools.Image ToImage(WriteableBitmap bitmap)
{
bitmap.Invalidate();
ImageTools.Image image = new ImageTools.Image(bitmap.PixelWidth, bitmap.PixelHeight);
try
{
for (int y = 0; y < bitmap.PixelHeight; ++y)
{
for (int x = 0; x < bitmap.PixelWidth; ++x)
{
int pixel = bitmap.Pixels[bitmap.PixelWidth * y + x];
byte a = (byte)((pixel >> 24) & 0xFF);
float aFactor = a / 255f;
byte r = (byte)(((pixel >> 16) & 0xFF) / aFactor);
byte g = (byte)(((pixel >> 8) & 0xFF) / aFactor);
byte b = (byte)((pixel & 0xFF) / aFactor);
image.SetPixel(x, y, r, g, b, a);
}
}
}
catch (System.Security.SecurityException e)
{
throw new ArgumentException("Bitmap cannot accessed", e);
}
return image;
}
public WriteableBitmap bmpFromColorFrame(ColorImageFrame NewFrame, bool SkeletonWanted, SkeletonFrame SkelFrame)
{
if (bmpColor == null)
{
bmpColor = new WriteableBitmap(frameWidth, frameHeight, 96, 96, PixelFormats.Bgr32, null);
}
if (NewFrame == null)
{
throw new InvalidOperationException("Null Image");
}
NewFrame.CopyPixelDataTo(colorPixels);
// Write the pixel data into our bitmap
bmpColor.WritePixels(
new Int32Rect(0, 0, bmpColor.PixelWidth, bmpColor.PixelHeight),
colorPixels,
bmpColor.PixelWidth * sizeof(int),
0);
//Skeleton
if (SkeletonWanted != false && SkelFrame != null)
{
return bmpWithSkelFromColor(bmpColor, SkelFrame);
}
return bmpColor;
}
private void btnSalvar_Click(object sender, RoutedEventArgs e)
{
try
{
string _tmpImage = "tmpImage";
string _msgMensagem = "Imagem grava com sucesso!";
var store = IsolatedStorageFile.GetUserStoreForApplication();
if (store.FileExists(_tmpImage)) store.DeleteFile(_tmpImage);
IsolatedStorageFileStream _stream = store.CreateFile(_tmpImage);
WriteableBitmap _writeImage = new WriteableBitmap(_imagetmp);
Extensions.SaveJpeg(_writeImage, _stream, _writeImage.PixelWidth,
_writeImage.PixelHeight, 0, 100);
_stream.Close();
_stream = store.OpenFile(_tmpImage, System.IO.FileMode.Open,
System.IO.FileAccess.Read);
MediaLibrary _mlibrary = new MediaLibrary();
_mlibrary.SavePicture(_stream.Name, _stream);
_stream.Close();
btnSalvar.IsEnabled = false;
lblStatus.Text = _msgMensagem;
}
catch (Exception error)
{
lblStatus.Text = error.Message;
}
}
private string SaveBitmap()
{
System.Windows.Media.Matrix m = PresentationSource.FromVisual(this).CompositionTarget.TransformToDevice;
Double dpiX = m.M11 * 96;
Double dpiY = m.M22 * 96;
//200*12
//7*60
int width = GetFitBMPWidth();
int height = GetFitBMPHeight();
var wb = new System.Windows.Media.Imaging.WriteableBitmap(width, height, dpiX, dpiY,
PixelFormats.Pbgra32, null);
wb.Lock();
var bmp = new System.Drawing.Bitmap(wb.PixelWidth, wb.PixelHeight,
wb.BackBufferStride,
System.Drawing.Imaging.PixelFormat.Format32bppPArgb,
wb.BackBuffer);
System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp); // Good old Graphics
DrawEverything(g);
//g.DrawLine( ... ); // etc...
// ...and finally:
g.Dispose();
string temp = System.Environment.GetEnvironmentVariable("TEMP");
string sFile = temp + "\\snapshot.png";
bmp.Save(sFile);
bmp.Dispose();
//wb.AddDirtyRect( ... );
wb.Unlock();
return(sFile);
}
public void Create(int width, int height, PixelFormat pixelFormat)
{
swm.PixelFormat format;
switch (pixelFormat)
{
/*case PixelFormat.Format16bppRgb555:
* format = swm.PixelFormats.Bgr555;
* break;*/
case PixelFormat.Format24bppRgb:
format = swm.PixelFormats.Bgr24;
break;
case PixelFormat.Format32bppRgb:
format = swm.PixelFormats.Bgr32;
break;
case PixelFormat.Format32bppRgba:
format = swm.PixelFormats.Bgra32;
break;
default:
throw new NotSupportedException();
}
var bf = new swmi.WriteableBitmap(width, height, 96, 96, format, null);
Control = bf;
}
/// <summary>
/// Получить тестовое незаполненное изображение
/// </summary>
/// <returns>Изображение, состоящее из 25 пикселей, 16 из которых белые и 9 черных (сетка, между ячейками черные полосы в 1 пиксель)</returns>
private WriteableBitmap GetTestPatternImage()
{
WriteableBitmap result = new WriteableBitmap(5,5,96,96,PixelFormats.Bgra32, new BitmapPalette(this.testColors));
int stride = 20;
byte[] firstLine =
{
255, 255, 255, 255,
255, 255, 255, 255,
0, 0, 0, 255,
255, 255, 255, 255,
255, 255, 255, 255,
};
byte[] middleLine =
{
0,0,0, 255,
0,0,0, 255,
0, 0, 0, 255,
0,0,0, 255,
0,0,0, 255,
};
byte[] imageBytes = new byte[25 * 4];
Array.Copy(firstLine, 0, imageBytes, 0, stride);
Array.Copy(firstLine, 0, imageBytes, stride, stride);
Array.Copy(middleLine, 0, imageBytes, stride * 2, stride);
Array.Copy(firstLine, 0, imageBytes, stride * 3, stride);
Array.Copy(firstLine, 0, imageBytes, stride * 4, stride);
result.WritePixels(new Int32Rect(0,0,5,5), imageBytes,stride,0);
return result;
}
/// <summary>
/// Converts a color frame to a System.Media.Imaging.BitmapSource.
/// </summary>
/// <param name="frame">The specified color frame.</param>
/// <returns>The specified frame in a System.Media.Imaging.BitmapSource representation of the color frame.</returns>
public static BitmapSource ToBitmap(this ColorFrame frame)
{
if (_bitmap == null)
{
_width = frame.FrameDescription.Width;
_height = frame.FrameDescription.Height;
_pixels = new byte[_width * _height * Constants.BYTES_PER_PIXEL];
_bitmap = new WriteableBitmap(_width, _height, Constants.DPI, Constants.DPI, Constants.FORMAT, null);
}
if (frame.RawColorImageFormat == ColorImageFormat.Bgra)
{
frame.CopyRawFrameDataToArray(_pixels);
}
else
{
frame.CopyConvertedFrameDataToArray(_pixels, ColorImageFormat.Bgra);
}
_bitmap.Lock();
Marshal.Copy(_pixels, 0, _bitmap.BackBuffer, _pixels.Length);
_bitmap.AddDirtyRect(new Int32Rect(0, 0, _width, _height));
_bitmap.Unlock();
return _bitmap;
}
// Make a grey image
public WriteableBitmap GreyEffect(WriteableBitmap image)
{
WriteableBitmap result = new WriteableBitmap(image.PixelWidth, image.PixelHeight);
int[] ARGBPx = image.Pixels;
for (int pixelIndex = 0; pixelIndex < ARGBPx.Length; pixelIndex++)
{
int color = ARGBPx[pixelIndex];
int gray = 0;
// Retrieve A, R, G, B colors
int a = color >> 24;
int r = (color & 0x00ff0000) >> 16;
int g = (color & 0x0000ff00) >> 8;
int b = (color & 0x000000ff);
if ((r == g) && (g == b))
{
gray = color;
}
else
{
// Calculate for the illumination.
int i = (7 * r + 38 * g + 19 * b + 32) >> 6;
gray = ((a & 0xFF) << 24) | ((i & 0xFF) << 16) | ((i & 0xFF) << 8) | (i & 0xFF);
}
// Set result color
ARGBPx[pixelIndex] = gray;
}
// Return resulted image
ARGBPx.CopyTo(result.Pixels, 0);
return result;
}
public CaptureImageCompletedEventArgs (WriteableBitmap image)
: base (null, false, null)
{
// Note: When this is implemented a native peer will have to be created.
Console.WriteLine ("NIEX: System.Windows.Media.CaptureImageCompletedEventArgs:.ctor");
throw new NotImplementedException ();
}
public void Update(ImageFrameReadyEventArgs e)
{
if (depthFrame32 == null)
{
depthFrame32 = new byte[e.ImageFrame.Image.Width * e.ImageFrame.Image.Height * 4];
}
ConvertDepthFrame(e.ImageFrame.Image.Bits);
if (DepthBitmap == null)
{
DepthBitmap = new WriteableBitmap(e.ImageFrame.Image.Width, e.ImageFrame.Image.Height, 96, 96, PixelFormats.Bgra32, null);
}
DepthBitmap.Lock();
int stride = DepthBitmap.PixelWidth * DepthBitmap.Format.BitsPerPixel / 8;
Int32Rect dirtyRect = new Int32Rect(0, 0, DepthBitmap.PixelWidth, DepthBitmap.PixelHeight);
DepthBitmap.WritePixels(dirtyRect, depthFrame32, stride, 0);
DepthBitmap.AddDirtyRect(dirtyRect);
DepthBitmap.Unlock();
RaisePropertyChanged(()=>DepthBitmap);
}
private void plotButton_click(object sender, RoutedEventArgs e)
{
if (graphBitmap == null)
{
graphBitmap = new WriteableBitmap(pixelWidth, pixelHeight, dpiX, dpiY, PixelFormats.Gray8, null);
}
Action doPlotButtonWorkAction = new Action(doPlotButtonWork);
doPlotButtonWorkAction.BeginInvoke(null, null);
#region 注释掉的内容
//int byetePerPixel = (graphBitmap.Format.BitsPerPixel + 7) / 8;
//int stride = byetePerPixel * graphBitmap.PixelWidth;
//int dataSize = stride * graphBitmap.PixelHeight;
//byte[] data = new byte[dataSize];
//Stopwatch watch = new Stopwatch();
////generateGraphData(data);
////新建线程
//Task first = Task.Factory.StartNew(()=>generateGraphData(data,0,pixelWidth/8));
//Task second = Task.Factory.StartNew(() => generateGraphData(data, pixelWidth / 8, pixelWidth / 4));
//Task first1 = Task.Factory.StartNew(() => generateGraphData(data, pixelWidth / 4, pixelWidth / 2));
//Task second1 = Task.Factory.StartNew(() => generateGraphData(data, pixelWidth / 2, pixelWidth));
//Task.WaitAll(first, second,first1,second1);
//duration.Content = string.Format("Duration (ms):{0}", watch.ElapsedMilliseconds);
//graphBitmap.WritePixels(new Int32Rect(0, 0, graphBitmap.PixelWidth, graphBitmap.PixelHeight), data, stride, 0);
//graphImage.Source = graphBitmap;
#endregion
}
public void Create(int width, int height, PixelFormat pixelFormat)
{
swm.PixelFormat format;
switch (pixelFormat)
{
/*case PixelFormat.Format16bppRgb555:
* format = swm.PixelFormats.Bgr555;
* break;*/
case PixelFormat.Format24bppRgb:
format = swm.PixelFormats.Bgr24;
break;
case PixelFormat.Format32bppRgb:
format = swm.PixelFormats.Bgr32;
break;
case PixelFormat.Format32bppRgba:
format = swm.PixelFormats.Pbgra32;
break;
default:
throw new NotSupportedException();
}
ApplicationHandler.InvokeIfNecessary(() =>
{
var bf = new swm.Imaging.WriteableBitmap(width, height, 96, 96, format, null);
Control = bf;
});
}
protected override async void OnNavigatedTo(NavigationEventArgs e) {
StreamResourceInfo sri = Application.GetResourceStream(new Uri("DemoImage.jpg", UriKind.Relative));
var myBitmap = new WriteableBitmap(800, 480);
img.ImageSource = myBitmap;
using (var editsession = await EditingSessionFactory.CreateEditingSessionAsync(sri.Stream)) {
// First add an antique effect
editsession.AddFilter(FilterFactory.CreateCartoonFilter(true));
editsession.AddFilter(FilterFactory.CreateAntiqueFilter());
// Then rotate the image
editsession.AddFilter(FilterFactory.CreateFreeRotationFilter(35.0f, RotationResizeMode.FitInside));
await editsession.RenderToBitmapAsync(myBitmap.AsBitmap());
}
myBitmap.Invalidate();
base.OnNavigatedTo(e);
}
public WriteableBitmap Render(int[] values)
{
if (values.Length != this.pixels.Length)
{
throw new ArgumentException("Number of raw values must equal width*height");
}
// Convert raw values to ARGB format pixels.
this.ConvertToPixels(values);
// Copy pixels to frame buffer.
var bitmap = new WriteableBitmap( this.width,
this.height,
0,
0,
PixelFormats.Pbgra32,
null);
int widthInBytes = 4 * this.width;
var sourceRect = new Int32Rect(0, 0, this.width, this.height);
bitmap.WritePixels( sourceRect,
pixels,
widthInBytes,
0);
return bitmap;
}
unsafe bool Close()
{
CloseGroup();
if (image != null)
{
Control.Close();
var handler = (BitmapHandler)image.Handler;
var bmp = image.ToWpf();
var newbmp = new swmi.RenderTargetBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Pbgra32);
newbmp.RenderWithCollect(visual);
if (!bmp.Format.HasAlpha())
{
// convert to non-alpha, as RenderTargetBitmap does not support anything other than Pbgra32
var wb = new swmi.WriteableBitmap(bmp.PixelWidth, bmp.PixelHeight, bmp.DpiX, bmp.DpiY, swm.PixelFormats.Bgr32, null);
var rect = new sw.Int32Rect(0, 0, bmp.PixelWidth, bmp.PixelHeight);
var pixels = new byte[bmp.PixelHeight * wb.BackBufferStride];
newbmp.CopyPixels(rect, pixels, wb.BackBufferStride, 0);
fixed(byte *ptr = pixels)
{
wb.WritePixels(rect, (IntPtr)ptr, pixels.Length, wb.BackBufferStride, 0, 0);
}
handler.SetBitmap(wb);
}
else
{
handler.SetBitmap(newbmp);
}
return(true);
}
return(false);
}
public unsafe void CreateImage(WriteableBitmap target, IntPtr pointer)
{
Int32Rect rectangle = default(Int32Rect);
target.Dispatcher.Invoke(new Action(() =>
{
rectangle = new Int32Rect(0, 0, target.PixelWidth, target.PixelHeight);
}));
byte* pImage = (byte*)pointer.ToPointer();
var pixelCount = rectangle.Width * rectangle.Height;
var buffer = new byte[pixelCount * 3];
for (int index = 0; index < pixelCount; index++)
{
buffer[index * 3] = pImage[2];
buffer[index * 3 + 1] = pImage[1];
buffer[index * 3 + 2] = pImage[0];
pImage += 3;
}
target.Dispatcher.Invoke(new Action(() =>
{
target.Lock();
target.WritePixels(rectangle, buffer, rectangle.Width * 3, 0);
target.Unlock();
}));
}
/// <summary>
/// Creates a new RenderTargetImageSource.
/// </summary>
/// <param name="graphics">The GraphicsDevice to use.</param>
/// <param name="width">The width of the image source.</param>
/// <param name="height">The height of the image source.</param>
public RenderTargetImageSource(GraphicsDevice graphics, int width, int height)
{
// create the render target and buffer to hold the data
renderTarget = new RenderTarget2D(graphics, width, height, false, SurfaceFormat.Color, DepthFormat.Depth24Stencil8);
buffer = new byte[width * height * 4];
writeableBitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Bgra32, null);
}
private void NewCommand(object sender, ExecutedRoutedEventArgs e)
{
var dlog = new NewDocument
{
Owner = this
};
var result = dlog.ShowDialog();
if (!result.HasValue || !result.Value)
{
return;
}
var bmp = new WriteableBitmap(
dlog.ViewModel.Width,
dlog.ViewModel.Height,
96,
96,
PixelFormats.Bgr32,
null);
_picture = new Picture(dlog.ViewModel.Name, bmp);
Title = _picture.Name;
ViewModel.Document = new ReversibleDocument<IPicture>(_picture);
ViewModel.AccessPolicy = new PictureAccessPolicy(_picture);
_image.Source = bmp;
_image.Stretch = Stretch.None;
RenderOptions.SetBitmapScalingMode(_image, BitmapScalingMode.NearestNeighbor);
RenderOptions.SetEdgeMode(_image, EdgeMode.Aliased);
}
void updateMyBg()
{
try
{
using (var store = System.IO.IsolatedStorage.IsolatedStorageFile.GetUserStoreForApplication())
{
using (var str = store.OpenFile("bing.jpg", FileMode.Open))
{
System.Windows.Media.Imaging.WriteableBitmap wb = new System.Windows.Media.Imaging.WriteableBitmap(480, 800);
BitmapImage bimg = new BitmapImage();
bimg.SetSource(str);
image1.Source = bimg;
}
}
}
catch
{
System.Windows.Threading.DispatcherTimer tim = new System.Windows.Threading.DispatcherTimer();
tim.Interval = TimeSpan.FromSeconds(2);
tim.Tick += new EventHandler((o, e) =>
{
updateMyBg();
tim.Stop();
});
tim.Start();
}
}
public static byte[] toByte(Image img)
{
BitmapImage bmpToArray = img.Source as BitmapImage;
WriteableBitmap wb = new WriteableBitmap(bmpToArray);
MemoryStream msWrite = new MemoryStream();
wb.SaveJpeg(msWrite, 100, 100, 0, 90);
msWrite.Seek(0, SeekOrigin.Begin);
if (msWrite != null)
{
msWrite.Position = 0;
MemoryStream ms = new MemoryStream();
byte[] buffer = new byte[msWrite.Length];
int read;
while ((read = msWrite.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
return buffer;
}
return null;
}
/// <summary>
/// WriteableBitmap -> IplImage
/// </summary>
private void TestWriteableBitmap()
{
// Load 16-bit image to WriteableBitmap
PngBitmapDecoder decoder = new PngBitmapDecoder(
new Uri(FilePath.Image.Depth16Bit, UriKind.Relative),
BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default
);
BitmapSource bs = decoder.Frames[0];
WriteableBitmap wb = new WriteableBitmap(bs);
// Convert wb into IplImage
IplImage ipl = wb.ToIplImage();
//IplImage ipl32 = new IplImage(wb.PixelWidth, wb.PixelHeight, BitDepth.U16, 1);
//WriteableBitmapConverter.ToIplImage(wb, ipl32);
// Print pixel values
for (int i = 0; i < ipl.Height; i++)
{
Console.WriteLine("x:{0} y:{1} v:{2}", i, i, ipl[i, 128]);
}
// Show 16-bit IplImage
using (new CvWindow("from WriteableBitmap to IplImage", ipl))
{
Cv.WaitKey();
}
}
void GetRequestStreamCallback(IAsyncResult callbackResult)
{
HttpWebRequest myRequest = (HttpWebRequest)callbackResult.AsyncState;
// End the stream request operation
Stream postStream = myRequest.EndGetRequestStream(callbackResult);
var settings = IsolatedStorageSettings.ApplicationSettings;
String token ="";
if (settings.Contains("tokken"))
{
token = settings["tokken"].ToString();
}
// Create the post data
string postData = "tokken=" + token + "&attrId=30";
MemoryStream ms = new MemoryStream();
WriteableBitmap btmMap = new WriteableBitmap(photo.PixelWidth,photo.PixelHeight);
// write an image into the stream
Extensions.SaveJpeg(btmMap, ms,
photo.PixelWidth, photo.PixelHeight, 0, 100);
//this.WriteEntry(postStream, "image",ms.ToArray());
byte[] byteArray = Encoding.UTF8.GetBytes(postData);
// Add the post data to the web request
postStream.Write(byteArray, 0, byteArray.Length);
postStream.Close();
// Start the web request
myRequest.BeginGetResponse(new AsyncCallback(GetResponsetStreamCallback), myRequest);
}
public static WriteableBitmap DecodeJpeg(Stream srcStream)
{
// Decode JPEG
var decoder = new FluxJpeg.Core.Decoder.JpegDecoder(srcStream);
var jpegDecoded = decoder.Decode();
var img = jpegDecoded.Image;
img.ChangeColorSpace(ColorSpace.RGB);
// Init Buffer
int w = img.Width;
int h = img.Height;
var result = new WriteableBitmap(w, h);
int[] p = result.Pixels;
byte[][,] pixelsFromJpeg = img.Raster;
// Copy FluxJpeg buffer into WriteableBitmap
int i = 0;
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
p[i++] = (0xFF << 24) // A
| (pixelsFromJpeg[0][x, y] << 16) // R
| (pixelsFromJpeg[1][x, y] << 8) // G
| pixelsFromJpeg[2][x, y]; // B
}
}
return result;
}
public FrameData( WriteableBitmap depth, WriteableBitmap color, double lat, double lng )
{
depthBitmap = depth;
colorBitmap = color;
latitude = lat;
longitude = lng;
}
public byte[] DoCapture()
{
FrameworkElement toSnap = null;
if (!AutomationIdIsEmpty)
toSnap = GetFrameworkElement(false);
if (toSnap == null)
toSnap = AutomationElementFinder.GetRootVisual();
if (toSnap == null)
return null;
// Save to bitmap
var bmp = new WriteableBitmap((int)toSnap.ActualWidth, (int)toSnap.ActualHeight);
bmp.Render(toSnap, null);
bmp.Invalidate();
// Get memoryStream from bitmap
using (var memoryStream = new MemoryStream())
{
bmp.SaveJpeg(memoryStream, bmp.PixelWidth, bmp.PixelHeight, 0, 95);
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream.GetBuffer();
}
}
void WebClientOpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
const string tempJpeg = "TempJPEG";
var streamResourceInfo = new StreamResourceInfo(e.Result, null);
var userStoreForApplication = IsolatedStorageFile.GetUserStoreForApplication();
if (userStoreForApplication.FileExists(tempJpeg))
{
userStoreForApplication.DeleteFile(tempJpeg);
}
var isolatedStorageFileStream = userStoreForApplication.CreateFile(tempJpeg);
var bitmapImage = new BitmapImage { CreateOptions = BitmapCreateOptions.None };
bitmapImage.SetSource(streamResourceInfo.Stream);
var writeableBitmap = new WriteableBitmap(bitmapImage);
writeableBitmap.SaveJpeg(isolatedStorageFileStream, writeableBitmap.PixelWidth, writeableBitmap.PixelHeight, 0, 85);
isolatedStorageFileStream.Close();
isolatedStorageFileStream = userStoreForApplication.OpenFile(tempJpeg, FileMode.Open, FileAccess.Read);
// Save the image to the camera roll or saved pictures album.
var mediaLibrary = new MediaLibrary();
// Save the image to the saved pictures album.
mediaLibrary.SavePicture(string.Format("SavedPicture{0}.jpg", DateTime.Now), isolatedStorageFileStream);
isolatedStorageFileStream.Close();
}
async void GeneratePicture()
{
if (rendering) return;
ProgressIndicator prog = new ProgressIndicator();
prog.IsIndeterminate = true;
prog.Text = "Rendering";
prog.IsVisible = true;
SystemTray.SetProgressIndicator(this, prog);
var bmp = new WriteableBitmap(480, 800);
try
{
rendering = true;
using (var renderer = new WriteableBitmapRenderer(manager, bmp, OutputOption.PreserveAspectRatio))
{
display.Source = await renderer.RenderAsync();
}
SystemTray.SetProgressIndicator(this, null);
rendering = false;
}
finally
{
}
}
void UpdateTiledImage() {
if(sourceBitmap == null)
return;
var width = (int)Math.Ceiling(ActualWidth);
var height = (int)Math.Ceiling(ActualHeight);
// only regenerate the image if the width/height has grown
if(width < lastWidth && height < lastHeight)
return;
lastWidth = width;
lastHeight = height;
var final = new WriteableBitmap(width, height);
for(var x = 0; x < final.PixelWidth; x++) {
for(var y = 0; y < final.PixelHeight; y++) {
var tiledX = (x % sourceBitmap.PixelWidth);
var tiledY = (y % sourceBitmap.PixelHeight);
final.Pixels[y * final.PixelWidth + x] = sourceBitmap.Pixels[tiledY * sourceBitmap.PixelWidth + tiledX];
}
}
tiledImage.Source = final;
}
public RecordedVideoFrame(ColorImageFrame colorFrame)
{
if (colorFrame != null)
{
byte[] bits = new byte[colorFrame.PixelDataLength];
colorFrame.CopyPixelDataTo(bits);
int BytesPerPixel = colorFrame.BytesPerPixel;
int Width = colorFrame.Width;
int Height = colorFrame.Height;
var bmp = new WriteableBitmap(Width, Height, 96, 96, PixelFormats.Bgr32, null);
bmp.WritePixels(new System.Windows.Int32Rect(0, 0, Width, Height), bits, Width * BytesPerPixel, 0);
JpegBitmapEncoder jpeg = new JpegBitmapEncoder();
jpeg.Frames.Add(BitmapFrame.Create(bmp));
var SaveStream = new MemoryStream();
jpeg.Save(SaveStream);
SaveStream.Flush();
JpegData = SaveStream.ToArray();
}
else
{
return;
}
}
Stream GetPngStream(WriteableBitmap bmp)
{
// Use Joe Stegman's PNG Encoder
// http://bit.ly/77mDsv
EditableImage imageData = new EditableImage(bmp.PixelWidth, bmp.PixelHeight);
for (int y = 0; y < bmp.PixelHeight; ++y)
{
for (int x = 0; x < bmp.PixelWidth; ++x)
{
int pixel = bmp.Pixels[bmp.PixelWidth * y + x];
imageData.SetPixel(x, y,
(byte)((pixel >> 16) & 0xFF),
(byte)((pixel >> 8) & 0xFF),
(byte)(pixel & 0xFF),
(byte)((pixel >> 24) & 0xFF)
);
}
}
return imageData.GetStream();
}
private void PreparePopups()
{
if (theHelpPopup == null)
{
theHelpPopup = new Popup();
theHelpPopup.Child = new HelpPopup();
theHelpPopup.VerticalOffset = 200;
theHelpPopup.HorizontalOffset = 0;
theHelpPopup.Closed += (sender1, e1) =>
{
this.ApplicationBar.IsVisible = true;
};
}
if (theSavePopup == null)
{
theSavePopup = new Popup();
theSavePopup.Child = new HelpSavePopup();
theSavePopup.VerticalOffset = 70;
theSavePopup.HorizontalOffset = 0;
theSavePopup.Closed += (sender1, e1) =>
{
try
{
if (!backButtonPressedFlag)
{
var bitmap = new System.Windows.Media.Imaging.WriteableBitmap(this.LayoutRoot, null);
using (var stream = new System.IO.MemoryStream())
{
System.Windows.Media.Imaging.Extensions.SaveJpeg(bitmap, stream,
bitmap.PixelWidth, bitmap.PixelHeight, 0, 100);
stream.Position = 0;
var mediaLib = new Microsoft.Xna.Framework.Media.MediaLibrary();
var datetime = System.DateTime.Now;
var filename =
System.String.Format("LockScreen-{0}-{1}-{2}-{3}-{4}",
datetime.Year % 100, datetime.Month, datetime.Day,
datetime.Hour, datetime.Minute);
mediaLib.SavePicture(filename, stream);
var toast = new ToastPrompt
{
Title = "Saved",
Message = @"Your wallpaper is in ""Saved Pictures"""
};
toast.Show();
}
}
backButtonPressedFlag = false;
}
finally
{
UpdateMockup(false);
}
};
}
}
private WriteableBitmap WriteableBitmapBitmapFromBitmap(Bitmap writeBmp)
{
BitmapSource bitmapSource =
System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(writeBmp.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty,
System.Windows.Media.Imaging.BitmapSizeOptions.FromEmptyOptions());
WriteableBitmap writeableBitmap = new System.Windows.Media.Imaging.WriteableBitmap(bitmapSource);
return(writeableBitmap);
}
public BitmapData Lock()
{
var wb = Control as swmi.WriteableBitmap;
if (wb == null || RequiresFrozen)
{
wb = new swmi.WriteableBitmap(FrozenControl);
SetBitmap(wb);
}
wb.Lock();
return(new BitmapDataHandler(Widget, wb.BackBuffer, wb.BackBufferStride, wb.Format.BitsPerPixel, wb, wb.Format.IsPremultiplied()));
}
public static BitmapSource ToBitmapSource(this System.Drawing.Bitmap bmp)
{
var rect = new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height);
var bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
int bufferSize = bmpData.Stride * bmp.Height;
var bms = new System.Windows.Media.Imaging.WriteableBitmap(bmp.Width, bmp.Height, bmp.HorizontalResolution, bmp.VerticalResolution, PixelFormats.Bgr32, null);
bms.WritePixels(new Int32Rect(0, 0, bmp.Width, bmp.Height), bmpData.Scan0, bufferSize, bmpData.Stride);
bmp.UnlockBits(bmpData);
return(bms);
}
public static void setPixel(this System.Windows.Media.Imaging.WriteableBitmap wbm, int x, int y, System.Windows.Media.Color c)
{
if (y > wbm.PixelHeight - 1 || x > wbm.PixelWidth - 1)
{
return;
}
if (y < 0 || x < 0)
{
return;
}
wbm.Pixels[y * wbm.PixelWidth + x] = c.A << 24 | c.R << 16 | c.G << 8 | c.B;
}
public void LoadImageWPF(string filePath)
{
filePath = System.IO.Path.Combine(TestContext.CurrentContext.TestDirectory, filePath);
var uri = new Uri(filePath, UriKind.Absolute);
var image = new System.Windows.Media.Imaging.BitmapImage(uri);
var memory = image.ToMemoryBitmap();
memory.Save(AttachmentInfo.From("Result.png"));
var writable = new System.Windows.Media.Imaging.WriteableBitmap(image);
}
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
var photoBase64 = string.Empty;
var wbmp = new System.Windows.Media.Imaging.WriteableBitmap((System.Windows.Media.Imaging.BitmapSource)value);
//this.photo.Source
using (var ms = new System.IO.MemoryStream())
{
wbmp.SaveJpeg(ms, 640, 480, 0, 60);
return(System.Convert.ToBase64String(ms.ToArray()));
}
}
public BitmapData Lock()
{
return(ApplicationHandler.InvokeIfNecessary(() =>
{
var wb = Control as swmi.WriteableBitmap;
if (wb == null)
{
wb = new swmi.WriteableBitmap(Control);
SetBitmap(wb);
}
wb.Lock();
return new BitmapDataHandler(Widget, wb.BackBuffer, Stride, Control.Format.BitsPerPixel, wb);
}));
}
public override WriteableBitmap ApplyFunctionFilter(System.Windows.Media.Imaging.BitmapImage originalBitmapImage)
{
WriteableBitmap writableImage = new System.Windows.Media.Imaging.WriteableBitmap(originalBitmapImage);
byte[] byteArr = writableImage.WriteableBitMapImageToArray();
for (int i = 0; i < byteArr.Length; i++)
{
byteArr[i] = (byte)(255 - byteArr[i]);
}
WriteableBitmap result = originalBitmapImage.ByteArrayToWritableBitmap(byteArr);
return(result);
}
public static System.Windows.Media.Color getPixel(this System.Windows.Media.Imaging.WriteableBitmap wbm, int x, int y)
{
if (y > wbm.PixelHeight - 1 || x > wbm.PixelWidth - 1)
{
return(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
}
if (y < 0 || x < 0)
{
return(System.Windows.Media.Color.FromArgb(0, 0, 0, 0));
}
byte[] ARGB = BitConverter.GetBytes(wbm.Pixels[y * wbm.PixelWidth + x]);
return(System.Windows.Media.Color.FromArgb(ARGB[3], ARGB[2], ARGB[1], ARGB[0]));
}
public Bitmap Clone(Rectangle?rectangle = null)
{
if (rectangle != null)
{
var rect = rectangle.Value;
var data = new byte[Stride * Control.PixelHeight];
FrozenControl.CopyPixels(data, Stride, 0);
var target = new swmi.WriteableBitmap(rect.Width, rect.Height, Control.DpiX, Control.DpiY, Control.Format, Control.Palette);
target.WritePixels(rect.ToWpfInt32(), data, Stride, destinationX: 0, destinationY: 0);
return(new Bitmap(new BitmapHandler(target)));
}
else
{
return(new Bitmap(new BitmapHandler(FrozenControl.Clone())));
}
}
/// <summary>
/// Draw outline on image
/// </summary>
/// <param name="strategy">is text strategy</param>
/// <param name="image">is the image to be draw upon</param>
/// <param name="offset">offsets the text (typically used for shadows)</param>
/// <param name="textContext">is text context</param>
/// <returns>true if successful</returns>
public static bool DrawTextImage(
ITextStrategy strategy,
ref System.Windows.Media.Imaging.WriteableBitmap image,
System.Windows.Point offset,
TextContext textContext,
System.Windows.Media.Matrix mat)
{
if (strategy == null || image == null || textContext == null)
{
return(false);
}
RenderTargetBitmap bmp = new RenderTargetBitmap((int)(image.Width), (int)(image.Height), 96, 96, PixelFormats.Pbgra32);
DrawingVisual drawingVisual = new DrawingVisual();
DrawingContext drawingContext = drawingVisual.RenderOpen();
MatrixTransform mat_trans = new MatrixTransform();
mat_trans.Matrix = mat;
drawingContext.PushTransform(mat_trans);
drawingContext.DrawImage(image, new Rect(0.0, 0.0, image.Width, image.Height));
bool bRet = strategy.DrawString(drawingContext,
textContext.fontFamily,
textContext.fontStyle,
textContext.fontWeight,
textContext.nfontSize,
textContext.pszText,
new System.Windows.Point(textContext.ptDraw.X + offset.X, textContext.ptDraw.Y + offset.Y),
textContext.ci);
drawingContext.Pop();
drawingContext.Close();
bmp.Render(drawingVisual);
image = new System.Windows.Media.Imaging.WriteableBitmap(bmp);
return(bRet);
}
/*
* private void btn_DoubleTap(object sender, System.Windows.Input.GestureEventArgs e)
* {
* Button btn;
* btn = ((Button) sender);
* RscMediaLibItemDesc it;
* it = (RscMediaLibItemDesc) btn.Tag;
*
* if( it.bFolder )
* {
* //m_path.Push( it.sFn );
*
* //ListFiles();
* }
* else
* {
* //m_txtTitle.Text = "medlib:\\" + it.sFolderPath + "\\" + it.sName;
*
* m_btnImage.Visibility = Rsc.Visible;
* m_btnImage.Tag = it.sIndiciesToItem;
* m_btnImage.Image.Source = LoadImage( it, false, 96, 160 );
* }
* }
*/
private ImageSource LoadImage(RscMediaLibItemDesc it, bool bThumbnail, int iCX, int iCY)
{
if (it.bFolder)
{
return(m_AppFrame.Theme.GetImage("Images/Ico001_Ressive.jpg"));
}
// //
//
PictureAlbum pa = m_media.RootPictureAlbum;
Picture pic = null;
string [] asInd = it.sIndiciesToItem.Split('|');
int iCnt = asInd.Length;
for (int i = 0; i < iCnt; i++)
{
if (i == iCnt - 1)
{
pic = pa.Pictures[Int32.Parse(asInd[i])];
}
else
{
pa = pa.Albums[Int32.Parse(asInd[i])];
}
}
//
// //
if (bThumbnail)
{
System.Windows.Media.Imaging.WriteableBitmap wbmp =
Microsoft.Phone.PictureDecoder.DecodeJpeg(pic.GetThumbnail(), iCX, iCY);
return(wbmp);
}
else
{
BitmapImage bmp = new BitmapImage();
bmp.SetSource(pic.GetImage());
return(bmp);
}
}
public bool IfNewSizeResizeAndDraw(int width, int height)
{
if (m_wpfBitmap == null ||
m_wpfBitmap.PixelHeight != height ||
m_wpfBitmap.PixelWidth != width)
{
Reset();
// Can't dispose wpf
const double Dpi = 96;
m_wpfBitmap = new SWMI.WriteableBitmap(width, height, Dpi, Dpi,
SWM.PixelFormats.Bgr24, null);
var ptr = m_wpfBitmap.BackBuffer;
m_gdiBitmap = new Bitmap(width, height, m_wpfBitmap.BackBufferStride,
System.Drawing.Imaging.PixelFormat.Format24bppRgb, ptr);
Draw();
return(true);
}
return(false);
}
public BitmapData Lock()
{
BitmapDataHandler handler = null;
ApplicationHandler.InvokeIfNecessary(() => {
var wb = Control as swm.Imaging.WriteableBitmap;
if (wb != null)
{
wb.Lock();
handler = new BitmapDataHandler(Widget, wb.BackBuffer, (int)stride, Control.Format.BitsPerPixel, Control);
}
else
{
wb = new swm.Imaging.WriteableBitmap(Control);
wb.Lock();
Control = wb;
handler = new BitmapDataHandler(Widget, wb.BackBuffer, (int)stride, Control.Format.BitsPerPixel, wb);
}
});
return(handler);
}
public override WriteableBitmap ApplyFunctionFilter(System.Windows.Media.Imaging.BitmapImage originalBitmapImage)
{
WriteableBitmap writableImage = new System.Windows.Media.Imaging.WriteableBitmap(originalBitmapImage);
byte[] byteArr = writableImage.WriteableBitMapImageToArray();
int num = 0;
for (int i = 0; i < byteArr.Length; i++)
{
num = (int)(byteArr[i]);
int val = (int)_customFunction[num] + (int)this.Offset;
val = (val < 0 ? 0 : val);
val = (val > 255 ? 255 : val);
byteArr[i] = (byte)(val);
}
WriteableBitmap result = originalBitmapImage.ByteArrayToWritableBitmap(byteArr);
return(result);
}
public Bitmap Clone(Rectangle?rectangle = null)
{
swmi.BitmapSource clone = null;
ApplicationHandler.InvokeIfNecessary(() =>
{
if (rectangle != null)
{
var rect = rectangle.Value;
var data = new byte[Stride * Control.PixelHeight];
Control.CopyPixels(data, Stride, 0);
var target = new swmi.WriteableBitmap(rect.Width, rect.Height, Control.DpiX, Control.DpiY, Control.Format, null);
target.WritePixels(rect.ToWpfInt32(), data, Stride, destinationX: 0, destinationY: 0);
clone = target;
}
else
{
clone = Control.Clone();
}
});
return(new Bitmap(Generator, new BitmapHandler(clone)));
}
/*
* public override byte[] Function {
* get {
* byte[] function = new byte[256];
*
* int num = 0;
*
* int subvalues = 4;
* int length = 256 / subvalues;
* for (int i = 0; i * subvalues < length; i += subvalues) {
*
* int grayScalePx = (int)((i * .299) + ((i + 1) * .587) + ((i + 2) * .114));
*
* if (grayScalePx < this.Offset)
* num = 0;
* else
* num = 255;
*
* for (int j = i; j < (i + subvalues); j++) {
* function[j] = (byte)num;
* }
* }
*
* _function = function;
* return _function;
* }
* set {
* base.Function = value;
* }
* }
*/
public override WriteableBitmap ApplyFunctionFilter(System.Windows.Media.Imaging.BitmapImage originalBitmapImage)
{
WriteableBitmap writableImage = new System.Windows.Media.Imaging.WriteableBitmap(originalBitmapImage);
byte[] byteArr = writableImage.WriteableBitMapImageToArray();
for (int i = 0; i < byteArr.Length; i += 4)
{
byte a = byteArr[i + 3];
if (a > 0)
{
double ad = (double)a / 255.0;
double rd = (double)byteArr[i + 2] / ad;
double gd = (double)byteArr[i + 1] / ad;
double bd = (double)byteArr[i + 0] / ad;
double luminance = 0.2126 * rd + 0.7152 * gd + 0.0722 * bd;
double newR = luminance * ad;
if (newR < this.Offset)
{
newR = 0;
}
else
{
newR = 255;
}
byteArr[i + 0] = (byte)newR;
byteArr[i + 1] = (byte)newR;
byteArr[i + 2] = (byte)newR;
}
}
WriteableBitmap result = originalBitmapImage.ByteArrayToWritableBitmap(byteArr);
return(result);
}
internal void CreateCameraViewWpfBitmapSource()
{
try
{
var capture = Device.CameraViewImageSourceBitmapCapture;
var width = capture.CameraViewImageSourceBitmapSize.Width;
var height = capture.CameraViewImageSourceBitmapSize.Height;
Debug.Assert(width > 0 && height > 0);
CameraViewWpfBitmapSource = new System.Windows.Media.Imaging.WriteableBitmap(width, height, 96, 96, System.Windows.Media.PixelFormats.Bgr24, null);
CameraViewWpfBitmapSourceWidth = width;
CameraViewWpfBitmapSourceHeight = height;
CameraViewWpfBitmapSourceWritePixelsSourceRect = new System.Windows.Int32Rect(0, 0, width, height);
}
catch (Exception ex)
{
if (ApplicationCommonSettings.IsDebugging)
{
Debugger.Break();
}
Debug.WriteLine(ex.Message);
}
}
private async void addPhoto(bool takeNew)
{
//Capture photo file from view
var picker = new Xamarin.Media.MediaPicker();
var options = new Xamarin.Media.StoreCameraMediaOptions();
var mediaFileSource = this.GetService <Core.Interfaces.IMediaFileSource>();
MediaFile mediaFile = null;
try { mediaFile = await mediaFileSource.GetPhoto(takeNew); }
catch { }
if (mediaFile != null && !string.IsNullOrEmpty(mediaFile.Path))
{
this.Dispatcher.BeginInvoke(() =>
{
this.Photo = new System.Windows.Media.Imaging.BitmapImage();
this.Photo.SetSource(mediaFile.GetStream());
var photoBase64 = string.Empty;
var wbmp = new System.Windows.Media.Imaging.WriteableBitmap(this.Photo);
using (var ms = new System.IO.MemoryStream())
{
wbmp.SaveJpeg(ms, 640, 480, 0, 60);
photoBase64 = Convert.ToBase64String(ms.ToArray());
}
this.ViewModel.AddPhoto(photoBase64);
//Clean up!
mediaFile.Dispose();
});
}
}
private void PrintDepthOnCanvas(short[] imageArray, Image canvas, int width, int height, int max)
{
try
{
System.Windows.Media.Imaging.WriteableBitmap colorBitmap = new System.Windows.Media.Imaging.WriteableBitmap(width, height, 96.0, 96.0, System.Windows.Media.PixelFormats.Bgr32, null);
byte[] pixels = new byte[imageArray.Length * 4];
int pixelsIndex = 0;
for (int i = 0; i < imageArray.Length; i++)
{
float relativeDepth = Convert.ToInt16(imageArray[i]) / (float)max;
System.Drawing.Color c = RelativeDepthToColor(relativeDepth);
pixels[pixelsIndex++] = c.B;
pixels[pixelsIndex++] = c.G;
pixels[pixelsIndex++] = c.R;
pixels[pixelsIndex++] = c.A;
}
colorBitmap.WritePixels(
new System.Windows.Int32Rect(0, 0, width, height),
pixels,
width * sizeof(int),
0);
colorBitmap.Freeze();
canvas.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal, (ThreadStart) delegate()
{
canvas.Source = colorBitmap;
});
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Apply shadow to mask onto the canvas
/// </summary>
/// <param name="clrShadow">is the color to be used</param>
/// <param name="mask">is the mask image to be read</param>
/// <param name="canvas">is the destination image to be draw upon</param>
/// <param name="maskColor">is mask color used in mask image</param>
/// <param name="offset">determine how much to offset the mask</param>
/// <returns>true if successful</returns>
public static bool ApplyShadowToMask(
System.Windows.Media.Color clrShadow,
System.Windows.Media.Imaging.WriteableBitmap mask,
System.Windows.Media.Imaging.WriteableBitmap canvas,
System.Windows.Media.Color maskColor,
System.Windows.Point offset)
{
if (mask == null || canvas == null)
{
return(false);
}
mask.Lock();
canvas.Lock();
unsafe
{
uint *pixelsMask = (uint *)mask.BackBuffer;
uint *pixelsCanvas = (uint *)canvas.BackBuffer;
if (pixelsMask == null || pixelsCanvas == null)
{
return(false);
}
uint col = 0;
int stride = canvas.BackBufferStride >> 2;
for (int row = 0; row < canvas.Height; ++row)
{
uint total_row_len = (uint)(row * stride);
uint total_row_mask_len = (uint)((row - (int)offset.Y) * (mask.BackBufferStride >> 2));
for (col = 0; col < canvas.Width; ++col)
{
if (row - (int)offset.Y >= mask.Height || col - (int)offset.X >= mask.Width ||
row - (int)offset.Y < 0 || col - (int)offset.X < 0)
{
continue;
}
uint index = total_row_len + col;
uint indexMask = (uint)(total_row_mask_len + (col - (int)offset.X));
byte maskByte = 0;
if (MaskColor.IsEqual(maskColor, MaskColor.Red))
{
maskByte = (Byte)((pixelsMask[indexMask] & 0xff0000) >> 16);
}
else if (MaskColor.IsEqual(maskColor, MaskColor.Green))
{
maskByte = (Byte)((pixelsMask[indexMask] & 0xff00) >> 8);
}
else if (MaskColor.IsEqual(maskColor, MaskColor.Blue))
{
maskByte = (Byte)(pixelsMask[indexMask] & 0xff);
}
uint color = (uint)(0xff << 24 | clrShadow.R << 16 | clrShadow.G << 8 | clrShadow.B);
if (maskByte > 0)
{
uint maskAlpha = (pixelsMask[indexMask] >> 24);
pixelsCanvas[index] = Alphablend(pixelsCanvas[index], color, (Byte)(maskAlpha), (Byte)(maskAlpha * clrShadow.A / 255));
}
}
}
}
canvas.Unlock();
mask.Unlock();
return(true);
}
/// <summary>
/// Apply image to mask onto the canvas
/// </summary>
/// <param name="image">is the image to be used</param>
/// <param name="mask">is the mask image to be read</param>
/// <param name="canvas">is the destination image to be draw upon</param>
/// <param name="maskColor">is mask color used in mask image</param>
/// <returns>true if successful</returns>
public static bool ApplyImageToMask(
System.Windows.Media.Imaging.WriteableBitmap image,
System.Windows.Media.Imaging.WriteableBitmap mask,
System.Windows.Media.Imaging.WriteableBitmap canvas,
System.Windows.Media.Color maskColor,
bool NoAlphaAtBoundary)
{
if (image == null || mask == null || canvas == null)
{
return(false);
}
image.Lock();
mask.Lock();
canvas.Lock();
unsafe
{
uint *pixelsImage = (uint *)image.BackBuffer;
uint *pixelsMask = (uint *)mask.BackBuffer;
uint *pixelsCanvas = (uint *)canvas.BackBuffer;
if (pixelsImage == null || pixelsMask == null || pixelsCanvas == null)
{
return(false);
}
uint col = 0;
int stride = canvas.BackBufferStride >> 2;
for (uint row = 0; row < canvas.Height; ++row)
{
uint total_row_len = (uint)(row * stride);
uint total_row_mask_len = (uint)(row * (mask.BackBufferStride >> 2));
uint total_row_image_len = (uint)(row * (image.BackBufferStride >> 2));
for (col = 0; col < canvas.Width; ++col)
{
if (row >= image.Height || col >= image.Width)
{
continue;
}
if (row >= mask.Height || col >= mask.Width)
{
continue;
}
uint index = total_row_len + col;
uint indexMask = total_row_mask_len + col;
uint indexImage = total_row_image_len + col;
byte maskByte = 0;
if (MaskColor.IsEqual(maskColor, MaskColor.Red))
{
maskByte = (Byte)((pixelsMask[indexMask] & 0xff0000) >> 16);
}
else if (MaskColor.IsEqual(maskColor, MaskColor.Green))
{
maskByte = (Byte)((pixelsMask[indexMask] & 0xff00) >> 8);
}
else if (MaskColor.IsEqual(maskColor, MaskColor.Blue))
{
maskByte = (Byte)(pixelsMask[indexMask] & 0xff);
}
if (maskByte > 0)
{
if (NoAlphaAtBoundary)
{
pixelsCanvas[index] = AlphablendNoAlphaAtBoundary(pixelsCanvas[index], pixelsImage[indexImage], (Byte)(pixelsMask[indexMask] >> 24), (Byte)(pixelsMask[indexMask] >> 24));
}
else
{
pixelsCanvas[index] = Alphablend(pixelsCanvas[index], pixelsImage[indexImage], (Byte)(pixelsMask[indexMask] >> 24), (Byte)(pixelsMask[indexMask] >> 24));
}
}
}
}
}
canvas.Unlock();
mask.Unlock();
image.Unlock();
return(true);
}
