private static void SaveToJPG(WriteableBitmap bitmap, Stream stream)
{
int width = bitmap.PixelWidth;
int height = bitmap.PixelHeight;
int bands = 3;
byte[][,] raster = new byte[bands][,];
for (int i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
for (int row = 0; row < height; row++)
{
for (int column = 0; column < width; column++)
{
int pixel = bitmap.Pixels[width * row + column];
raster[0][column, row] = (byte)(pixel >> 16);
raster[1][column, row] = (byte)(pixel >> 8);
raster[2][column, row] = (byte)pixel;
}
}
ColorModel model = new ColorModel { colorspace = ColorSpace.RGB };
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
JpegEncoder encoder = new JpegEncoder(img, JpgQuality, stream);
encoder.Encode();
}
static MemoryStream Encode(Image image)
{
MemoryStream outStream = new MemoryStream();
JpegEncoder encoder = new JpegEncoder(image, 85, outStream);
encoder.Encode();
outStream.Seek(0, SeekOrigin.Begin);
return outStream;
}
public static Stream Encode(WriteableBitmap bitmap, int quality)
{
//Convert the Image to pass into FJCore
int width = bitmap.PixelWidth;
int height = bitmap.PixelHeight;
int bands = 3;
byte[][,] raster = new byte[bands][,];
for (int i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
for (int row = 0; row < height; row++)
{
for (int column = 0; column < width; column++)
{
int pixel = bitmap.Pixels[width * row + column];
raster[0][column, row] = (byte)(pixel >> 16);
raster[1][column, row] = (byte)(pixel >> 8);
raster[2][column, row] = (byte)pixel;
}
}
ColorModel model = new ColorModel { colorspace = ColorSpace.RGB };
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
//Encode the Image as a JPEG
MemoryStream stream = new MemoryStream();
JpegEncoder encoder = new JpegEncoder(img, quality, stream);
encoder.Encode();
//Move back to the start of the stream
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
return stream;
}
public static void EncodeJpeg(WriteableBitmap bmp, Stream dstStream)
{
// Init buffer in FluxJpeg format
int w = bmp.PixelWidth;
int h = bmp.PixelHeight;
int[] p = bmp.Pixels;
byte[][,] pixelsForJpeg = new byte[3][,]; // RGB colors
pixelsForJpeg[0] = new byte[h, w];
pixelsForJpeg[1] = new byte[h, w];
pixelsForJpeg[2] = new byte[h, w];
// Copy WriteableBitmap data into buffer for FluxJpeg
int i = 0;
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
int color = p[i++];
// Swap x and y coordinates to cheaply rotate the image 90° clockwise
pixelsForJpeg[0][y, x] = (byte)(color >> 16); // R
pixelsForJpeg[1][y, x] = (byte)(color >> 8); // G
pixelsForJpeg[2][y, x] = (byte)(color); // B
}
}
using (MemoryStream memStream = new MemoryStream())
{
//Encode Image as JPEG
var jpegImage = new FluxJpeg.Core.Image(new ColorModel { colorspace = ColorSpace.RGB }, pixelsForJpeg);
var encoder = new JpegEncoder(jpegImage, 95, memStream);
encoder.Encode();
// Seek to begin of stream and write the encoded bytes to the FileSteram
memStream.Seek(0, SeekOrigin.Begin);
// Use the new .Net 4 CopyTo method :)
memStream.CopyTo(dstStream);
}
}
private Stream ResizeImage(Stream image_stream, int width, int height, int quality, ImageType type)
{
try {
// Load the image as a writeablebitmap
WriteableBitmap writableBitmap;
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.SetSource(image_stream);
writableBitmap = new WriteableBitmap(bitmapImage);
double scale = Math.Min((double) width / writableBitmap.PixelWidth, (double) height / writableBitmap.PixelHeight);
// No resize needed
if (scale >= 1.0)
return image_stream;
// Setup shorter names and pixelbuffers
int w = writableBitmap.PixelWidth;
int h = writableBitmap.PixelHeight;
int[] p = writableBitmap.Pixels;
byte[][,] imageRaster = new byte[3][,]; // RGB colors
imageRaster[0] = new byte[w, h];
imageRaster[1] = new byte[w, h];
imageRaster[2] = new byte[w, h];
// Copy WriteableBitmap data into buffer for FluxJpeg
int i = 0;
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
int color = p[i++];
imageRaster[0][x, y] = (byte) (color >> 16); // R
imageRaster[1][x, y] = (byte) (color >> 8); // G
imageRaster[2][x, y] = (byte) (color); // B
}
}
// Create new FluxJpeg image based on pixel data
FluxJpeg.Core.Image jpegImage = new FluxJpeg.Core.Image(new ColorModel {
colorspace = ColorSpace.RGB
}, imageRaster);
// Calc new proportional size
width = (int) Math.Round(writableBitmap.PixelWidth * scale);
height = (int) Math.Round(writableBitmap.PixelHeight * scale);
// Resize the image
ImageResizer resizer = new ImageResizer(jpegImage);
Image resizedImage = resizer.Resize(width, height, FluxJpeg.Core.Filtering.ResamplingFilters.LowpassAntiAlias);
Stream imageStream = new MemoryStream();
if (type == ImageType.Jpeg) {
// Encode the resized image as Jpeg
JpegEncoder jpegEncoder = new JpegEncoder(resizedImage, quality, imageStream);
jpegEncoder.Encode();
} else {
int[] pixelBuffer = new int[resizedImage.Height * resizedImage.Width];
byte[][,] resizedRaster = resizedImage.Raster;
// Convert FJCore raster to PixelBuffer
for (int y = 0; y < resizedImage.Height; y++) {
for (int x = 0; x < resizedImage.Width; x++) {
int color = 0;
color = color | resizedRaster[0][x, y] << 16; // R
color = color | resizedRaster[1][x, y] << 8; // G
color = color | resizedRaster[2][x, y]; // B
pixelBuffer[(y * resizedImage.Width) + x] = color;
}
}
// Encode the resized image as Png
PngEncoder pngEncoder = new PngEncoder(pixelBuffer, resizedImage.Width, resizedImage.Height, false, PngEncoder.FILTER_NONE, Deflater.BEST_COMPRESSION);
byte[] pngBuffer = pngEncoder.pngEncode();
imageStream.Write(pngBuffer, 0, pngBuffer.Length);
}
return imageStream;
} catch {
// Ignore the error and let the server resize the image
}
return image_stream;
}
//http://kodierer.blogspot.com/2009/11/convert-encode-and-decode-silverlight.html
public static void EncodeJpeg(WriteableBitmap bmp, Stream destinationStream)
{
// Init buffer in FluxJpeg format
int w = bmp.PixelWidth;
int h = bmp.PixelHeight;
int[] p = bmp.Pixels;
byte[][,] pixelsForJpeg = new byte[3][,]; // RGB colors
pixelsForJpeg[0] = new byte[w, h];
pixelsForJpeg[1] = new byte[w, h];
pixelsForJpeg[2] = new byte[w, h];
// Copy WriteableBitmap data into buffer for FluxJpeg
int i = 0;
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
int color = p[i++];
pixelsForJpeg[0][x, y] = (byte)(color >> 16); // R
pixelsForJpeg[1][x, y] = (byte)(color >> 8); // G
pixelsForJpeg[2][x, y] = (byte)(color); // B
}
}
// Encode Image as JPEG using the FluxJpeg library
// and write to destination stream
ColorModel cm = new ColorModel { colorspace = ColorSpace.RGB };
FluxJpeg.Core.Image jpegImage = new FluxJpeg.Core.Image(cm, pixelsForJpeg);
JpegEncoder encoder = new JpegEncoder(jpegImage, 95, destinationStream);
encoder.Encode();
}
/// <summary>
/// 老外写的方法：将WriteableBitmap转化为base64位字符串
/// </summary>
/// <param name="bitmap"></param>
/// <returns></returns>
private string GetBase64Image(WriteableBitmap bitmap)
{
int width = bitmap.PixelWidth;
int height = bitmap.PixelHeight;
int bands = 3;
byte[][,] raster = new byte[bands][,];
for (int i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
for (int row = 0; row < height; row++)
{
for (int column = 0; column < width; column++)
{
int pixel = bitmap.Pixels[width * row + column];
raster[0][column, row] = (byte)(pixel >> 16);
raster[1][column, row] = (byte)(pixel >> 8);
raster[2][column, row] = (byte)pixel;
}
}
ColorModel model = new ColorModel { colorspace = ColorSpace.RGB };
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
MemoryStream stream = new MemoryStream();
JpegEncoder encoder = new JpegEncoder(img, 100, stream);
encoder.Encode();
stream.Seek(0, SeekOrigin.Begin);
byte[] binaryData = new Byte[stream.Length];
long bytesRead = stream.Read(binaryData, 0, (int)stream.Length);
string base64String =
System.Convert.ToBase64String(binaryData,
0,
binaryData.Length);
return base64String;
}
public string ImportarImagen(string NombreArchivo)
{
string MyPicturesPath = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
string FilePath = MyPicturesPath + "\\" + NombreArchivo + ".jpg";
string TempPath = MyPicturesPath + "\\Temp.jpg";
try
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Imagenes |*.jpg;*.png;*.bmp";
if (dialog.ShowDialog() == true)
{
if (File.Exists(FilePath))
{
File.Delete(FilePath);
}
File.Copy(dialog.File.FullName, FilePath);
long fileLength = new FileInfo(FilePath).Length;
//MessageBox.Show("tamaño anterior: " + fileLength);
//Si la imagen escaneada es mayor 50Kb, se itera reduciendo la imagen a la mitad de su tamaño
while (fileLength > 51200)
{
if (File.Exists(TempPath))
{
File.Delete(TempPath);
}
if (File.Exists(FilePath))
{
File.Copy(FilePath, TempPath);
File.Delete(FilePath);
}
using (Stream Stream = File.OpenRead(TempPath))
{
BitmapImage image = new BitmapImage();
image.SetSource(Stream);
MemoryStream outStream = new MemoryStream();
Stream.Seek(0, SeekOrigin.Begin);
JpegDecoder decoder = new JpegDecoder(Stream);
DecodedJpeg jpeg = decoder.Decode();
ImageResizer resizer = new ImageResizer(jpeg.Image);
FluxJpeg.Core.Image small = resizer.Resize(Convert.ToInt32(Math.Floor(image.PixelWidth / 2)), Convert.ToInt32(Math.Floor(image.PixelHeight / 2)), ResamplingFilters.NearestNeighbor);
JpegEncoder encoder = new JpegEncoder(small, 90, outStream);
encoder.Encode();
outStream.Seek(0, SeekOrigin.Begin);
int bufferSize = Convert.ToInt32(outStream.Length);
byte[] buffer = new byte[bufferSize];
outStream.Read(buffer, 0, bufferSize);
outStream.Close();
Stream.Close();
File.WriteAllBytes(FilePath, buffer);
}
if (File.Exists(TempPath))
{
File.Delete(TempPath);
}
fileLength = new FileInfo(FilePath).Length;
}
return FilePath;
}
else
{
return "Error: No se selecciono ningún archivo";
}
}
catch (Exception ex)
{
return ("Error de Aplicación: " + ex.Message);
//return "";
}
}
public void getAsEncodedStream(Stream imageStream, string type = null, int quality = 90)
{
if (type != null) {
type = this.type != "" ? this.type : JPEG.MIME;
}
if (type == JPEG.MIME) // Encode as JPEG
{
byte[][,] raster = _bm.ToRaster();
FluxJpeg.Core.Image jpegImage = new FluxJpeg.Core.Image(new ColorModel {
colorspace = ColorSpace.RGB
}, raster);
JpegEncoder jpegEncoder = new JpegEncoder(jpegImage, quality, imageStream);
jpegEncoder.Encode();
// TODO: restore jpeg headers here
}
else if (type == PNG.MIME) // Encode as PNG
{
PngEncoder pngEncoder = new PngEncoder(_bm.Pixels, _bm.PixelWidth, _bm.PixelHeight, false, PngEncoder.FILTER_NONE, Deflater.BEST_COMPRESSION);
byte[] pngBuffer = pngEncoder.pngEncode();
imageStream.Write(pngBuffer, 0, pngBuffer.Length);
}
else
{
Error(this, null);
}
}
public MemoryStream getAsEncodedStream(string type = null, int quality = 90)
{
MemoryStream imageStream = new MemoryStream();
if (type != null) {
type = this.type != "" ? this.type : JPEG.MIME;
}
if (type == JPEG.MIME) // Encode as JPEG
{
byte[][,] raster = _bm.ToRaster();
FluxJpeg.Core.Image jpegImage = new FluxJpeg.Core.Image(new ColorModel {
colorspace = ColorSpace.RGB
}, raster);
JpegEncoder jpegEncoder = new JpegEncoder(jpegImage, quality, imageStream);
jpegEncoder.Encode();
if (_img != null) {
// strip off any headers that might be left by encoder, etc
imageStream = new MemoryStream(((JPEG)_img).stripHeaders(imageStream));
if (_preserveHeaders) {
imageStream = new MemoryStream(((JPEG)_img).insertHeaders(imageStream));
}
}
}
else if (type == PNG.MIME) // Encode as PNG
{
PngEncoder pngEncoder = new PngEncoder(_bm.Pixels, _bm.PixelWidth, _bm.PixelHeight, false, PngEncoder.FILTER_NONE, Deflater.BEST_COMPRESSION);
byte[] pngBuffer = pngEncoder.pngEncode();
imageStream.Write(pngBuffer, 0, pngBuffer.Length);
}
else
{
Error(this, null);
return null;
}
return imageStream;
}
void UploadFrame(WriteableBitmap bmp, string kind, string fileName, bool replace)
{
PlaySound("shutter");
int W = bmp.PixelWidth;
int H = bmp.PixelHeight;
byte[][,] buf = FJ.Image.CreateRaster(W, H, 3);
int[] pix = bmp.Pixels;
for (int y = 0; y < H; ++y)
{
for (int x = 0, i = y * W; x < W; ++x, ++i)
{
int n = pix[i];
buf[0][x,y] = (byte)((n >> 16) & 255);
buf[1][x,y] = (byte)((n >> 8) & 255);
buf[2][x,y] = (byte)(n & 255);
}
}
MemoryStream stream = new MemoryStream();
FJ.Image img = new FJ.Image(new FJ.ColorModel { colorspace = FJ.ColorSpace.RGB }, buf);
JpegEncoder enc = new JpegEncoder(img, 80, stream);
enc.Encode();
stream.Seek(0, SeekOrigin.Begin);
Form form = new Form();
form["name"] = nameTextField.Text;
form["pin"] = m_verified;
form["kind"] = kind;
form["width"] = W.ToString();
form["height"] = H.ToString();
if (replace)
{
form["replace"] = "replace";
}
form.Add(new FileData("file", stream, stream.Length, "image/jpeg", System.IO.Path.GetFileNameWithoutExtension(fileName) + ".jpg"));
form.Submit(WebRequest.CreateHttp(m_baseUrl + "upload"), (FormSubmissionEventArgs e) =>
{
if (!e.Success)
{
PlaySound("error");
SetMode(Mode.Disconnected);
if (e.Response != null && e.Response.StatusCode == HttpStatusCode.NotFound)
{
SetReason(Reason.Rejected);
}
else
{
SetReason(Reason.NoConnection);
}
}
}, Dispatcher);
}
/// <summary>
/// Encode raster information to MemoryStream
/// </summary>
/// <param name="raster">Raster information (Array of bytes)</param>
/// <param name="colorSpace">ColorSpace used</param>
/// <returns>MemoryStream</returns>
public static System.IO.MemoryStream EncodeRasterInformationToStream(byte[][,] raster, ColorSpace colorSpace)
{
ColorModel model = new ColorModel { colorspace = ColorSpace.RGB };
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
//Encode the Image as a JPEG
System.IO.MemoryStream stream = new System.IO.MemoryStream();
FluxJpeg.Core.Encoder.JpegEncoder encoder = new FluxJpeg.Core.Encoder.JpegEncoder(img, 100, stream);
encoder.Encode();
// Back to the start
stream.Seek(0, System.IO.SeekOrigin.Begin);
return stream;
}
public static void EncodeJpeg(byte[] p, int h_in,int w_in, Stream dstStream)
{
// Init buffer in FluxJpeg format
int w = w_in;
int h = h_in;
byte[][,] pixelsForJpeg = new byte[3][,]; // RGB colors
pixelsForJpeg[0] = new byte[w, h];
pixelsForJpeg[1] = new byte[w, h];
pixelsForJpeg[2] = new byte[w, h];
// Copy WriteableBitmap data into buffer for FluxJpeg
int i = 0;
for (int y = h-1; y >=0 ; y--)
{
for (int x = 0; x < w; x++)
{
pixelsForJpeg[2][x, y] = p[i++]; // R
pixelsForJpeg[1][x, y] = p[i++]; // G
pixelsForJpeg[0][x, y] = p[i++]; // B
i++;
}
}
//Encode Image as JPEG
var jpegImage = new FluxJpeg.Core.Image(new ColorModel { colorspace = ColorSpace.RGB }, pixelsForJpeg);
var encoder = new JpegEncoder(jpegImage, 95, dstStream);
encoder.Encode();
}
