public RgbImageAdapter(string path)
{
this.source = new BitmapImage(new Uri(path));
if (source.Format != PixelFormats.Bgra32)
{
source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
}
int width = source.PixelWidth;
int height = source.PixelHeight;
RgbPixel[,] result = new RgbPixel[height, width];
byte[] byteArray = new byte[height * width * 4];
int stride = width * 4;
source.CopyPixels(byteArray, stride, 0);
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
result[i, j] = new RgbPixel
{
Blue = byteArray[(i * width + j) * 4 + 0],
Green = byteArray[(i * width + j) * 4 + 1],
Red = byteArray[(i * width + j) * 4 + 2],
Alpha = byteArray[(i * width + j) * 4 + 3],
};
}
}
image = new RgbImage(result);
}
static void Main(string[] args)
{
List <Image> imagesArray = new System.Collections.Generic.List <Image>();
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(@"C:\CosaHelperLib");
foreach (System.IO.FileInfo file in dir.GetFiles())
{
String ext = file.Extension;
Console.WriteLine(file.FullName);
if (ext.Equals(".ico"))
{
Stream iconStream = new FileStream(file.FullName, FileMode.Open);
IconBitmapDecoder decoder = new IconBitmapDecoder(iconStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
foreach (var item in decoder.Frames)
{
var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();
src.BeginInit();
src.Source = item;
src.EndInit();
Console.WriteLine(file.FullName + '_' + src.PixelHeight + 'X' + src.PixelWidth);
//Console.WriteLine("Pixel Width: " + src.PixelWidth);
//Console.WriteLine("Pixel Height: " + src.PixelHeight);
//Console.WriteLine("Pixel Width: " + src.PixelWidth);
Console.WriteLine("Alpha Channel Threshold: " + src.AlphaThreshold);
}
}
Console.WriteLine();
}
Console.Read();
}
private byte[] RenderCurve(
ref RenderTargetBitmap rtb,
ref FormatConvertedBitmap fcb,
int width,
IEnumerable<IList<Point>> collection,
double thickness,
int miterLimit,
int height,
int stride)
{
if (rtb == null
|| rtb.PixelWidth != width
|| rtb.PixelHeight != height)
{
rtb = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Pbgra32);
fcb = new FormatConvertedBitmap(rtb, DrawingParameter.TargetPixelFormat, DrawingParameter.TargetBitmapPalette, 1);
}
else
{
rtb.Clear();
}
collection
.Select(it =>
{
var visual = _drawingVisualFactory();
visual.Draw(it, thickness, miterLimit, _logicalToScreenMapperFactory());
return visual;
})
.ForEachElement(rtb.Render);
var curvePixels = new byte[stride * height];
fcb.CopyPixels(curvePixels, stride, 0);
return curvePixels;
}
public void Button1_Click(object sender, RoutedEventArgs e)
{
try
{
BitmapImage myBitmapImage = new BitmapImage();
myBitmapImage.BeginInit();
myBitmapImage.UriSource = new Uri(@text1.Text);
myBitmapImage.EndInit();
FormatConvertedBitmap gray = new FormatConvertedBitmap(myBitmapImage, PixelFormats.Gray4, null, 0);
myImage.Source = gray;
var enc = new JpegBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(gray));
using (var s = File.Create("gray.jpg"))
enc.Save(s);
}
catch
{
text1.Text = "Не верно введен путь";
}
/* public void Button2_Click(object sender, RoutedEventArgs e)
{
BitmapImage myBitmapImage = new BitmapImage();
myBitmapImage.BeginInit();
myBitmapImage.UriSource=new Uri(myImage);
myBitmapImage.EndInit();
var enc = new JpegBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(gray));
using (var s = File.Create("gray.jpg"))
enc.Save(s);*/
}
/// <summary>
/// Cashes original ImageSource, creates and caches greyscale ImageSource and greyscale opacity mask
/// </summary>
private void SetSources()
{
_sourceC = Source;
try
{
// create and cache greyscale ImageSource
_sourceG = new FormatConvertedBitmap(new BitmapImage(new Uri(TypeDescriptor.GetConverter(Source).ConvertTo(Source, typeof(string)) as string)),
PixelFormats.Gray16, null, 0);
// create Opacity Mask for greyscale image as FormatConvertedBitmap does not keep transparency info
_opacityMaskG = new ImageBrush(_sourceC);
_opacityMaskG.Opacity = 0.5;
this.Source = IsEnabled ? _sourceC : _sourceG;
this.OpacityMask = IsEnabled ? _opacityMaskC : _opacityMaskG;
InvalidateProperty(IsEnabledProperty);
}
catch
{
#if DEBUG
MessageBox.Show(String.Format("The ImageSource used cannot be greyed out.\nUse BitmapImage or URI as a Source in order to allow greyscaling.\nSource type used: {0}", Source.GetType().Name),
"Unsupported Source in GreyableImage", MessageBoxButton.OK, MessageBoxImage.Warning);
#endif // DEBUG
// in case greyscale image cannot be created set greyscale source to original Source
_sourceG = Source;
}
}
public MemoryStream ReduceColorDepth(Bitmap bmp)
{
var ms = new MemoryStream();
bmp.Save(ms, ImageFormat.Png);
var bi = new BitmapImage();
bi.BeginInit();
bi.StreamSource = ms;
bi.EndInit();
var newFormatedBitmapSource = new FormatConvertedBitmap();
newFormatedBitmapSource.BeginInit();
newFormatedBitmapSource.Source = bi;
var myPalette = new BitmapPalette(bi, 256);
newFormatedBitmapSource.DestinationPalette = myPalette;
//Set PixelFormats
newFormatedBitmapSource.DestinationFormat = PixelFormats.Indexed8;
newFormatedBitmapSource.EndInit();
var pngBitmapEncoder = new PngBitmapEncoder();
pngBitmapEncoder.Interlace = PngInterlaceOption.Off;
pngBitmapEncoder.Frames.Add(BitmapFrame.Create(newFormatedBitmapSource));
var memstream = new MemoryStream();
pngBitmapEncoder.Save(memstream);
memstream.Position = 0;
return memstream;
}
public static System.Drawing.Bitmap setPixelFormat2(BitmapSource bitmapsource, System.Drawing.Imaging.PixelFormat format)
{
//convert image format
var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();
src.BeginInit();
src.Source = bitmapsource;
if (format == System.Drawing.Imaging.PixelFormat.Format1bppIndexed)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.BlackWhite;
}
if (format == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Gray8;
}
if (format == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr24;
}
if (format == System.Drawing.Imaging.PixelFormat.Format32bppRgb)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr32;
}
src.EndInit();
//copy to bitmap
Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, format);
var data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, format);
src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
bitmap.UnlockBits(data);
return bitmap;
}
public static void DrawImage (this ConsoleBuffer @this, ImageSource imageSource, int x, int y, int width, int height)
{
var bmp = imageSource as BitmapSource;
if (bmp == null)
throw new ArgumentException("Only rendering of bitmap source is supported.");
@this.OffsetX(ref x).OffsetY(ref y);
int x1 = x, x2 = x + width, y1 = y, y2 = y + height;
if ([email protected](ref x1, ref y1, ref x2, ref y2))
return;
if (width != bmp.PixelWidth || height != bmp.PixelHeight)
bmp = new TransformedBitmap(bmp, new ScaleTransform((double)width / bmp.PixelWidth, (double)height / bmp.PixelHeight));
if (bmp.Format != PixelFormats.Indexed4)
bmp = new FormatConvertedBitmap(bmp, PixelFormats.Indexed4, BitmapPalettes.Halftone8Transparent, 0.5);
const int bitsPerPixel = 4;
int stride = 4 * (bmp.PixelWidth * bitsPerPixel + 31) / 32;
byte[] bytes = new byte[stride * bmp.PixelHeight];
bmp.CopyPixels(bytes, stride, 0);
for (int iy = y1, py = 0; iy < y2; iy++, py++) {
ConsoleChar[] charsLine = @this.GetLine(iy);
for (int ix = x1, px = 0; ix < x2; ix++, px++) {
int byteIndex = stride * py + px / 2;
int bitOffset = px % 2 == 0 ? 4 : 0;
SetColor(ref charsLine[ix], bmp.Palette, (bytes[byteIndex] >> bitOffset) & 0xF);
}
}
}
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 converted = new swmi.FormatConvertedBitmap(newbmp, swm.PixelFormats.Bgr32, null, 0);
handler.SetBitmap(converted);
// 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 static bool[,] Rasterize(Point[] points, int width, int height)
{
Contract.Requires(points != null);
Contract.Requires(width > 0);
Contract.Requires(height > 0);
Contract.Requires(width % 8 == 0);
Contract.Ensures(Contract.Result<bool[,]>() != null);
Contract.Ensures(Contract.Result<bool[,]>().GetLength(0) == width);
Contract.Ensures(Contract.Result<bool[,]>().GetLength(1) == height);
var canvas = new Canvas { Background = Brushes.White, Width = width, Height = height };
var polygon = new Polygon { Stroke = Brushes.Black, Fill = Brushes.Black, StrokeThickness = 1, Points = new PointCollection(points) };
canvas.Children.Add(polygon);
RenderOptions.SetEdgeMode(canvas, EdgeMode.Aliased);
canvas.Measure(new Size(width, height));
canvas.Arrange(new Rect(0, 0, canvas.DesiredSize.Width, canvas.DesiredSize.Height));
var rtb = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
rtb.Render(canvas);
var fmb = new FormatConvertedBitmap(rtb, PixelFormats.BlackWhite, null, 0);
var pixels = new byte[width * height / 8];
fmb.CopyPixels(pixels, width / 8, 0);
System.Collections.BitArray ba = new System.Collections.BitArray(pixels);
var result = new bool[width, height];
for (int i = 0, y = 0; y < height; ++y)
for (int x = 0; x < width; ++x, ++i)
result[x, y] = !ba[i];
return result;
}
public override Stream OpenEntry(ArcFile arc, Entry entry)
{
var pent = entry as PnaEntry;
if (null == pent)
return base.OpenEntry (arc, entry);
ImageData image;
using (var input = arc.File.CreateStream (entry.Offset, entry.Size))
image = ImageFormat.Read (input);
var bitmap = image.Bitmap;
if (bitmap.Format.BitsPerPixel != 32)
{
bitmap = new FormatConvertedBitmap (bitmap, PixelFormats.Bgra32, null, 0);
}
int stride = bitmap.PixelWidth * 4;
var pixels = new byte[stride * bitmap.PixelHeight];
bitmap.CopyPixels (pixels, stride, 0);
// restore colors premultiplied by alpha
for (int i = 0; i < pixels.Length; i += 4)
{
int alpha = pixels[i+3];
if (alpha != 0 && alpha != 0xFF)
{
pixels[i] = (byte)(pixels[i] * 0xFF / alpha);
pixels[i+1] = (byte)(pixels[i+1] * 0xFF / alpha);
pixels[i+2] = (byte)(pixels[i+2] * 0xFF / alpha);
}
}
return TgaStream.Create (pent.Info, pixels);
}
public MyImageReader(string fileName)
{
var filePath = Path.Combine(Environment.CurrentDirectory, fileName);
_bitmap = new FormatConvertedBitmap(new BitmapImage(new Uri("file://" + filePath)), System.Windows.Media.PixelFormats.Bgr32, null, 0);
_pixels = new uint[_bitmap.PixelHeight * _bitmap.PixelWidth];
_bitmap.CopyPixels(_pixels, sizeof(uint) * _bitmap.PixelWidth, 0);
}
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");
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapSourceLuminanceSource"/> class.
/// </summary>
/// <param name="bitmap">The bitmap.</param>
public BitmapSourceLuminanceSource(BitmapSource bitmap)
: base(bitmap.PixelWidth, bitmap.PixelHeight)
{
switch (bitmap.Format.ToString())
{
case "Bgr24":
case "Bgr32":
CalculateLuminanceBGR(bitmap);
break;
case "Bgra32":
CalculateLuminanceBGRA(bitmap);
break;
case "Rgb24":
CalculateLuminanceRGB(bitmap);
break;
case "Bgr565":
CalculateLuminanceBGR565(bitmap);
break;
default:
// there is no special conversion routine to luminance values
// we have to convert the image to a supported format
bitmap = new FormatConvertedBitmap(bitmap, PixelFormats.Bgra32, null, 0);
CalculateLuminanceBGR(bitmap);
break;
}
}
public static System.Drawing.Bitmap setPixelFormat2(BitmapSource bitmapsource, System.Drawing.Imaging.PixelFormat format)
{
//convert image format
var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();
src.BeginInit();
src.Source = bitmapsource;
if (format == System.Drawing.Imaging.PixelFormat.Format1bppIndexed)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.BlackWhite;
}
if (format == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Gray8;
}
if (format == System.Drawing.Imaging.PixelFormat.Format24bppRgb)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr24;
}
if (format == System.Drawing.Imaging.PixelFormat.Format32bppRgb)
{
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgr32;
}
src.EndInit();
//copy to bitmap
Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, format);
var data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, format);
src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
bitmap.UnlockBits(data);
return(bitmap);
}
public static BitmapSource CreateThemedBitmapSource(BitmapSource src, Color bgColor, bool isHighContrast)
{
unchecked {
if (src.Format != PixelFormats.Bgra32)
src = new FormatConvertedBitmap(src, PixelFormats.Bgra32, null, 0.0);
var pixels = new byte[src.PixelWidth * src.PixelHeight * 4];
src.CopyPixels(pixels, src.PixelWidth * 4, 0);
var bg = HslColor.FromColor(bgColor);
int offs = 0;
while (offs + 4 <= pixels.Length) {
var hslColor = HslColor.FromColor(Color.FromRgb(pixels[offs + 2], pixels[offs + 1], pixels[offs]));
double hue = hslColor.Hue;
double saturation = hslColor.Saturation;
double luminosity = hslColor.Luminosity;
double n1 = Math.Abs(0.96470588235294119 - luminosity);
double n2 = Math.Max(0.0, 1.0 - saturation * 4.0) * Math.Max(0.0, 1.0 - n1 * 4.0);
double n3 = Math.Max(0.0, 1.0 - saturation * 4.0);
luminosity = TransformLuminosity(hue, saturation, luminosity, bg.Luminosity);
hue = hue * (1.0 - n3) + bg.Hue * n3;
saturation = saturation * (1.0 - n2) + bg.Saturation * n2;
if (isHighContrast)
luminosity = ((luminosity <= 0.3) ? 0.0 : ((luminosity >= 0.7) ? 1.0 : ((luminosity - 0.3) / 0.4))) * (1.0 - saturation) + luminosity * saturation;
var color = new HslColor(hue, saturation, luminosity, 1.0).ToColor();
pixels[offs + 2] = color.R;
pixels[offs + 1] = color.G;
pixels[offs] = color.B;
offs += 4;
}
BitmapSource newImage = BitmapSource.Create(src.PixelWidth, src.PixelHeight, src.DpiX, src.DpiY, PixelFormats.Bgra32, src.Palette, pixels, src.PixelWidth * 4);
newImage.Freeze();
return newImage;
}
}
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);
}
public static FormatConvertedBitmap GetFormatConvertedBitmap(SWM.PixelFormat pf, BitmapSource bs)
{
FormatConvertedBitmap newFormatedBitmapSource = new FormatConvertedBitmap();
newFormatedBitmapSource.BeginInit();
newFormatedBitmapSource.Source = bs;
newFormatedBitmapSource.DestinationFormat = pf;
newFormatedBitmapSource.EndInit();
return newFormatedBitmapSource;
}
private static BitmapSource LoadBitmap(string path)
{
BitmapSource bitmapSource = new BitmapImage(new Uri(Path.GetFullPath(path)));
if (bitmapSource.Format != workingFormat)
{
bitmapSource = new FormatConvertedBitmap(bitmapSource, workingFormat, null, 0.5);
}
return bitmapSource;
}
public static Bitmap ToGdiBitmap(BitmapSource bmp)
{
// below code refernces blog entry by luche:
// http://www.ruche-home.net/%A4%DC%A4%E4%A4%AD%A4%B4%A4%C8/2011-08-02/CopyPixels%20%A5%E1%A5%BD%A5%C3%A5%C9%A4%F2%CD%D1%A4%A4%A4%BF%20WPF%20BitmapSource%20%A4%AB%A4%E9%20GDI%20Bitmap%20%A4%D8%A4%CE%CA%D1%B4%B9
if (bmp.Format != PixelFormats.Bgra32)
{
// convert format
bmp = new FormatConvertedBitmap(bmp,
PixelFormats.Bgra32, null, 0);
bmp.Freeze();
}
// prepare values
var width = (int)bmp.Width;
var height = (int)bmp.Height;
var stride = width * 4;
// prepare buffer
var buffer = new byte[stride * height];
// copy to byte array
bmp.CopyPixels(buffer, stride, 0);
// create bitmap
var result = new Bitmap(width, height, SDI::PixelFormat.Format32bppArgb);
// set bitmap content
try
{
// locking bits
SDI::BitmapData bd = null;
try
{
bd = result.LockBits(new Rectangle(0, 0, width, height),
SDI::ImageLockMode.WriteOnly, SDI::PixelFormat.Format32bppArgb);
Marshal.Copy(buffer, 0, bd.Scan0, buffer.Length);
}
finally
{
if (bd != null)
{
result.UnlockBits(bd);
}
}
}
catch
{
result.Dispose();
throw;
}
return result;
}
/// <summary>
/// Converts a bitmap and returns the result.
/// </summary>
/// <param name="bitmap">The bitmap to convert.</param>
/// <returns>The result.</returns>
public BitmapSource Convert(BitmapSource bitmap)
{
BitmapSource result = bitmap;
if(bitmap.Format != _format)
result = new FormatConvertedBitmap(result, _format, null, 0);
if(Rotate != 0)
result = new TransformedBitmap(result, new RotateTransform(Rotate));
return result;
}
public ShowMyFace()
{
Title = "Show My Face";
///******************************************************************
// 3���� ShowMyFace ����
//******************************************************************/
Uri uri = new Uri("http://www.charlespetzold.com/PetzoldTattoo.jpg");
//BitmapImage bitmap = new BitmapImage(uri);
//Image img = new Image();
//img.Source = bitmap;
//Content = img;
///******************************************************************
// p1245 BitmapImage �ڵ�
//******************************************************************/
Image rotated90 = new Image();
TransformedBitmap tb = new TransformedBitmap();
FormatConvertedBitmap fb = new FormatConvertedBitmap();
CroppedBitmap cb = new CroppedBitmap();
// Create the source to use as the tb source.
BitmapImage bi = new BitmapImage();
bi.BeginInit();
bi.UriSource = uri;
bi.EndInit();
//cb.BeginInit();
//cb.Source = bi;
//Int32Rect rect = new Int32Rect();
//rect.X = 220;
//rect.Y = 200;
//rect.Width = 120;
//rect.Height = 80;
//cb.SourceRect = rect;
//cb.EndInit();
fb.BeginInit();
fb.Source = bi;
fb.DestinationFormat = PixelFormats.Gray2;
fb.EndInit();
// Properties must be set between BeginInit and EndInit calls.
tb.BeginInit();
tb.Source = fb;
// Set image rotation.
tb.Transform = new RotateTransform(90);
tb.EndInit();
// Set the Image source.
rotated90.Source = tb;
Content = rotated90;
}
private static void SetGrayscale(System.Windows.Controls.Image img)
{
img.IsEnabled = false;
FormatConvertedBitmap bitmap = new FormatConvertedBitmap();
bitmap.BeginInit();
bitmap.Source = (BitmapSource)img.Source;
bitmap.DestinationFormat = PixelFormats.Gray32Float;
bitmap.EndInit();
img.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Background, new Action(() => { img.Source = bitmap; }));
}
public static PixelColor[,] GetPixels(BitmapSource source)
{
if (source.Format != PixelFormats.Bgra32)
source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
int width = source.PixelWidth;
int height = source.PixelHeight;
PixelColor[,] result = new PixelColor[width, height];
BitmapSourceHelper.CopyPixels(source, result, width * 4, 0);
return result;
}
public PixelBitmap(BitmapSource source)
{
if (source.Format != PixelFormats.Bgra32)
{
source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
}
this.Width = source.PixelWidth;
this.Height = source.PixelHeight;
this.Pixels = new PixelColor[this.Width * this.Height];
this.copyPixels(source, this.Pixels, this.Width * 4, 0);
}
/// <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 void CombineTiffs(string DestinationPath, IEnumerable<string> FilePathToMerge, FileMode DestinationPathMode)
{
//create the file stream to write to the file
using (FileStream FileStreamToUse = new FileStream(DestinationPath, DestinationPathMode))
{
//create the tiff encoder
var Encoder = new TiffBitmapEncoder();
//set the compression
Encoder.Compression = TiffCompressOption.Ccitt4;
//loop through each of the files to combine
foreach (string FileNameToMerge in FilePathToMerge)
{
try
{
//declare the bitmap image
var ImageToMerge = new BitmapImage();
//start the process
ImageToMerge.BeginInit();
//do everything on load
ImageToMerge.CacheOption = BitmapCacheOption.OnLoad;
//set the file source
ImageToMerge.UriSource = new Uri(FileNameToMerge);
//we are done and ready to convert
ImageToMerge.EndInit();
//convert it now
FormatConvertedBitmap ConvertedBitMap = new FormatConvertedBitmap(ImageToMerge,
PixelFormats.BlackWhite,
BitmapPalettes.BlackAndWhite,
1.0);
//create the frames
Encoder.Frames.Add(BitmapFrame.Create(ConvertedBitMap));
}
catch (NotSupportedException)
{
//ignore these exception? (means bad image file...or is not a tiff file)
throw;
}
}
//save the file
Encoder.Save(FileStreamToUse);
}
}
public void RGB565LuminanceSource_Should_Give_The_Same_Result_As_RGBLuminanceSource_For_BGR565()
{
BitmapSource bitmapImage = new BitmapImage(new Uri(samplePicRelPath, UriKind.RelativeOrAbsolute));
bitmapImage = new FormatConvertedBitmap(bitmapImage, PixelFormats.Bgr565, null, 0);
var bytes = new byte[bitmapImage.PixelHeight*bitmapImage.PixelWidth*2];
bitmapImage.CopyPixels(bytes, bitmapImage.PixelWidth * 2, 0);
var rgb565LuminanceSource = new RGB565LuminanceSource(bytes, bitmapImage.PixelWidth, bitmapImage.PixelHeight);
var rgbLuminanceSource = new BitmapSourceLuminanceSource(bitmapImage);
Assert.AreEqual(rgbLuminanceSource.ToString(), rgb565LuminanceSource.ToString());
}
public ImageSource GetCroppedImage(BitmapSource source, int cropTop, int cropBottom, int cropLeft, int cropRight)
{
if (source == null)
return null;
if (source.Format != PixelFormats.Bgra32)
source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
if (cropRight > source.Width || cropBottom > source.Height)
return null;
return new CroppedBitmap(source, new Int32Rect(cropLeft, cropTop, cropRight - cropLeft, cropBottom - cropTop));
}
public static RgbaBitmapBuffer FromBitmapSource(BitmapSource bitmapSource)
{
if (bitmapSource.Format != workingFormat)
{
bitmapSource = new FormatConvertedBitmap(bitmapSource, workingFormat, null, 0.5);
}
var floatStride = workingChannelCount * bitmapSource.PixelWidth;
var buffer = new float[floatStride * bitmapSource.PixelHeight];
bitmapSource.CopyPixels(buffer, sizeof(float) * floatStride, 0);
return new RgbaBitmapBuffer(buffer, floatStride);
}
public static PixelColor[,] GetPixels(this BitmapSource source)
{
if (source.Format != PixelFormats.Bgra32)
source = new FormatConvertedBitmap(source, PixelFormats.Bgra32, null, 0);
int width = source.PixelWidth;
int height = source.PixelHeight;
PixelColor[,] result = new PixelColor[width,height];
// ReSharper disable RedundantNameQualifier
// qualifier is NOT redudant, in fact if you don't have it we crash.
PixelRetrievalExtensions.CopyPixels(source,result, width * 4, 0);
// ReSharper restore RedundantNameQualifier
return result;
}
/// <summary>
/// Extension method
/// </summary>
/// <param name="bitmapsource"></param>
/// <returns></returns>
public static Bitmap BitmapSourceToBitmap(this BitmapSource bitmapsource) {
//convert image format
FormatConvertedBitmap src = new FormatConvertedBitmap();
src.BeginInit();
src.Source = bitmapsource;
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgra32;
src.EndInit();
//copy to bitmap
Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, PixelFormat.Format32bppArgb);
BitmapData data = bitmap.LockBits(new Rectangle(System.Drawing.Point.Empty, bitmap.Size), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
src.CopyPixels(Int32Rect.Empty, data.Scan0, data.Height*data.Stride, data.Stride);
bitmap.UnlockBits(data);
return bitmap;
}
public static void Store(FrameworkElement fwElement, string fileName)
{
var width = (int)fwElement.ActualWidth;
var height = (int)fwElement.ActualHeight;
var rtb = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
rtb.Render(fwElement);
var bwImage = new FormatConvertedBitmap(rtb, PixelFormats.BlackWhite, null, 0);
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bwImage));
using (var stream = File.Create(fileName))
{
encoder.Save(stream);
}
}
public static System.Drawing.Bitmap BmpSource2Img(BitmapSource bmpsource)
{
//convert image format
var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();
src.BeginInit();
src.Source = bmpsource;
src.EndInit();
//copy to bitmap
Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, System.Drawing.Imaging.PixelFormat.DontCare);
var data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.DontCare);
src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
bitmap.UnlockBits(data);
return(bitmap);
}
public Bitmap BitmapFromSource(System.Windows.Media.Imaging.BitmapSource bitmapsource)
{
//convert image format
var src = new System.Windows.Media.Imaging.FormatConvertedBitmap();
src.BeginInit();
src.Source = bitmapsource;
src.DestinationFormat = System.Windows.Media.PixelFormats.Bgra32;
src.EndInit();
//copy to bitmap
Bitmap bitmap = new Bitmap(src.PixelWidth, src.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
var data = bitmap.LockBits(new Rectangle(System.Drawing.Point.Empty, bitmap.Size), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
src.CopyPixels(System.Windows.Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
bitmap.UnlockBits(data);
return(bitmap);
}
private void ClonePrequel(FormatConvertedBitmap otherFormatConvertedBitmap)
{
BeginInit();
}
private void ClonePostscript(FormatConvertedBitmap otherFormatConvertedBitmap)
{
EndInit();
}