/// <summary>
/// Creates a WPF bitmap source from an GDI image.
/// </summary>
public static BitmapSource CreateBitmapSource(Image image)
{
MemoryStream stream = new MemoryStream();
//int width = image.Width;
//int height = image.Height;
//double dpiX = image.HorizontalResolution;
//double dpiY = image.VerticalResolution;
//System.Windows.Media.PixelFormat pixelformat = PixelFormats.Default;
BitmapSource bitmapSource = null;
try
{
string guid = image.RawFormat.Guid.ToString("B").ToUpper();
switch (guid)
{
case "{B96B3CAA-0728-11D3-9D7B-0000F81EF32E}": // memoryBMP
case "{B96B3CAB-0728-11D3-9D7B-0000F81EF32E}": // bmp
image.Save(stream, ImageFormat.Bmp);
stream.Position = 0;
BmpBitmapDecoder bmpDecoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
bitmapSource = bmpDecoder.Frames[0];
break;
case "{B96B3CAF-0728-11D3-9D7B-0000F81EF32E}": // png
image.Save(stream, ImageFormat.Png);
stream.Position = 0;
PngBitmapDecoder pngDecoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
bitmapSource = pngDecoder.Frames[0];
break;
case "{B96B3CAE-0728-11D3-9D7B-0000F81EF32E}": // jpeg
image.Save(stream, ImageFormat.Jpeg);
JpegBitmapDecoder jpegDecoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
stream.Position = 0;
bitmapSource = jpegDecoder.Frames[0];
break;
case "{B96B3CB0-0728-11D3-9D7B-0000F81EF32E}": // gif
image.Save(stream, ImageFormat.Gif);
GifBitmapDecoder gifDecoder = new GifBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
stream.Position = 0;
bitmapSource = gifDecoder.Frames[0];
break;
case "{B96B3CB1-0728-11D3-9D7B-0000F81EF32E}": // tiff
image.Save(stream, ImageFormat.Tiff);
TiffBitmapDecoder tiffDecoder = new TiffBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
stream.Position = 0;
bitmapSource = tiffDecoder.Frames[0];
break;
case "{B96B3CB5-0728-11D3-9D7B-0000F81EF32E}": // icon
image.Save(stream, ImageFormat.Icon);
IconBitmapDecoder iconDecoder = new IconBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
stream.Position = 0;
bitmapSource = iconDecoder.Frames[0];
break;
case "{B96B3CAC-0728-11D3-9D7B-0000F81EF32E}": // emf
case "{B96B3CAD-0728-11D3-9D7B-0000F81EF32E}": // wmf
case "{B96B3CB2-0728-11D3-9D7B-0000F81EF32E}": // exif
case "{B96B3CB3-0728-11D3-9D7B-0000F81EF32E}": // photoCD
case "{B96B3CB4-0728-11D3-9D7B-0000F81EF32E}": // flashPIX
default:
throw new InvalidOperationException("Unsupported image format.");
}
}
catch (Exception ex)
{
Debug.WriteLine("ImageHelper.CreateBitmapSource failed:" + ex.Message);
}
finally
{
//if (stream != null)
// stream.Close();
}
return bitmapSource;
}
public void avilaImages()
{
try
{
Stream imageStreamSource = new FileStream("base.bmp", FileMode.Open, FileAccess.Read, FileShare.Read);
BmpBitmapDecoder baseImage = new BmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource baseImageSource = baseImage.Frames[0];
//List<System.Windows.Media.Color> colors = new List<System.Windows.Media.Color>();
//colors.Add(System.Windows.Media.Colors.Red);
//colors.Add(System.Windows.Media.Colors.Blue);
//colors.Add(System.Windows.Media.Colors.Green);
BitmapPalette palette = new BitmapPalette(baseImageSource, 8);
WriteableBitmap bitmapImages = new WriteableBitmap(imageSizeX, imageSizeY, (double)600, (double)560, PixelFormats.Gray8, palette);
WriteableBitmap bitmapImagesW = new WriteableBitmap(imageSizeX, imageSizeY, (double)600, (double)560, PixelFormats.Gray8, palette);
string photoSaveLocation = Directory.GetCurrentDirectory();
photoSaveLocation = photoSaveLocation + "\\images\\";
imageDeleteLocation = photoSaveLocation;
if (Directory.Exists(photoSaveLocation))
{
Directory.Delete(photoSaveLocation, true);
}
Directory.CreateDirectory(photoSaveLocation);
if (Directory.Exists(imageCopyLocation))
{
Directory.Delete(imageCopyLocation, true);
}
Directory.CreateDirectory(imageCopyLocation);
const int stride = imageSizeX;
byte[] pixels = new byte[imageSizeX * imageSizeY];
byte[] pixelsW = new byte[imageSizeX * imageSizeY];
int currentImage = 0;
if (layerSize < .001f)
{
textBlock3.Text = "Layer size is too small";
}
else if (layerSize > .009f)
{
textBlock3.Text = "Layer size is too large";
}
else
{
numImages = imageSizeZ / layerSize;
int centerImage = (int)numImages / 2;
int sphereOffsetY = baseImageSizeY / 2;
int x, y, r2;
int pixelsX = (int)numImages;
byte[] circlePixels = new byte[pixelsX * pixelsX];
int offset = (int)(numImages) / 2;
int radius = (int)(sphereSizeZ / layerSize);
//int offsetY = radius;
byte sphereOneColor = sphereOneColorGlobal;
r2 = (int)radius * (int)radius;
circlePixels[(int)(offset + (offset + radius) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + (offset - radius) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + radius + (offset) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - radius + (offset) * pixelsX)] = sphereOneColor;
y = radius;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
circlePixels[(int)(offset + x + (offset + y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + x + (offset - y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - x + (offset + y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - x + (offset - y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + y + (offset + x) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + y + (offset - x) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - y + (offset + x) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - y + (offset - x) * pixelsX)] = sphereOneColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
circlePixels[(int)(offset + x + (offset + y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset + x + (offset - y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - x + (offset + y) * pixelsX)] = sphereOneColor;
circlePixels[(int)(offset - x + (offset - y) * pixelsX)] = sphereOneColor;
}
WriteableBitmap view3D = new WriteableBitmap((int)pixelsX, (int)pixelsX, (double)600, (double)600, PixelFormats.Gray8, palette);
view3D.WritePixels(new Int32Rect(0, 0, pixelsX, pixelsX), circlePixels, pixelsX, 0);
BitmapEncoder view3DEnc = new BmpBitmapEncoder();
view3DEnc.Frames.Add(BitmapFrame.Create(view3D));
using (FileStream fs = new FileStream(photoSaveLocation + "view3D.bmp", FileMode.Create, FileAccess.Write))
{
view3DEnc.Save(fs);
}
for (int i = 0; i < numImages; i++)
{
for (int locationIndex = 0, colorIndex = 0; colorIndex < pixels.Length; locationIndex++, colorIndex += 1)
{
int columnLocation = locationIndex % imageSizeX;
int rowLocation = (int)(locationIndex / imageSizeX);
if (locationIndex >= (baseImageSizeY) * imageSizeX && locationIndex <= (baseImageSizeY + gapSize) * imageSizeX || locationIndex >= (baseImageSizeY * 2 + gapSize) * imageSizeX && locationIndex <= (baseImageSizeY * 2 + gapSize + gapSize) * imageSizeX)
{
pixels[colorIndex] = 0;
}
else
{
if (locationIndex < baseImageSizeY * imageSizeX)
{
pixels[colorIndex] = backgroundColor;
}
else if (locationIndex < (baseImageSizeY * 2 + gapSize) * imageSizeX )
{
pixels[colorIndex] = backgroundColor - colorOffsetLower1;
}
else if (locationIndex < (baseImageSizeY * 3 + gapSize + gapSize) * imageSizeX)
{
pixels[colorIndex] = backgroundColor + colorOffsetUpper1;
}
}
pixelsW[colorIndex] = maxColor;
}
//bitmapImages.WritePixels(new Int32Rect(0, 0, imageSizeX, imageSizeY), pixels, stride, 0);
//Bitmap bmp;
//using (MemoryStream outStream = new MemoryStream())
//{
// BitmapEncoder enc = new BmpBitmapEncoder();
// enc.Frames.Add(BitmapFrame.Create((bitmapImages)));
// enc.Save(outStream);
// bmp = new System.Drawing.Bitmap(outStream);
//}
//Graphics graphicsProccesor = Graphics.FromImage(bmp);
//System.Drawing.Pen backgroudPen = new System.Drawing.Pen(System.Drawing.Color.FromArgb(backgroundColor, backgroundColor, backgroundColor));
//System.Drawing.Pen sphere1Pen = new System.Drawing.Pen(System.Drawing.Color.FromArgb(sphereOneColor, sphereOneColor, sphereOneColor));
//System.Drawing.Pen sphere2Pen = new System.Drawing.Pen(System.Drawing.Color.FromArgb(sphereTwoColor, sphereTwoColor, sphereTwoColor));
//System.Drawing.Pen sphere3Pen = new System.Drawing.Pen(System.Drawing.Color.FromArgb(sphereThreeColor, sphereThreeColor, sphereThreeColor));
//graphicsProccesor.DrawEllipse(sphere1Pen, sphereOneOffset, (imageSizeY / 2), sphereSize, sphereSize);
//for (int x = 0; x < imageSizeX; x++)
// for (int y = 0; y < imageSizeY; y++)
// {
// bmp.GetPixel(x, y).ToString();
// }
for (int locationIndex = 0, colorIndex = 0; colorIndex < pixels.Length; locationIndex++, colorIndex += 1)
{
int columnLocation = locationIndex % imageSizeX;
int rowLocation = (int)(locationIndex / imageSizeX);
//pixels[colorIndex] = backgroundColor;
//pixelsW[colorIndex] = maxColor;
int sphereSize = 0;
int sphereOffset = sphereOneOffset;
//if (sphereSize > 0)
if (currentImage > centerImage - (sphereSizeZ / layerSize) && currentImage < centerImage + (sphereSizeZ / layerSize) && columnLocation == sphereOffset && rowLocation == sphereOffsetY)
{
sphereSize = (getRadius(currentImage, circlePixels, centerImage));
if (currentImage == centerImage)
{
int test = 0;
}
r2 = sphereSize * sphereSize;
sphereOneColor = sphereOneColorGlobal;
byte sphereTwoColor = sphereTwoColorGlobal;
byte sphereThreeColor = sphereThreeColorGlobal;
pixels[(int)(sphereOffset + (sphereOffsetY + sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + (sphereOffsetY - sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + sphereSize + (sphereOffsetY) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - sphereSize + (sphereOffsetY) * imageSizeX)] = sphereOneColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY - x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY - x) * imageSizeX)] = sphereOneColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereOneColor;
}
sphereOffset = sphereTwoOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (sphereOffsetY + sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + (sphereOffsetY - sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + sphereSize + (sphereOffsetY) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - sphereSize + (sphereOffsetY) * imageSizeX)] = sphereTwoColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
}
sphereOffset = sphereThreeOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (sphereOffsetY + sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + (sphereOffsetY - sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + sphereSize + (sphereOffsetY) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - sphereSize + (sphereOffsetY) * imageSizeX)] = sphereThreeColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (sphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (sphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (sphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (sphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (sphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
}
//new circle sets 2 and 3
int localSphereOffsetY = (baseImageSizeY / 2) + baseImageSizeY + gapSize;
sphereOffset = sphereOneOffset;
sphereOneColor = sphereOneColorGlobal - colorOffsetLower1;
sphereTwoColor = sphereTwoColorGlobal - colorOffsetLower2;
sphereThreeColor = sphereThreeColorGlobal - colorOffsetLower3;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereOneColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereOneColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
}
sphereOffset = sphereTwoOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereTwoColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
}
sphereOffset = sphereThreeOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereThreeColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
}
//circle set 3
localSphereOffsetY = (baseImageSizeY / 2) + baseImageSizeY + gapSize + baseImageSizeY + gapSize;
sphereOffset = sphereOneOffset;
sphereOneColor = sphereOneColorGlobal + colorOffsetUpper1;
sphereTwoColor = sphereTwoColorGlobal + colorOffsetUpper2;
sphereThreeColor = sphereThreeColorGlobal + colorOffsetUpper3;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereOneColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereOneColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereOneColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereOneColor;
}
sphereOffset = sphereTwoOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereTwoColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereTwoColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereTwoColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereTwoColor;
}
sphereOffset = sphereThreeOffset;
r2 = sphereSize * sphereSize;
pixels[(int)(sphereOffset + (localSphereOffsetY + sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + (localSphereOffsetY - sphereSize) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - sphereSize + (localSphereOffsetY) * imageSizeX)] = sphereThreeColor;
y = sphereSize;
x = 1;
y = (int)(Math.Sqrt(r2 - 1) + 0.5);
while (x < y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + y + (localSphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY + x) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - y + (localSphereOffsetY - x) * imageSizeX)] = sphereThreeColor;
x += 1;
y = (int)(Math.Sqrt(r2 - x * x) + 0.5);
}
if (x == y)
{
pixels[(int)(sphereOffset + x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset + x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY + y) * imageSizeX)] = sphereThreeColor;
pixels[(int)(sphereOffset - x + (localSphereOffsetY - y) * imageSizeX)] = sphereThreeColor;
}
}
}
//if (currentImage > centerImage - (sphereSizeZ / layerSize) && currentImage < centerImage + (sphereSizeZ / layerSize))
//{
for (int testY = 0; testY < imageSizeY; testY++)
{
int hitColor = backgroundColor;
int hitEndColor = backgroundColor;
int sphereStart = 0;
int sphereEnd = 0;
int sphereMiddle = 0;
for (int testX = testY * imageSizeX; testX < (testY * imageSizeX) + imageSizeX; testX++)
{
if (pixels[testX] != backgroundColor && pixels[testX] != backgroundColor - colorOffsetLower1 && pixels[testX] != backgroundColor + colorOffsetUpper1)
{
if (sphereStart == 0)
{
hitColor = pixels[testX];
sphereStart = testX;
}
else if (sphereMiddle != 0)
{
hitEndColor = pixels[testX];
sphereEnd = testX;
}
}
if (pixels[testX] == backgroundColor || pixels[testX] == backgroundColor - colorOffsetLower1 || pixels[testX] == backgroundColor + colorOffsetUpper1)
{
if (sphereStart != 0)
{
if (sphereMiddle == 0)
{
sphereMiddle = testX;
}
else if (sphereMiddle != 0)
{
if (sphereEnd != 0)
{
if (hitEndColor == hitColor)
{
for (int colorY = sphereStart; colorY < sphereEnd; colorY++)
{
pixels[colorY] = (byte)hitColor;
}
}
hitColor = backgroundColor;
sphereStart = 0;
sphereEnd = 0;
sphereMiddle = 0;
}
}
}
}
}
}
// }
//}
// sphereOffset = sphereTwoOffset;
// if (currentImage == centerImage - (sphereSizeZ / layerSize) && columnLocation == sphereOffset - sphereSize && rowLocation == sphereOffsetY - sphereSize)
// {
// pixels[colorIndex] = sphereTwoColor;
// pixelsW[colorIndex] = maxColor;
// }
// sphereOffset = sphereThreeOffset;
// if (currentImage == centerImage - (sphereSizeZ / layerSize) && columnLocation == sphereOffset - sphereSize && rowLocation == sphereOffsetY - sphereSize)
// {
// pixels[colorIndex] = sphereThreeColor;
// pixelsW[colorIndex] = maxColor;
// }
// if within +- .3in in Z
// if (isSphere(sphereOneOffset, locationIndex, i)) //left circle
// {
// pixels[colorIndex] = sphereOneColor;
// pixelsW[colorIndex] = maxColor;
// }
// else if (isSphere(sphereTwoOffset, locationIndex, i)) //middle circle
// {
// pixels[colorIndex] = sphereTwoColor;
// pixelsW[colorIndex] = maxColor;
// }
// else if (isSphere(sphereThreeOffset, locationIndex, i)) //right circle
// {
// pixels[colorIndex] = sphereThreeColor;
// pixelsW[colorIndex] = maxColor;
// }
// else
// {
// pixels[colorIndex] = backgroundColor;
// pixelsW[colorIndex] = maxColor;
// }
//}
////Test loop
//for (int j = 0; j < pixels.Length; j++)
//{
// pixels[j] = 0;
// pixelsW[j] = maxColor;
//}
for (int pixelsCount = 0; pixelsCount < pixels.Length; pixelsCount++)
{
if (pixels[pixelsCount] != 0)
{
pixelsW[pixelsCount] = (byte)((byte)(255) - pixels[pixelsCount]);
}
else
{
pixelsW[pixelsCount] = 0;
}
}
bitmapImages.WritePixels(new Int32Rect(0, 0, imageSizeX, imageSizeY), pixels, stride, 0);
image1.Source = bitmapImages;
BitmapEncoder avilaImages = new BmpBitmapEncoder();
avilaImages.Frames.Add(BitmapFrame.Create(bitmapImages));
bitmapImagesW.WritePixels(new Int32Rect(0, 0, imageSizeX, imageSizeY), pixelsW, stride, 0);
BitmapEncoder avilaImagesW = new BmpBitmapEncoder();
avilaImagesW.Frames.Add(BitmapFrame.Create(bitmapImagesW));
try
{
int intNumImages = (int)numImages;
string currentImageName = currentImage.ToString().PadLeft(intNumImages.ToString().Length, '0') + ".bmp";
using (FileStream fs = new FileStream(photoSaveLocation + currentImageName, FileMode.Create, FileAccess.Write))
{
avilaImages.Save(fs);
textBlock4.Text = "Image base number " + currentImage + " created";
}
string currentImageNameW = currentImage.ToString().PadLeft(intNumImages.ToString().Length, '0') + "_w.bmp";
using (FileStream fs = new FileStream(photoSaveLocation + currentImageNameW, FileMode.Create, FileAccess.Write))
{
avilaImagesW.Save(fs);
textBlock4.Text = "Image base inverted number " + currentImage + " created";
}
currentImage++;
}
catch (IOException)
{
textBlock3.Text = "IO Exception caught, is //images// write locked?";
}
}
}
//end loop here
//--------------------------------------
imageStreamSource.Close();
textBlock4.Text = currentImage + " images were created successfully";
}
catch (IOException)
{
textBlock3.Text = "IO Exception caught, does image base.bmp exist in runtime directory?";
}
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
//----------------------------------------This Code is from bmpCopyPasta-----------------------------------------------
//-------The following code is from a script I made earlier to copy a series of images to be print ready---------------
//-------it requires a series of images that end with _w and for every one of these there is an image without _w-------
//---------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------
int numImagesCopy = 0;
string[] oldPathAndNameRGB = new string[50];
//string[] newPathAndNameRGB = new string[50];
string[] oldPathAndNameW;
//string[] newPathAndNameW = new string[50];
string[] errorLocations = new string[50];
string[] z2cFile = new string[3];
string imagesDirectory = imageCopyLocation;
string blankImage = imagesDirectory + "\\blank.bmp"; //Black Image/RGB
string baseImageCopy = imagesDirectory + "\\base.bmp"; //White Image/W
try
{
/*numImagesRGB = Directory.GetFiles(imagesDirectory, "*.bmp", SearchOption.TopDirectoryOnly).Length; //count the number of .jpg files in the directory found above
oldPathAndNameRGB = Directory.GetFiles(imagesDirectory, "*.bmp", SearchOption.TopDirectoryOnly);*/
numImagesCopy = Directory.GetFiles(imageDeleteLocation, "*_w.bmp", SearchOption.TopDirectoryOnly).Length; //count the number of .jpg files in the directory found above
oldPathAndNameW = Directory.GetFiles(imageDeleteLocation, "*_w.bmp", SearchOption.TopDirectoryOnly);
if (numImagesCopy != 0)
{
oldPathAndNameRGB = new string[numImagesCopy];
errorLocations = new string[numImagesCopy];
}
for (int i = 0; i < numImagesCopy; i++)
{
oldPathAndNameRGB[i] = oldPathAndNameW[i].Substring(0, oldPathAndNameW[i].Length - 6) + ".bmp";
}
//if (Directory.Exists(imagesDirectory))
//{
// Directory.Delete(imagesDirectory, true);
//}
//System.IO.Directory.CreateDirectory(imagesDirectory);
for (int i = 0; i < numImagesCopy; i++)
{
if (File.Exists(oldPathAndNameRGB[i]) && File.Exists(oldPathAndNameW[i]))
{
}
else
{
for (int j = 0; j < errorLocations.Length; j++)
{
errorLocations[j] = "There was an issue with image number " + i;
}
}
}
if (errorLocations[0] == null)
{
for (int i = 0; i < numImagesCopy; i++)
{
string imageName = "Layer" + i.ToString().PadLeft(/*numImagesRGB.ToString().Length*/ 4, '0'); //May need to just be 4 later
System.IO.File.Copy(oldPathAndNameRGB[i], imagesDirectory + imageName + "_c.bmp");
System.IO.File.Copy(oldPathAndNameRGB[i], imagesDirectory + imageName + "_m.bmp");
System.IO.File.Copy(oldPathAndNameRGB[i], imagesDirectory + imageName + "_y.bmp");
//System.IO.File.Copy(oldPathAndNameW[i], imagesDirectory + "\\images\\" + imageName + "_c.bmp");//transition code
//System.IO.File.Copy(oldPathAndNameW[i], imagesDirectory + "\\images\\" + imageName + "_m.bmp");//transition code
//System.IO.File.Copy(oldPathAndNameW[i], imagesDirectory + "\\images\\" + imageName + "_y.bmp");//transition code
//System.IO.File.Copy(blankImage, imagesDirectory + "\\images\\" + imageName + "_c.bmp");//davelike test code
//System.IO.File.Copy(blankImage, imagesDirectory + "\\images\\" + imageName + "_m.bmp");//davelike test code
//System.IO.File.Copy(blankImage, imagesDirectory + "\\images\\" + imageName + "_y.bmp");//davelike test code
textBlock4.Text = "CMY of layer: " + i + " is done";
System.IO.File.Copy(oldPathAndNameW[i], imagesDirectory + imageName + "_w.bmp");
//System.IO.File.Copy(oldPathAndNameRGB[i], imagesDirectory + "\\images\\" + imageName + "_w.bmp"); //davelike test code
//System.IO.File.Copy(baseImage, imagesDirectory + "\\images\\" + imageName + "_w.bmp"); //davelike test code
textBlock4.Text = "W of layer: " + i + " is done";
//System.IO.File.Copy(oldPathAndNameW[i], imagesDirectory + "\\images\\" + imageName + "_k.bmp"); //davelike test code
//System.Console.WriteLine("K of layer: " + i + " is done"); //davelike test code
}
System.Console.WriteLine("All Done Copying Images");
if (numImagesCopy != 0)
{
z2cFile[0] = "inches";
z2cFile[1] = ".007";
z2cFile[2] = numImagesCopy.ToString();
System.IO.File.WriteAllLines(imagesDirectory + "\\images.z2c", z2cFile);
textBlock4.Text = "All Done Creating .z2c file";
}
}
else
{
for (int i = 0; i < errorLocations.Length; i++)
{
if (errorLocations[i] != null)
{
System.Console.WriteLine(errorLocations[i]);
}
}
}
}
catch
{
textBlock4.Text = "Exception caught, the folder \\forPrint\\ may be write locked.";
}
System.Console.WriteLine("The number of images found was " + numImagesCopy + ". Press enter to finish");
Console.ReadLine();
}
public void TestCacheModifySymbol()
{
using (ShimsContext.Create())
{
client.Geometry.MapPoint p = new client.Geometry.MapPoint(0.0, 0.0);
clientfake.ShimGraphic g = new clientfake.ShimGraphic();
client.FeatureService.Symbols.PictureMarkerSymbol pms = new client.FeatureService.Symbols.PictureMarkerSymbol();
Uri myUri = new Uri("../../resources/zoom_in_tool_1.bmp", UriKind.RelativeOrAbsolute);
BitmapDecoder decoder = new BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];
pms.Source = bitmapSource;
clientfake.ShimUniqueValueRenderer r = new clientfake.ShimUniqueValueRenderer();
Dictionary<String, Object> attributes = new Dictionary<String, Object>();
attributes["uniquedesignation"] = "Wolfpack 1 C";
attributes["owningunit"] = "2nd Stryker Brigade";
attributes["type"] = "M1128";
g.AttributesGet = () => { return attributes; };
g.GeometryGet = () => { return p; };
Dictionary<String, String> fields = new Dictionary<String, String>();
fields["UID"] = "uniquedesignation";
fields["HF"] = "owningunit";
fields["LABELS"] = "uniquedesignation";
fields["DESCFLDS"] = "type";
fields["DESCFIELD"] = "type";
int count = cache.RetrieveFeatureCache("EQUIPMENT").Count;
cache.AddFeature("EQUIPMENT", g, "Type: {type}", "{uniquedesignation}", fields, r);
fields["LABELS"] = "uniquedesignation,owningunit";
g.SymbolGet = () => { return pms; };
cache.UpdateFeature("EQUIPMENT", "Wolfpack 1 C", "Type: {type}", "{uniquedesignation} owned by {owningunit}", g, fields);
Dictionary<String, Dictionary<String, Object>> fcache = cache.RetrieveFeatureCache("EQUIPMENT");
Dictionary<String, Object> f = fcache["Wolfpack 1 C"];
ImageSource imsrc = f["ICON"] as ImageSource;
Assert.AreEqual(pms.Source, imsrc);
}
}
private static ImageSource RetriveImage(string imagePath)
{
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(imagePath);
switch (imagePath.Substring(imagePath.Length - 3))
{
case "jpg":
var jpgDecoder = new System.Windows.Media.Imaging.JpegBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(jpgDecoder.Frames[0]);
case "bmp":
var bmpDecoder = new System.Windows.Media.Imaging.BmpBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(bmpDecoder.Frames[0]);
case "png":
var pngDecoder = new System.Windows.Media.Imaging.PngBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(pngDecoder.Frames[0]);
case "ico":
var icoDecoder = new System.Windows.Media.Imaging.IconBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(icoDecoder.Frames[0]);
default:
return(null);
}
}
private void GetBitmapSourceFromBmp(string fileRoute)
{
Stream imageStream = new FileStream(fileRoute, FileMode.Open, FileAccess.Read, FileShare.Read);
var decoder = new BmpBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
BmSource = decoder.Frames[0];
BitsPerPix = BmSource.Format.BitsPerPixel;
}
private System.Windows.Media.ImageSource BmpImageSource(string embeddedPath)
{
Stream stream = this.GetType().Assembly.GetManifestResourceStream(embeddedPath);
var decoder = new System.Windows.Media.Imaging.BmpBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(decoder.Frames[0]);
}
public static BitmapSource ToImage(byte[] arg, TypeImagen tipo) {
BitmapSource temporigen = null;
if(arg != null){
System.IO.MemoryStream ms = new System.IO.MemoryStream(arg);
switch (tipo)
{
case TypeImagen.BMP:
BmpBitmapDecoder bmpdeco = new BmpBitmapDecoder(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
temporigen = bmpdeco.Frames[0];
break;
case TypeImagen.JPG:
JpegBitmapDecoder jpgdeco = new JpegBitmapDecoder(ms, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
temporigen = jpgdeco.Frames[0];
break;
}
}
return temporigen;
}
public override ImageData Read(Stream stream, ImageMetaData info)
{
var meta = info as GrdMetaData;
if (null == meta)
throw new ArgumentException ("GrdFormat.Read should be supplied with GrdMetaData", "info");
stream.Position = 12;
using (var reader = new Reader (stream, meta.DataSize))
{
reader.Unpack();
byte[] pixels = reader.Data;
using (var bmp = new MemoryStream (reader.Data, false))
{
var decoder = new BmpBitmapDecoder (bmp,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapSource frame = decoder.Frames[0];
frame.Freeze();
return new ImageData (frame, info);
}
}
}
public override ImageData Read(Stream file, ImageMetaData info)
{
var bmp_info = info as BmpMetaData;
if (bmp_info != null && file.CanSeek
&& info.Width * info.Height * (uint)info.BPP/8 + bmp_info.HeaderLength == bmp_info.ImageLength)
{
if (0x20 == info.BPP)
{
return ReadBitmapBGRA (file, bmp_info);
}
else if (0x18 == info.BPP
&& (bmp_info.ImageLength + info.Width * info.Height) == file.Length)
{
return ReadBitmapWithAlpha (file, bmp_info);
}
}
var decoder = new BmpBitmapDecoder (file,
BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
BitmapSource frame = decoder.Frames.First();
frame.Freeze();
return new ImageData (frame, info);
}
/// <summary>
/// 从资源中恢复图像（png、ico、jpeg、bmp）
/// </summary>
/// <param name="nomImage"></param>
/// <returns></returns>
public static ImageSource ImageSource(string nomImage)
{
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(nomImage);
if (Path.GetExtension(nomImage).ToLower().EndsWith(".png")) // Cas png
{
PngBitmapDecoder img = new System.Windows.Media.Imaging.PngBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(img.Frames[0]);
}
if (Path.GetExtension(nomImage).ToLower().EndsWith(".bmp")) // Cas bmp
{
BmpBitmapDecoder img = new System.Windows.Media.Imaging.BmpBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(img.Frames[0]);
}
if (Path.GetExtension(nomImage).ToLower().EndsWith(".jpg")) // Cas jpg
{
JpegBitmapDecoder img = new System.Windows.Media.Imaging.JpegBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(img.Frames[0]);
}
if (Path.GetExtension(nomImage).ToLower().EndsWith(".tiff")) // Cas tiff
{
TiffBitmapDecoder img = new System.Windows.Media.Imaging.TiffBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(img.Frames[0]);
}
if (Path.GetExtension(nomImage).ToLower().Contains(".ico")) // Cas ico
{
IconBitmapDecoder img = new System.Windows.Media.Imaging.IconBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return(img.Frames[0]);
}
return(null);
}
public void Load()
{
try
{
// If we have a loading function, use that to get the url we want to load
if (loading != null)
this.url = loading();
// We explicitly use the WebClient here because we need access to the system-wide browser cache and cookies collection
var client = new WebClient { CachePolicy = new RequestCachePolicy(RequestCacheLevel.CacheIfAvailable) };
var stream = new MemoryStream();
using (var istream = client.OpenRead(url))
{
// Read stream into our own byte buffer on the background thread
istream.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
}
var headers = client.ResponseHeaders;
Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, (Action)delegate
{
try
{
// Create imagesource on the foreground thread
string extension = Path.GetExtension(url).ToLower();
BitmapDecoder decoder = null;
if (extension == ".gif")
decoder = new GifBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (extension == ".png")
decoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (extension == ".jpg" || extension == ".jpeg")
decoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (extension == ".bmp")
decoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else
{
// We are not sure what extension we are looking at, lets see if there is a content-type available
if (headers["Content-Type"] != null)
{
var type = headers["Content-Type"];
if (type.IndexOf("gif", StringComparison.InvariantCultureIgnoreCase) > -1)
decoder = new GifBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (type.IndexOf("png", StringComparison.InvariantCultureIgnoreCase) > -1)
decoder = new PngBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (type.IndexOf("jpg", StringComparison.InvariantCultureIgnoreCase) > -1 || type.IndexOf("jpeg", StringComparison.InvariantCultureIgnoreCase) > -1)
decoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
else if (type.IndexOf("bmp", StringComparison.InvariantCultureIgnoreCase) > -1)
decoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
}
if (decoder == null)
{
Logger.Error("Unable to determine type of image to decode. url = {0}", LogSource.BackgroundTask, url);
return;
}
_asyncSource = decoder.Frames[0];
_asyncSource.Freeze();
if (PropertyChanged != null)
PropertyChanged(this, new PropertyChangedEventArgs("AsyncSource"));
if (loaded != null)
loaded();
}
catch (Exception ex)
{
Logger.Error("An error has occured while trying to download an AsyncHttpImage. Url = {0} Exception = {1}", LogSource.BackgroundTask, url, ex);
}
finally
{
stream.Dispose();
}
});
}
catch (Exception ex)
{
Logger.Error("An error has occured while trying to download an AsyncHttpImage. Url = {0} Exception = {1}", LogSource.BackgroundTask, url, ex);
}
}
private static Bitmap GetBitmapFromStream(Stream input, ImageFormat format)
{
BitmapDecoder decoder;
if (format == ImageFormat.Bmp)
decoder = new BmpBitmapDecoder(input, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
else if (format == ImageFormat.Png)
decoder = new PngBitmapDecoder(input, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
else // Jpeg and other formats...
decoder = new JpegBitmapDecoder(input, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return GetBitmapFromFrames(decoder.Frames);
}
//static readonly byte[] pngHeader = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
//static readonly byte[] jpgHeader = { 0xFF, 0xD8, 0xFF };
//static readonly byte[] gifHeader = { 0x47, 0x49, 0x46 };
//static readonly byte[] bmpHeader = { 0x42, 0x4D };
public override PureImage FromStream(System.IO.Stream stream)
{
GMapImage ret = null;
if(stream != null)
{
var type = stream.ReadByte();
stream.Position = 0;
ImageSource m = null;
switch(type)
{
// PNG: 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A
case 0x89:
{
var bitmapDecoder = new PngBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad);
m = bitmapDecoder.Frames[0];
bitmapDecoder = null;
}
break;
// JPG: 0xFF, 0xD8, 0xFF
case 0xFF:
{
var bitmapDecoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad);
m = bitmapDecoder.Frames[0];
bitmapDecoder = null;
}
break;
// GIF: 0x47, 0x49, 0x46
case 0x47:
{
var bitmapDecoder = new GifBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad);
m = bitmapDecoder.Frames[0];
bitmapDecoder = null;
}
break;
// BMP: 0x42, 0x4D
case 0x42:
{
var bitmapDecoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad);
m = bitmapDecoder.Frames[0];
bitmapDecoder = null;
}
break;
// TIFF: 0x49, 0x49 || 0x4D, 0x4D
case 0x49:
case 0x4D:
{
var bitmapDecoder = new TiffBitmapDecoder(stream, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.OnLoad);
m = bitmapDecoder.Frames[0];
bitmapDecoder = null;
}
break;
default:
{
Debug.WriteLine("WindowsPresentationImageProxy: unknown image format: " + type);
}
break;
}
if(m != null)
{
ret = new GMapImage();
ret.Img = m;
if(ret.Img.CanFreeze)
{
ret.Img.Freeze();
}
}
}
return ret;
}
private static BitmapFrame GetBitmapFrame(string sourceFile, Stream s)
{
BitmapDecoder d;
string extension = Path.GetExtension(sourceFile);
switch (extension.ToLower())
{
case ".jpg":
case ".jpeg":
d = new JpegBitmapDecoder(s, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
break;
case ".gif":
d = new GifBitmapDecoder(s, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
break;
case ".png":
d = new PngBitmapDecoder(s, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
break;
case ".bmp":
d = new BmpBitmapDecoder(s, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
break;
case ".tif":
case ".tiff":
d = new TiffBitmapDecoder(s, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.None);
break;
default:
throw new InvalidDataException("Unsupported file extension " + extension);
}
BitmapFrame frame = d.Frames[0];
return frame;
}
/// <summary>
/// Encode image fingerprint to wsq file
/// </summary>
/// <param name="FileSource">File source (bmp,tiff)</param>
/// <param name="FileDest">File wsq</param>
/// <param name="comments">Comments in image</param>
/// <param name="BitRate">Bit rate</param>
public void EnconderFile(String FileSource,
String FileDest,
String[] comments,
double BitRate)
{
try
{
switch (Path.GetExtension(FileSource).ToUpper())
{
case ".BMP":
case ".TIF":
break;
default:
throw new ApplicationException("Error: FileSource extension no supported");
}
if (Path.GetExtension(FileDest).ToUpper().Replace(".", "") != "WSQ")
{
throw new ApplicationException("Error: FileDest extension no supported");
}
Bitmap bm = null;
System.Drawing.Image img = null;
byte[] fileData;
Wsqm.cBitmap bitmap;
Wsqm.DataOutput data;
BitmapSource bitmapSource;
switch (Path.GetExtension(FileSource).ToUpper())
{
case ".BMP":
img = System.Drawing.Image.FromFile(FileSource);
bm = new Bitmap(img);
Uri myUri = new Uri(FileSource, UriKind.RelativeOrAbsolute);
BmpBitmapDecoder decoder2 = new BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
bitmapSource = decoder2.Frames[0];
fileData = GetBytesFromBitmapSource(bitmapSource);
bitmap = new Wsqm.cBitmap(fileData,
bm.Width,
bm.Height, 500, 8, 1);
data = new Wsqm.DataOutput();
data.RutaDestino = FileDest;
_EncoderWSQ.encode(data, bitmap, BitRate, comments);
img.Dispose();
break;
case ".TIF":
img = System.Drawing.Image.FromFile(FileSource);
bm = new Bitmap(img);
Stream imageStreamSource = new FileStream(FileSource, FileMode.Open, FileAccess.Read, FileShare.Read);
TiffBitmapDecoder decoder = new TiffBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
bitmapSource = decoder.Frames[0];
fileData = GetBytesFromBitmapSource(bitmapSource);
bitmap = new Wsqm.cBitmap(fileData,
bm.Width,
bm.Height, 500, 8, 1);
data = new Wsqm.DataOutput();
data.RutaDestino = FileDest;
_EncoderWSQ.encode(data, bitmap, BitRate, comments);
img.Dispose();
imageStreamSource.Dispose();
break;
}
}
catch (Exception e)
{
throw (e);
}
}
/// <summary>
///
/// </summary>
/// <param name="serviceProvider"></param>
/// <returns></returns>
public override object ProvideValue(IServiceProvider serviceProvider)
{
Assembly caller = Assembly.GetEntryAssembly();
var obj = caller.GetType(ClassName).GetProperty(ResourceName, BindingFlags.Static | BindingFlags.NonPublic);
if (obj != null)
{
var val = obj.GetValue(obj, null);
if (val != null)
{
MemoryStream mstr = new MemoryStream();
BitmapDecoder decoder = null;
if (val is Icon)
{
((Icon)val).Save(mstr);
decoder = new IconBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
else if (val is Bitmap)
{
Bitmap bmp = val as Bitmap;
if (ImageFormat == ImageFormat.Png)
{
bmp.Save(mstr, ImageFormat.Png);
decoder = new PngBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
else if (ImageFormat == ImageFormat.Tiff)
{
bmp.Save(mstr, ImageFormat.Tiff);
decoder = new TiffBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
else if (ImageFormat == ImageFormat.Gif)
{
bmp.Save(mstr, ImageFormat.Gif);
decoder = new GifBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
else if (ImageFormat == ImageFormat.Jpeg)
{
bmp.Save(mstr, ImageFormat.Jpeg);
decoder = new JpegBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
else if (ImageFormat == ImageFormat.Bmp)
{
bmp.Save(mstr, ImageFormat.Bmp);
decoder = new BmpBitmapDecoder(mstr, BitmapCreateOptions.None, BitmapCacheOption.None);
}
}
if (decoder != null)
{
return decoder.Frames[0];
}
}
return null;
}
else
{
return null;
}
}
public void Load(string filename, FileTypes type)
{
Tags.Clear();
Title = "";
Description = "";
City = "";
Sublocation = "";
Country = "";
DateTaken = new DateTime(2000, 1, 1);
FileName = filename;
GeoLat = GeoLong = null;
StarRating = 0;
if (type == FileTypes.FileTypeUnknown)
{
if (filename.EndsWith(".jpg", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeJpeg;
else if (filename.EndsWith(".jpeg", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeJpeg;
else if (filename.EndsWith(".gif", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeGIF;
else if (filename.EndsWith(".png", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypePNG;
else if (filename.EndsWith(".tif", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeTiff;
else if (filename.EndsWith(".tiff", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeTiff;
else if (filename.EndsWith(".bmp", System.StringComparison.CurrentCultureIgnoreCase))
type = FileTypes.FileTypeBmp;
}
try
{
Stream pictureStream = new FileStream(filename, FileMode.Open, FileAccess.Read);
BitmapMetadata bitmapMetadata;
switch (type)
{
case FileTypes.FileTypeJpeg:
JpegBitmapDecoder JpegDecoder = new JpegBitmapDecoder(pictureStream, BitmapCreateOptions.None, BitmapCacheOption.None);
bitmapMetadata = (BitmapMetadata)JpegDecoder.Frames[0].Metadata;
if (bitmapMetadata.Keywords != null)
{
foreach (string tag in bitmapMetadata.Keywords)
Tags.Add(tag);
}
Title = bitmapMetadata.Title;
Description = bitmapMetadata.Comment;
if (bitmapMetadata.DateTaken != null)
DateTaken = DateTime.Parse(bitmapMetadata.DateTaken);
//City = (string)bitmapMetadata.GetQuery(@"/xmp/<xmpbag>photoshop:City");
City = (string)bitmapMetadata.GetQuery(@"/app13/irb/8bimiptc/iptc/city");
if (City == null)
City = "";
Sublocation = (string)bitmapMetadata.GetQuery(@"/app13/irb/8bimiptc/iptc/sub-location");
if (Sublocation == null)
Sublocation = "";
//Country = (string)bitmapMetadata.GetQuery(@"/xmp/<xmpbag>photoshop:Country");
Country = (string)bitmapMetadata.GetQuery(@"/app13/irb/8bimiptc/iptc/country\/primary location name");
if (Country == null)
Country = "";
byte[] Version = (byte[])bitmapMetadata.GetQuery(@"/app1/ifd/gps/");
if (Version != null)
{
ulong[] GeoLatInfo = (ulong[])bitmapMetadata.GetQuery(@"/app1/ifd/gps/subifd:{ulong=2}");
string GeoLatDirection = (string)bitmapMetadata.GetQuery(@"/app1/ifd/gps/subifd:{char=1}");
ulong[] GeoLongInfo = (ulong[])bitmapMetadata.GetQuery(@"/app1/ifd/gps/subifd:{ulong=4}");
string GeoLongDirection = (string)bitmapMetadata.GetQuery(@"/app1/ifd/gps/subifd:{char=3}");
if (GeoLatInfo != null && GeoLatDirection != null)
{
GeoLat = ConvertCoordinate(GeoLatInfo);
if (GeoLatDirection == "S")
GeoLat = -GeoLat;
}
if (GeoLongInfo != null && GeoLongDirection != null)
{
GeoLong = ConvertCoordinate(GeoLongInfo);
if (GeoLongDirection == "W")
GeoLong = -GeoLong;
}
}
StarRating = bitmapMetadata.Rating;
break;
case FileTypes.FileTypeTiff:
TiffBitmapDecoder TiffDecoder = new TiffBitmapDecoder(pictureStream, BitmapCreateOptions.None, BitmapCacheOption.None);
bitmapMetadata = (BitmapMetadata)TiffDecoder.Frames[0].Metadata;
if (bitmapMetadata.Keywords != null)
{
foreach (string tag in bitmapMetadata.Keywords)
Tags.Add(tag);
}
Title = bitmapMetadata.Title;
Description = bitmapMetadata.Comment;
if (bitmapMetadata.DateTaken != null)
DateTaken = DateTime.Parse(bitmapMetadata.DateTaken);
StarRating = bitmapMetadata.Rating;
break;
case FileTypes.FileTypeGIF:
GifBitmapDecoder GifDecoder = new GifBitmapDecoder(pictureStream, BitmapCreateOptions.None, BitmapCacheOption.None);
bitmapMetadata = (BitmapMetadata)GifDecoder.Frames[0].Metadata;
if (bitmapMetadata.Keywords != null)
{
foreach (string tag in bitmapMetadata.Keywords)
Tags.Add(tag);
}
Title = bitmapMetadata.Title;
Description = bitmapMetadata.Comment;
if (bitmapMetadata.DateTaken != null)
DateTaken = DateTime.Parse(bitmapMetadata.DateTaken);
StarRating = bitmapMetadata.Rating;
break;
case FileTypes.FileTypePNG:
PngBitmapDecoder PngDecoder = new PngBitmapDecoder(pictureStream, BitmapCreateOptions.None, BitmapCacheOption.None);
bitmapMetadata = (BitmapMetadata)PngDecoder.Frames[0].Metadata;
if (bitmapMetadata.Keywords != null)
{
foreach (string tag in bitmapMetadata.Keywords)
Tags.Add(tag);
}
Title = bitmapMetadata.Title;
Description = bitmapMetadata.Comment;
if (bitmapMetadata.DateTaken != null)
DateTaken = DateTime.Parse(bitmapMetadata.DateTaken);
StarRating = bitmapMetadata.Rating;
break;
case FileTypes.FileTypeBmp:
BmpBitmapDecoder BmpDecoder = new BmpBitmapDecoder(pictureStream, BitmapCreateOptions.None, BitmapCacheOption.None);
bitmapMetadata = (BitmapMetadata)BmpDecoder.Frames[0].Metadata;
if (bitmapMetadata.Keywords != null)
{
foreach (string tag in bitmapMetadata.Keywords)
Tags.Add(tag);
}
Title = bitmapMetadata.Title;
Description = bitmapMetadata.Comment;
if (bitmapMetadata.DateTaken != null)
DateTaken = DateTime.Parse(bitmapMetadata.DateTaken);
StarRating = bitmapMetadata.Rating;
break;
}
pictureStream.Close();
}
catch (Exception)
{
}
if (Title == null) Title = "";
if (Description == null) Description = "";
}
internal static BitmapDecoder CreateFromUriOrStream(
Uri baseUri,
Uri uri,
Stream stream,
BitmapCreateOptions createOptions,
BitmapCacheOption cacheOption,
RequestCachePolicy uriCachePolicy,
bool insertInDecoderCache
)
{
Guid clsId = Guid.Empty;
bool isOriginalWritable = false;
SafeMILHandle decoderHandle = null;
BitmapDecoder cachedDecoder = null;
Uri finalUri = null;
Stream uriStream = null;
UnmanagedMemoryStream unmanagedMemoryStream = null;
SafeFileHandle safeFilehandle = null;
// check to ensure that images are allowed in partial trust
DemandIfImageBlocked();
if (uri != null)
{
finalUri = (baseUri != null) ?
System.Windows.Navigation.BaseUriHelper.GetResolvedUri(baseUri, uri) :
uri;
if (insertInDecoderCache)
{
if ((createOptions & BitmapCreateOptions.IgnoreImageCache) != 0)
{
ImagingCache.RemoveFromDecoderCache(finalUri);
}
cachedDecoder = CheckCache(
finalUri,
out clsId
);
}
}
// try to retrieve the cached decoder
if (cachedDecoder != null)
{
decoderHandle = cachedDecoder.InternalDecoder;
}
else if ((finalUri != null) && (finalUri.IsAbsoluteUri) && (stream == null) &&
((finalUri.Scheme == Uri.UriSchemeHttp) ||
(finalUri.Scheme == Uri.UriSchemeHttps)))
{
return new LateBoundBitmapDecoder(baseUri, uri, stream, createOptions, cacheOption, uriCachePolicy);
}
else if ((stream != null) && (!stream.CanSeek))
{
return new LateBoundBitmapDecoder(baseUri, uri, stream, createOptions, cacheOption, uriCachePolicy);
}
else
{
// Create an unmanaged decoder
decoderHandle = BitmapDecoder.SetupDecoderFromUriOrStream(
finalUri,
stream,
cacheOption,
out clsId,
out isOriginalWritable,
out uriStream,
out unmanagedMemoryStream,
out safeFilehandle
);
}
BitmapDecoder decoder = null;
// Find out the decoder type and wrap it appropriately and return that
if (MILGuidData.GUID_ContainerFormatBmp == clsId)
{
decoder = new BmpBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatGif == clsId)
{
decoder = new GifBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatIco == clsId)
{
decoder = new IconBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatJpeg == clsId)
{
decoder = new JpegBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatPng == clsId)
{
decoder = new PngBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatTiff == clsId)
{
decoder = new TiffBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else if (MILGuidData.GUID_ContainerFormatWmp == clsId)
{
decoder = new WmpBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
else
{
decoder = new UnknownBitmapDecoder(
decoderHandle,
cachedDecoder,
baseUri,
uri,
stream,
createOptions,
cacheOption,
insertInDecoderCache,
isOriginalWritable,
uriStream,
unmanagedMemoryStream,
safeFilehandle
);
}
return decoder;
}
private static BitmapSource Load(object obj, BitmapEncoding enc,
BitmapCreateOptions create, BitmapCacheOption cache, out BitmapMetadata data)
{
BitmapDecoder dec = null;
if (obj is Stream)
{
Stream stream = obj as Stream;
switch (enc)
{
case BitmapEncoding.Bmp:
dec = new BmpBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Png:
dec = new PngBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Jpg:
dec = new JpegBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Tiff:
dec = new TiffBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Gif:
dec = new GifBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Wmp:
dec = new WmpBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Icon:
dec = new IconBitmapDecoder(stream, create, cache);
break;
default:
throw new NotImplementedException();
}
}
else if (obj is Uri)
{
Uri stream = obj as Uri;
switch (enc)
{
case BitmapEncoding.Bmp:
dec = new BmpBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Png:
dec = new PngBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Jpg:
dec = new JpegBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Tiff:
dec = new TiffBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Gif:
dec = new GifBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Wmp:
dec = new WmpBitmapDecoder(stream, create, cache);
break;
case BitmapEncoding.Icon:
dec = new IconBitmapDecoder(stream, create, cache);
break;
default:
throw new NotImplementedException();
}
}
else
throw new ArgumentException();
data = dec.Metadata;
return dec.Frames[0];
}
private void DrawContent()
{
pnlContent.Children.Clear();
if (Clipboard.ContainsText())
{
// we have some text in the clipboard.
TextBox tb = new TextBox();
tb.HorizontalScrollBarVisibility = ScrollBarVisibility.Auto;
tb.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
tb.Text = Clipboard.GetText();
tb.IsReadOnly = true;
tb.TextWrapping = TextWrapping.NoWrap;
pnlContent.Children.Add(tb);
}
else if (Clipboard.ContainsFileDropList())
{
// we have a file drop list in the clipboard
ListBox lb = new ListBox();
lb.ItemsSource = Clipboard.GetFileDropList();
pnlContent.Children.Add(lb);
}
else if (Clipboard.ContainsImage())
{
// Because of a known issue in WPF,
// we have to use a workaround to get correct
// image that can be displayed.
// The image have to be saved to a stream and then
// read out to workaround the issue.
MemoryStream ms = new MemoryStream();
BmpBitmapEncoder enc = new BmpBitmapEncoder();
enc.Frames.Add(BitmapFrame.Create(Clipboard.GetImage()));
enc.Save(ms);
ms.Seek(0, SeekOrigin.Begin);
BmpBitmapDecoder dec = new BmpBitmapDecoder(ms,
BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
Image img = new Image();
img.Stretch = Stretch.Uniform;
img.Source = dec.Frames[0];
pnlContent.Children.Add(img);
}
else
{
Label lb = new Label();
lb.Content = "The type of the data in the clipboard is not supported by this sample.";
pnlContent.Children.Add(lb);
}
}
private void CreateAndShowMainWindow()
{
// Create the application's main window
_mainWindow = new Window {Title = "BMP Imaging Sample"};
var mySv = new ScrollViewer();
var width = 128;
var height = width;
var stride = width/8;
var pixels = new byte[height*stride];
// Try creating a new image with a custom palette.
var colors = new List<Color>
{
Colors.Red,
Colors.Blue,
Colors.Green
};
var myPalette = new BitmapPalette(colors);
// Creates a new empty image with the pre-defined palette
var image = BitmapSource.Create(
width,
height,
96,
96,
PixelFormats.Indexed1,
myPalette,
pixels,
stride);
var stream = new FileStream("new.bmp", FileMode.Create);
var encoder = new BmpBitmapEncoder();
var myTextBlock = new TextBlock {Text = "Codec Author is: " + encoder.CodecInfo.Author};
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(stream);
// Open a Stream and decode a BMP image
Stream imageStreamSource = new FileStream("tulipfarm.bmp", FileMode.Open, FileAccess.Read, FileShare.Read);
var decoder = new BmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource bitmapSource = decoder.Frames[0];
// Draw the Image
var myImage = new Image
{
Source = bitmapSource,
Stretch = Stretch.None,
Margin = new Thickness(20)
};
// Open a Uri and decode a BMP image
var myUri = new Uri("tulipfarm.bmp", UriKind.RelativeOrAbsolute);
var decoder2 = new BmpBitmapDecoder(myUri, BitmapCreateOptions.PreservePixelFormat,
BitmapCacheOption.Default);
BitmapSource bitmapSource2 = decoder2.Frames[0];
// Draw the Image
var myImage2 = new Image
{
Source = bitmapSource2,
Stretch = Stretch.None,
Margin = new Thickness(20)
};
// Define a StackPanel to host the decoded BMP images
var myStackPanel = new StackPanel
{
Orientation = Orientation.Vertical,
VerticalAlignment = VerticalAlignment.Stretch,
HorizontalAlignment = HorizontalAlignment.Stretch
};
// Add the Image and TextBlock to the parent Grid
myStackPanel.Children.Add(myImage);
myStackPanel.Children.Add(myImage2);
myStackPanel.Children.Add(myTextBlock);
// Add the StackPanel as the Content of the Parent Window Object
mySv.Content = myStackPanel;
_mainWindow.Content = mySv;
_mainWindow.Show();
}
public ReadExifInfo(string fileName, FileInfo file)
{
try
{
using (foto = File.Open(fileName, FileMode.Open, FileAccess.Read))
{
JpegBitmapDecoder jpegdecoder;
PngBitmapDecoder pngdecoder;
BmpBitmapDecoder bmpdecoder;
GifBitmapDecoder gifdecoder;
IconBitmapDecoder icondecoder;
TiffBitmapDecoder tiffdecoder;
WmpBitmapDecoder wmpdecoder;
switch(file.Extension.ToLower())
{
case ".jpg":
jpegdecoder = new JpegBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)jpegdecoder.Frames[0].Metadata.Clone();
break;
case ".jpeg":
jpegdecoder = new JpegBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)jpegdecoder.Frames[0].Metadata.Clone();
break;
case ".png":
pngdecoder = new PngBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)pngdecoder.Frames[0].Metadata.Clone();
break;
case ".bmp":
bmpdecoder = new BmpBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)bmpdecoder.Frames[0].Metadata.Clone();
break;
case ".gif":
gifdecoder = new GifBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)gifdecoder.Frames[0].Metadata.Clone();
break;
case ".ico":
icondecoder = new IconBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)icondecoder.Frames[0].Metadata.Clone();
break;
case ".tiff":
tiffdecoder = new TiffBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)tiffdecoder.Frames[0].Metadata.Clone();
break;
case ".wmp":
wmpdecoder = new WmpBitmapDecoder(foto, BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
bm = (BitmapMetadata)wmpdecoder.Frames[0].Metadata.Clone();
break;
}
creationTime = Convert.ToDateTime(bm.DateTaken);
}
}
catch (Exception ex) { WPF.MessageBox.Show(fileName + "\n" + ex.Message, "Decoder Exception"); }
}
/// <summary>
/// <c>Bitmap</c> to <c>BitmapSource</c> conversion method in order to show the edited image at the main window.
/// </summary>
/// <remarks>Extension method.</remarks>
public static BitmapFrame BitmapToBitmapSource(this Bitmap bitmap) {
// Convert Bitmap to BitmapImage
MemoryStream str = new MemoryStream();
bitmap.Save(str, ImageFormat.Bmp);
str.Seek(0, SeekOrigin.Begin);
BmpBitmapDecoder bdc = new BmpBitmapDecoder(str, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
return bdc.Frames[0];
}
/// <summary>
/// Decomposes a level bitmap to a tile sheet and a <see cref="LevelSheet"/>.
/// </summary>
/// <param name="fileName">Bitmap of the level to decompose.</param>
/// <param name="tileWidth">Tile width, must be a multiple of <see cref="fileName"/> width.</param>
/// <param name="tileHeight">Tile height, must be a multiple of <see cref="fileName"/> height.</param>
/// <param name="targetJson">File to write the <see cref="LevelSheet"/> to.</param>
/// <param name="targetPng">File to write the level tiles to.</param>
/// <param name="sheetWidth">Width in pixels of the tile sheet, must be a multiple of 2.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void Decompose(string fileName, int tileWidth, int tileHeight, string targetJson, string targetPng, int sheetWidth)
{
if (fileName == null) throw new ArgumentNullException("fileName");
if (!File.Exists(fileName))
throw new ArgumentOutOfRangeException("fileName", "Input file name does not exist");
if (tileWidth <= 0) throw new ArgumentOutOfRangeException("tileWidth");
if (tileHeight <= 0) throw new ArgumentOutOfRangeException("tileHeight");
var image = new BitmapImage(new Uri(fileName, UriKind.RelativeOrAbsolute));
WriteableBitmap bitmap = BitmapFactory.ConvertToPbgra32Format(image);
int pixelWidth = bitmap.PixelWidth;
int pixelHeight = bitmap.PixelHeight;
if (pixelWidth % tileWidth != 0)
throw new ArgumentOutOfRangeException("tileWidth", "Tile width must be a multiple of image width");
if (pixelHeight % tileHeight != 0)
throw new ArgumentOutOfRangeException("tileHeight", "Tile height must be a multiple of image height");
if (targetJson == null) throw new ArgumentNullException("targetJson");
if (targetPng == null) throw new ArgumentNullException("targetPng");
if (sheetWidth <= 0)
throw new ArgumentOutOfRangeException("sheetWidth", "Must a multiple of two");
if (sheetWidth %2 !=0)
throw new ArgumentOutOfRangeException("sheetWidth", "Must a multiple of two");
int hTiles = pixelWidth / tileWidth;
int vTiles = pixelHeight / tileHeight;
WriteableBitmap target = BitmapFactory.New(tileWidth, tileHeight);
var dictionary = new Dictionary<string, LevelData>();
for (int y = 0; y < vTiles; y++)
{
for (int x = 0; x < hTiles; x++)
{
target.Blit(new Rect(0, 0, tileWidth, tileHeight), bitmap,
new Rect(x * tileWidth, y * tileHeight, tileWidth, tileHeight));
var bmpBitmapEncoder = new BmpBitmapEncoder();
bmpBitmapEncoder.Frames.Add(BitmapFrame.Create(target));
byte[] buffer;
using (var memoryStream = new MemoryStream())
{
bmpBitmapEncoder.Save(memoryStream);
buffer = memoryStream.GetBuffer();
}
byte[] hash;
using (SHA1 sha1 = SHA1.Create())
{
hash = sha1.ComputeHash(buffer);
}
IEnumerable<string> @select = hash.Select(s => s.ToString("X"));
string key = String.Concat(@select);
bool containsKey = dictionary.ContainsKey(key);
if (!containsKey)
{
dictionary.Add(key, new LevelData(buffer));
}
dictionary[key].Tiles.Add(new Tuple<int, int>(x, y));
}
}
// generate sheet
int count = dictionary.Count;
int tilesPerRow = sheetWidth / tileWidth;
int rows = count / tilesPerRow + 1;
int desiredHeight = rows * tileHeight;
WriteableBitmap writeableBitmap = BitmapFactory.New(tilesPerRow * tileWidth, rows * tileHeight);
int i = 0;
foreach (var myClass in dictionary)
{
byte[] bytes = myClass.Value.Pixels;
BmpBitmapDecoder decoder;
using (var memoryStream = new MemoryStream(bytes))
{
decoder = new BmpBitmapDecoder(memoryStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
BitmapFrame bitmapFrame = decoder.Frames[0];
WriteableBitmap source = BitmapFactory.ConvertToPbgra32Format(bitmapFrame);
var destRect = new Rect(i * tileWidth, 0, tileWidth, tileHeight);
destRect.X = i % tilesPerRow * tileWidth;
destRect.Y = i / tilesPerRow * tileHeight;
writeableBitmap.Blit(destRect, source, new Rect(0, 0, tileWidth, tileHeight));
i++;
}
// save level
int i1 = hTiles * vTiles;
var level = new int[i1];
int j = 0;
foreach (var myClass in dictionary)
{
List<Tuple<int, int>> tuples = myClass.Value.Tiles;
foreach (var tuple in tuples)
{
int x = tuple.Item1;
int y = tuple.Item2;
int offset = y * hTiles + x;
level[offset] = j;
}
j++;
}
// Save bitmap
string pngDirectory = EnsureDirectoryExists(targetPng);
string pngFile = Path.GetFileName(targetPng);
string pngPath = Path.Combine(pngDirectory, pngFile);
using (Stream stream = File.OpenWrite(pngPath))
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(writeableBitmap));
encoder.Save(stream);
}
// Save sheet
var sheet = new LevelSheet(Path.GetFileName(targetPng), sheetWidth, desiredHeight, hTiles, vTiles,
tileWidth, tileHeight, level);
string json = JsonConvert.SerializeObject(sheet, Formatting.Indented);
string jsonDirectory = EnsureDirectoryExists(targetJson);
string jsonFile = Path.GetFileName(targetJson);
string jsonPath = Path.Combine(jsonDirectory, jsonFile);
File.WriteAllText(jsonPath, json);
}
private void Load_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialogue = new OpenFileDialog()
{
Filter = "Bitmap Image (.bmp)|*.bmp|Gif Image (.gif)|*.gif|JPEG Image (.jpeg)|*.jpeg|Png Image (.png)|*.png|Tiff Image (.tiff)|*.tiff|Wmf Image (.wmf)|*.wmf"
};
if (openFileDialogue.ShowDialog() == true)
{
Stream imageStreamSource = new FileStream(openFileDialogue.FileName, FileMode.Open, FileAccess.Read, FileShare.Read);
BitmapDecoder decoder;
#region Decoding
string extension = System.IO.Path.GetExtension(openFileDialogue.FileName);
switch (extension.ToLower())
{
case ".jpeg":
decoder = new JpegBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
case ".png":
decoder = new PngBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
case ".gif":
decoder = new GifBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
case ".tiff":
decoder = new TiffBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
case ".wmf":
decoder = new WmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
case ".bmp":
decoder = new BmpBitmapDecoder(imageStreamSource, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
break;
default:
return;
}
#endregion
BitmapSource LoadedBitmap = decoder.Frames[0];
MyCanvas.Children.Clear();
MyCanvas.Width = LoadedBitmap.Width;
MyCanvas.Height = LoadedBitmap.Height;
MyCanvas.Children.Add(
new Image() { Source = LoadedBitmap }
);
}
}
public object ReadBmp(Stream stream)
{
var decoder = new BmpBitmapDecoder(stream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
return decoder.Frames[0].Clone();
}