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();
}
private void EncodeFluxJpeg()
{
Log.Message("0 - start");
// Get all needed data which could collide as fast as possible
bool localManuallyTriggered = manuallyTriggered;
string filePath = CreateCurrentFilePath();
// Convert temp data to local raw data
byte[][,] rawImage = new byte[3][, ];
Log.Message("1");
rawImage[0] = new byte[imageTextureWidth, imageTextureHeight];
rawImage[1] = new byte[imageTextureWidth, imageTextureHeight];
rawImage[2] = new byte[imageTextureWidth, imageTextureHeight];
Log.Message("1");
for (int row = 0; row < imageTextureHeight; row++)
{
for (int col = 0; col < imageTextureWidth; col++)
{
int index = ((imageTextureHeight - 1 - row) * imageTextureWidth + col) * 3;
rawImage[0][col, row] = imageTextureRawData[index];
rawImage[1][col, row] = imageTextureRawData[index + 1];
rawImage[2][col, row] = imageTextureRawData[index + 2];
}
}
Log.Message("3 - post raw");
// Tmp cleanup
ctrlEncodingPost = true;
// Encode raw data and save the final image
ColorModel model = new ColorModel {
colorspace = FluxJpeg.Core.ColorSpace.RGB
};
Log.Message("4");
FluxJpeg.Core.Image image = new FluxJpeg.Core.Image(model, rawImage);
Log.Message("5 - post image");
FileStream fileStream = new FileStream(filePath, FileMode.Create);
Log.Message("6 . post fs");
JpegEncoder encoder = new JpegEncoder(image, 75, fileStream);
Log.Message("7 - post encode");
encoder.Encode();
Log.Message("8 - post save");
// Local cleanup
fileStream.Dispose();
image = null;
rawImage = null;
Log.Message("end - 9");
// Create tmp copy to file if needed
if (!localManuallyTriggered && PRModSettings.fileNamePattern == FileNamePattern.BothTmpCopy)
{
File.Copy(filePath, CreateFilePath(FileNamePattern.Numbered, true));
}
}
// as found here: http://blog.blueboxes.co.uk/2009/07/21/rendering-xaml-to-a-jpeg-using-silverlight-3/
// also see attribution to SO post here: http://stackoverflow.com/questions/1139200/using-fjcore-to-encode-silverlight-writeablebitmap
private static void SaveBitmapToJpeg(WriteableBitmap bitmap, Stream fs)
{
//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();
FluxJpeg.Core.Encoder.JpegEncoder encoder = new FluxJpeg.Core.Encoder.JpegEncoder(img, 100, stream);
encoder.Encode();
//Move back to the start of the stream
stream.Seek(0, SeekOrigin.Begin);
//Get the Bytes and write them to the stream
byte[] binaryData = new Byte[stream.Length];
long bytesRead = stream.Read(binaryData, 0, (int)stream.Length);
fs.Write(binaryData, 0, binaryData.Length);
}
private string ConvertToString(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 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);
}
/// <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 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
MemoryStream stream = new MemoryStream();
FluxJpeg.Core.Encoder.JpegEncoder encoder = new FluxJpeg.Core.Encoder.JpegEncoder(img, 100, stream);
encoder.Encode();
// Back to the start
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public static Stream EncodeWriteableBitmap(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);
}
}
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 EncodeJpg(WriteableBitmap bitmap, Stream destinationStream)
{
int width = bitmap.PixelWidth;
int height = bitmap.PixelHeight;
int bands = 3; // RGB
byte[][,] raster = new byte[bands][, ];
// initialise the bands
for (int i = 0; i < bands; i++)
{
raster[i] = new byte[width, height];
}
// copy over the pixel data from the bitmap
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;
}
}
// Use the Flux library to encode the JPG
ColorModel model = new ColorModel {
colorspace = ColorSpace.RGB
};
FluxJpeg.Core.Image img = new FluxJpeg.Core.Image(model, raster);
// encode it to the destination stream
JpegEncoder encoder = new JpegEncoder(img, 90, destinationStream);
encoder.Encode();
}
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);
}
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);
}
//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();
}
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;
}
/// <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;
}
/// <summary>
/// Encodes the data of the specified image and writes the result to
/// the specified stream.
/// </summary>
/// <param name="image">The image, where the data should be get from.
/// Cannot be null (Nothing in Visual Basic).</param>
/// <param name="stream">The stream, where the image data should be written to.
/// Cannot be null (Nothing in Visual Basic).</param>
/// <exception cref="System.ArgumentNullException">
/// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para>
/// <para>- or -</para>
/// <para><paramref name="stream"/> is null (Nothing in Visual Basic).</para>
/// </exception>
public void Encode(ExtendedImage image, Stream stream)
{
Guard.NotNull(image, "image");
Guard.NotNull(stream, "stream");
const int bands = 3;
int pixelWidth = image.PixelWidth;
int pixelHeight = image.PixelHeight;
byte[] sourcePixels = image.Pixels;
byte[][,] pixels = new byte[bands][,];
for (int b = 0; b < bands; b++)
{
pixels[b] = new byte[pixelWidth, pixelHeight];
}
for (int y = 0; y < pixelHeight; y++)
{
for (int x = 0; x < pixelWidth; x++)
{
int offset = (y * pixelWidth + x) * 4;
float a = (float)sourcePixels[offset + 3] / 255.0f;
pixels[0][x, y] = (byte)(sourcePixels[offset + 0] * a + (1 - a) * _transparentColor.R);
pixels[1][x, y] = (byte)(sourcePixels[offset + 1] * a + (1 - a) * _transparentColor.G);
pixels[2][x, y] = (byte)(sourcePixels[offset + 2] * a + (1 - a) * _transparentColor.B);
}
}
Image newImage = new Image(new ColorModel { ColorSpace = ColorSpace.RGB, Opaque = false }, pixels);
if (image.DensityXInt32 > 0 && image.DensityYInt32 > 0)
{
newImage.DensityX = image.DensityXInt32;
newImage.DensityY = image.DensityYInt32;
}
// Create a jpg image from the image object.
DecodedJpeg jpg = new DecodedJpeg(newImage);
// Create a new encoder and start encoding.
FluxCoreJpegEncoder fluxCoreJpegEncoder = new FluxCoreJpegEncoder(jpg, _quality, stream);
fluxCoreJpegEncoder.Encode();
}
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);
}
}
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;
}
/// <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 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
MemoryStream stream = new MemoryStream();
FluxJpeg.Core.Encoder.JpegEncoder encoder = new FluxJpeg.Core.Encoder.JpegEncoder(img, 100, stream);
encoder.Encode();
// Back to the start
stream.Seek(0, 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();
}
