protected static void TestTiffEncoderCore <TPixel>(
TestImageProvider <TPixel> provider,
TiffBitsPerPixel?bitsPerPixel,
TiffPhotometricInterpretation photometricInterpretation,
TiffCompression compression = TiffCompression.None,
TiffPredictor predictor = TiffPredictor.None,
bool useExactComparer = true,
float compareTolerance = 0.001f,
IImageDecoder imageDecoder = null)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage();
var encoder = new TiffEncoder
{
PhotometricInterpretation = photometricInterpretation,
BitsPerPixel = bitsPerPixel,
Compression = compression,
HorizontalPredictor = predictor
};
// Does DebugSave & load reference CompareToReferenceInput():
image.VerifyEncoder(
provider,
"tiff",
bitsPerPixel,
encoder,
useExactComparer ? ImageComparer.Exact : ImageComparer.Tolerant(compareTolerance),
referenceDecoder: imageDecoder ?? ReferenceDecoder);
}
private void MenuSaveOnClick(object sender, EventArgs e)
{
if (_saveFileDialog.ShowDialog(this) != DialogResult.OK)
{
return;
}
ImageEncoder encoder = null;
switch (_saveFileDialog.FilterIndex)
{
case 1:
//for more control over saving, use the PdfCollection and PdfImage classes
encoder = new PdfEncoder();
break;
case 2:
encoder = new TiffEncoder();
break;
case 3:
encoder = new JpegEncoder();
break;
}
_workspaceViewer.Save(_saveFileDialog.FileName, encoder);
}
private void UploadFile(HttpContext context, string filename)
{
var file = context.Request.Files[0];
using (var outStream = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite))
{
using (var ms = new MemoryStream())
{
file.InputStream.CopyTo(ms);
ms.Seek(0, 0);
var decoder = RegisteredDecoders.GetDecoder(ms);
if (decoder is TiffDecoder || decoder is PdfDecoder || decoder is OfficeDecoder)
{
ms.CopyTo(outStream);
}
else
{
var ic = new ImageCollection(ms, null);
var tiffEncoder = new TiffEncoder();
ic.Save(outStream, tiffEncoder, null);
}
}
}
}
public void EncoderOptions_SetPhotometricInterpretationAndCompression_Works(
TiffPhotometricInterpretation?photometricInterpretation,
TiffCompression compression,
TiffBitsPerPixel expectedBitsPerPixel,
TiffCompression expectedCompression)
{
// arrange
var tiffEncoder = new TiffEncoder {
PhotometricInterpretation = photometricInterpretation, Compression = compression
};
using Image input = new Image <Rgb24>(10, 10);
using var memStream = new MemoryStream();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
TiffFrameMetadata rootFrameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, rootFrameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, rootFrameMetaData.Compression);
}
public void TiffEncoder_EncodeMultiframe_Create <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage();
using var image0 = new Image <Rgba32>(image.Width, image.Height, Color.Red.ToRgba32());
using var image1 = new Image <Rgba32>(image.Width, image.Height, Color.Green.ToRgba32());
using var image2 = new Image <Rgba32>(image.Width, image.Height, Color.Yellow.ToRgba32());
image.Frames.AddFrame(image0.Frames.RootFrame);
image.Frames.AddFrame(image1.Frames.RootFrame);
image.Frames.AddFrame(image2.Frames.RootFrame);
image.Frames.RemoveFrame(0);
TiffBitsPerPixel bitsPerPixel = TiffBitsPerPixel.Bit8;
var encoder = new TiffEncoder
{
PhotometricInterpretation = TiffPhotometricInterpretation.PaletteColor,
BitsPerPixel = bitsPerPixel,
Compression = TiffCompression.Lzw
};
using (var ms = new System.IO.MemoryStream())
{
image.Save(ms, encoder);
ms.Position = 0;
using var output = Image.Load <Rgba32>(ms);
Assert.Equal(3, output.Frames.Count);
ImageFrame <Rgba32> frame0 = output.Frames[0];
ImageFrame <Rgba32> frame1 = output.Frames[1];
ImageFrame <Rgba32> frame2 = output.Frames[2];
Assert.Equal(Color.Red.ToRgba32(), frame0[10, 10]);
Assert.Equal(Color.Green.ToRgba32(), frame1[10, 10]);
Assert.Equal(Color.Yellow.ToRgba32(), frame2[10, 10]);
Assert.Equal(TiffCompression.Lzw, frame0.Metadata.GetTiffMetadata().Compression);
Assert.Equal(TiffCompression.Lzw, frame1.Metadata.GetTiffMetadata().Compression);
Assert.Equal(TiffCompression.Lzw, frame1.Metadata.GetTiffMetadata().Compression);
Assert.Equal(TiffPhotometricInterpretation.PaletteColor, frame0.Metadata.GetTiffMetadata().PhotometricInterpretation);
Assert.Equal(TiffPhotometricInterpretation.PaletteColor, frame1.Metadata.GetTiffMetadata().PhotometricInterpretation);
Assert.Equal(TiffPhotometricInterpretation.PaletteColor, frame2.Metadata.GetTiffMetadata().PhotometricInterpretation);
}
image.VerifyEncoder(
provider,
"tiff",
bitsPerPixel,
encoder,
ImageComparer.Exact);
}
public void TiffEncode_WorksWithDiscontiguousBuffers <TPixel>(TestImageProvider <TPixel> provider, TiffPhotometricInterpretation photometricInterpretation)
where TPixel : unmanaged, IPixel <TPixel>
{
provider.LimitAllocatorBufferCapacity().InPixelsSqrt(200);
using Image <TPixel> image = provider.GetImage();
var encoder = new TiffEncoder {
PhotometricInterpretation = photometricInterpretation
};
image.DebugSave(provider, encoder);
}
public void TiffCore()
{
TiffPhotometricInterpretation photometricInterpretation = TiffPhotometricInterpretation.Rgb;
var encoder = new TiffEncoder()
{
Compression = this.Compression, PhotometricInterpretation = photometricInterpretation
};
using var memoryStream = new MemoryStream();
this.core.SaveAsTiff(memoryStream, encoder);
}
public void TiffEncoder_PreservesCompression <TPixel>(TestImageProvider <TPixel> provider, TiffCompression expectedCompression)
where TPixel : unmanaged, IPixel <TPixel>
{
// arrange
var tiffEncoder = new TiffEncoder();
using Image <TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
Assert.Equal(expectedCompression, output.Frames.RootFrame.Metadata.GetTiffMetadata().Compression);
}
public void TiffCore()
{
TiffPhotometricInterpretation photometricInterpretation = TiffPhotometricInterpretation.Rgb;
// Workaround for 1-bit bug
if (this.Compression == TiffCompression.CcittGroup3Fax || this.Compression == TiffCompression.Ccitt1D)
{
photometricInterpretation = TiffPhotometricInterpretation.WhiteIsZero;
}
var encoder = new TiffEncoder()
{
Compression = this.Compression, PhotometricInterpretation = photometricInterpretation
};
using var memoryStream = new MemoryStream();
this.core.SaveAsTiff(memoryStream, encoder);
}
public void TiffEncoder_PreservesBitsPerPixel_WhenInputIsL8()
{
// arrange
var tiffEncoder = new TiffEncoder();
using Image input = new Image <L8>(10, 10);
using var memStream = new MemoryStream();
TiffBitsPerPixel expectedBitsPerPixel = TiffBitsPerPixel.Bit8;
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(expectedBitsPerPixel, frameMetaData.BitsPerPixel);
}
private string UploadFile(HttpContext context, string filename)
{
string msg = "";
HttpPostedFile file = context.Request.Files[0];
byte[] fileBytes = new byte[file.ContentLength];
file.InputStream.Read(fileBytes, 0, file.ContentLength);
using (FileStream outStream = new FileStream(filename, FileMode.CreateNew, FileAccess.ReadWrite))
{
using (MemoryStream ms = new MemoryStream())
{
ms.Write(fileBytes, 0, fileBytes.Length);
ms.Position = 0;
try
{
ImageDecoder decoder = RegisteredDecoders.GetDecoder(ms);
if (decoder is TiffDecoder)
{
outStream.Write(fileBytes, 0, fileBytes.Length);
outStream.Position = 0;
}
else
{
ImageCollection ic = new ImageCollection(ms, null);
TiffEncoder tiffEncoder = new TiffEncoder();
ic.Save(outStream, tiffEncoder, null);
}
}
catch (Exception ex)
{
msg = ex.Message;
}
ms.Position = 0;
}
}
return(msg);
}
public void EncoderOptions_UnsupportedBitPerPixel_DefaultTo24Bits(TiffBitsPerPixel bitsPerPixel)
{
// arrange
var tiffEncoder = new TiffEncoder {
BitsPerPixel = bitsPerPixel
};
using Image input = new Image <Rgb24>(10, 10);
using var memStream = new MemoryStream();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(TiffBitsPerPixel.Bit24, frameMetaData.BitsPerPixel);
}
/// <summary>
/// Examines the file extension on fileName to return the correct ImageEncoder
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
private ImageEncoder GetEncoder(string fileName)
{
string ext = Path.GetExtension(fileName);
ImageEncoder returnEnc = null;
if (ext != null)
{
switch (ext.ToLower())
{
// Not using these
//case ".jpg":
//case ".jpeg":
// returnEnc = new JpegEncoder();
// break;
//case ".png":
// returnEnc = new PngEncoder();
// break;
//case ".gif":
// returnEnc = new GifEncoder();
// break;
//case ".bmp":
// returnEnc = new BmpEncoder();
// break;
case ".tif":
case ".tiff":
returnEnc = new TiffEncoder();
break;
case ".pdf":
returnEnc = new PdfEncoder();
break;
default:
returnEnc = null;
break;
}
}
return(returnEnc);
}
public void EncoderOptions_SetBitPerPixel_Works(TiffBitsPerPixel bitsPerPixel)
{
// arrange
var tiffEncoder = new TiffEncoder {
BitsPerPixel = bitsPerPixel
};
using Image input = new Image <Rgb24>(10, 10);
using var memStream = new MemoryStream();
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(bitsPerPixel, frameMetaData.BitsPerPixel);
Assert.Equal(TiffCompression.None, frameMetaData.Compression);
}
public void TiffEncoder_EncodeMultiframe_RemoveFrames <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image = provider.GetImage();
Assert.True(image.Frames.Count > 1);
image.Frames.RemoveFrame(0);
TiffBitsPerPixel bitsPerPixel = TiffBitsPerPixel.Bit24;
var encoder = new TiffEncoder
{
PhotometricInterpretation = TiffPhotometricInterpretation.Rgb,
BitsPerPixel = bitsPerPixel,
Compression = TiffCompression.Deflate
};
image.VerifyEncoder(
provider,
"tiff",
bitsPerPixel,
encoder,
ImageComparer.Exact);
}
/// <summary>
/// Examines the file extension on fileName to return the correct ImageEncoder.
/// </summary>
/// <param name="fileName">Name of the file to examine.</param>
/// <returns><see cref="ImageEncoder"/> instance that can be used to encode specified file.</returns>
private ImageEncoder GetEncoder(string fileName)
{
string ext = Path.GetExtension(fileName);
ImageEncoder returnEnc = null;
if (ext != null)
{
switch (ext.ToLower())
{
case ".tif":
case ".tiff":
returnEnc = new TiffEncoder();
break;
case ".pdf":
returnEnc = new PdfEncoder();
break;
}
}
return(returnEnc);
}
public void ConvertToGrayScale(string sourceFile, string targetFile)
{
MultiFramedImageEncoder encoder = new TiffEncoder();
using (ImageSource src = new FileSystemImageSource(sourceFile, true))
{
ImageCollection images = new ImageCollection();
while (src.HasMoreImages())
{
AtalaImage img = src.AcquireNext();
img = img.GetChangedPixelFormat(PixelFormat.Pixel8bppGrayscale);
images.Add(img);
//img.Dispose();
}
using (Stream s = File.Create(targetFile))
{
encoder.Save(s, images, null);
}
}
}
public void TiffEncoder_EncodesWithCorrectBiColorModeCompression <TPixel>(TestImageProvider <TPixel> provider, TiffCompression compression, TiffCompression expectedCompression)
where TPixel : unmanaged, IPixel <TPixel>
{
// arrange
var encoder = new TiffEncoder()
{
Compression = compression, BitsPerPixel = TiffBitsPerPixel.Bit1
};
using Image <TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
// act
input.Save(memStream, encoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
TiffFrameMetadata frameMetaData = output.Frames.RootFrame.Metadata.GetTiffMetadata();
Assert.Equal(TiffBitsPerPixel.Bit1, frameMetaData.BitsPerPixel);
Assert.Equal(expectedCompression, frameMetaData.Compression);
}
//returns an encoder based on image type
public static ImageEncoder GetEncoderFromType(ImageType type)
{
ImageEncoder encoder = null;
switch (type)
{
case ImageType.Jpeg:
encoder = new JpegEncoder();
break;
case ImageType.Png:
encoder = new PngEncoder();
break;
case ImageType.J2k:
encoder = new Jp2Encoder();
break;
case ImageType.Bmp:
encoder = new BmpEncoder();
break;
case ImageType.Emf:
encoder = new EmfEncoder();
break;
case ImageType.Gif:
encoder = new GifEncoder();
break;
case ImageType.Pcx:
encoder = new PcxEncoder();
break;
case ImageType.Psd:
encoder = new PsdEncoder();
break;
case ImageType.Tga:
encoder = new TgaEncoder();
break;
case ImageType.Tiff:
encoder = new TiffEncoder();
break;
case ImageType.Wbmp:
encoder = new WbmpEncoder();
break;
case ImageType.Wmf:
encoder = new WmfEncoder();
break;
case ImageType.Tla:
encoder = new TlaEncoder();
break;
default:
MessageBox.Show("当前的图像格式不支持");
break;
}
return(encoder);
}
/// <summary>
/// Saves the image to the given stream with the Tiff format.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="stream">The stream to save the image to.</param>
/// <param name="encoder">The encoder to save the image with.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static void SaveAsTiff(this Image source, Stream stream, TiffEncoder encoder)
=> source.Save(
stream,
encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TiffFormat.Instance));
public void Encode_PreservesMetadata <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
// Load Tiff image
using Image <TPixel> image = provider.GetImage(new TiffDecoder()
{
IgnoreMetadata = false
});
ImageMetadata inputMetaData = image.Metadata;
ImageFrame <TPixel> rootFrameInput = image.Frames.RootFrame;
TiffFrameMetadata frameMetaInput = rootFrameInput.Metadata.GetTiffMetadata();
byte[] xmpProfileInput = rootFrameInput.Metadata.XmpProfile;
ExifProfile exifProfileInput = rootFrameInput.Metadata.ExifProfile;
Assert.Equal(TiffCompression.Lzw, frameMetaInput.Compression);
Assert.Equal(TiffBitsPerPixel.Bit4, frameMetaInput.BitsPerPixel);
// Save to Tiff
var tiffEncoder = new TiffEncoder()
{
PhotometricInterpretation = TiffPhotometricInterpretation.Rgb
};
using var ms = new MemoryStream();
image.Save(ms, tiffEncoder);
// Assert
ms.Position = 0;
using var encodedImage = Image.Load <Rgba32>(ms);
ImageMetadata encodedImageMetaData = encodedImage.Metadata;
ImageFrame <Rgba32> rootFrameEncodedImage = encodedImage.Frames.RootFrame;
TiffFrameMetadata tiffMetaDataEncodedRootFrame = rootFrameEncodedImage.Metadata.GetTiffMetadata();
ExifProfile encodedImageExifProfile = rootFrameEncodedImage.Metadata.ExifProfile;
byte[] encodedImageXmpProfile = rootFrameEncodedImage.Metadata.XmpProfile;
Assert.Equal(TiffBitsPerPixel.Bit4, tiffMetaDataEncodedRootFrame.BitsPerPixel);
Assert.Equal(TiffCompression.Lzw, tiffMetaDataEncodedRootFrame.Compression);
Assert.Equal(inputMetaData.HorizontalResolution, encodedImageMetaData.HorizontalResolution);
Assert.Equal(inputMetaData.VerticalResolution, encodedImageMetaData.VerticalResolution);
Assert.Equal(inputMetaData.ResolutionUnits, encodedImageMetaData.ResolutionUnits);
Assert.Equal(rootFrameInput.Width, rootFrameEncodedImage.Width);
Assert.Equal(rootFrameInput.Height, rootFrameEncodedImage.Height);
PixelResolutionUnit resolutionUnitInput = UnitConverter.ExifProfileToResolutionUnit(exifProfileInput);
PixelResolutionUnit resolutionUnitEncoded = UnitConverter.ExifProfileToResolutionUnit(encodedImageExifProfile);
Assert.Equal(resolutionUnitInput, resolutionUnitEncoded);
Assert.Equal(exifProfileInput.GetValue(ExifTag.XResolution).Value.ToDouble(), encodedImageExifProfile.GetValue(ExifTag.XResolution).Value.ToDouble());
Assert.Equal(exifProfileInput.GetValue(ExifTag.YResolution).Value.ToDouble(), encodedImageExifProfile.GetValue(ExifTag.YResolution).Value.ToDouble());
Assert.Equal(xmpProfileInput, encodedImageXmpProfile);
Assert.Equal("IrfanView", exifProfileInput.GetValue(ExifTag.Software).Value);
Assert.Equal("This is Название", exifProfileInput.GetValue(ExifTag.ImageDescription).Value);
Assert.Equal("This is Изготовитель камеры", exifProfileInput.GetValue(ExifTag.Make).Value);
Assert.Equal("This is Авторские права", exifProfileInput.GetValue(ExifTag.Copyright).Value);
Assert.Equal(exifProfileInput.GetValue(ExifTag.ImageDescription).Value, encodedImageExifProfile.GetValue(ExifTag.ImageDescription).Value);
Assert.Equal(exifProfileInput.GetValue(ExifTag.Make).Value, encodedImageExifProfile.GetValue(ExifTag.Make).Value);
Assert.Equal(exifProfileInput.GetValue(ExifTag.Copyright).Value, encodedImageExifProfile.GetValue(ExifTag.Copyright).Value);
// Note that the encoded profile has PlanarConfiguration explicitly set, which is missing in the original image profile.
Assert.Equal((ushort)TiffPlanarConfiguration.Chunky, encodedImageExifProfile.GetValue(ExifTag.PlanarConfiguration)?.Value);
Assert.Equal(exifProfileInput.Values.Count + 1, encodedImageExifProfile.Values.Count);
}
/// <summary>
/// Saves the image to the given stream with the Tiff format.
/// </summary>
/// <param name="source">The image this method extends.</param>
/// <param name="stream">The stream to save the image to.</param>
/// <param name="encoder">The encoder to save the image with.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <exception cref="System.ArgumentNullException">Thrown if the stream is null.</exception>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public static Task SaveAsTiffAsync(this Image source, Stream stream, TiffEncoder encoder, CancellationToken cancellationToken = default) =>
source.SaveAsync(
stream,
encoder ?? source.GetConfiguration().ImageFormatsManager.FindEncoder(TiffFormat.Instance),
cancellationToken);
protected static void TestStripLength <TPixel>(
TestImageProvider <TPixel> provider,
TiffPhotometricInterpretation photometricInterpretation,
TiffCompression compression,
bool useExactComparer = true,
float compareTolerance = 0.01f)
where TPixel : unmanaged, IPixel <TPixel>
{
// arrange
var tiffEncoder = new TiffEncoder()
{
PhotometricInterpretation = photometricInterpretation, Compression = compression
};
using Image <TPixel> input = provider.GetImage();
using var memStream = new MemoryStream();
TiffFrameMetadata inputMeta = input.Frames.RootFrame.Metadata.GetTiffMetadata();
TiffCompression inputCompression = inputMeta.Compression ?? TiffCompression.None;
// act
input.Save(memStream, tiffEncoder);
// assert
memStream.Position = 0;
using var output = Image.Load <Rgba32>(memStream);
ExifProfile exifProfileOutput = output.Frames.RootFrame.Metadata.ExifProfile;
TiffFrameMetadata outputMeta = output.Frames.RootFrame.Metadata.GetTiffMetadata();
ImageFrame <Rgba32> rootFrame = output.Frames.RootFrame;
Number rowsPerStrip = exifProfileOutput.GetValue(ExifTag.RowsPerStrip) != null?exifProfileOutput.GetValue(ExifTag.RowsPerStrip).Value : TiffConstants.RowsPerStripInfinity;
Assert.True(output.Height > (int)rowsPerStrip);
Assert.True(exifProfileOutput.GetValue(ExifTag.StripOffsets)?.Value.Length > 1);
Number[] stripByteCounts = exifProfileOutput.GetValue(ExifTag.StripByteCounts)?.Value;
Assert.NotNull(stripByteCounts);
Assert.True(stripByteCounts.Length > 1);
Assert.NotNull(outputMeta.BitsPerPixel);
foreach (Number sz in stripByteCounts)
{
Assert.True((uint)sz <= TiffConstants.DefaultStripSize);
}
// For uncompressed more accurate test.
if (compression == TiffCompression.None)
{
for (int i = 0; i < stripByteCounts.Length - 1; i++)
{
// The difference must be less than one row.
int stripBytes = (int)stripByteCounts[i];
int widthBytes = ((int)outputMeta.BitsPerPixel + 7) / 8 * rootFrame.Width;
Assert.True((TiffConstants.DefaultStripSize - stripBytes) < widthBytes);
}
}
// Compare with reference.
TestTiffEncoderCore(
provider,
inputMeta.BitsPerPixel,
photometricInterpretation,
inputCompression,
useExactComparer: useExactComparer,
compareTolerance: compareTolerance);
}
//returns an encoder based on image type
public static ImageEncoder GetEncoderFromType( ImageType type )
{
ImageEncoder encoder = null;
switch ( type )
{
case ImageType.Jpeg:
encoder = new JpegEncoder();
break;
case ImageType.Png:
encoder = new PngEncoder();
break;
case ImageType.J2k:
encoder = new Jp2Encoder();
break;
case ImageType.Bmp:
encoder = new BmpEncoder();
break;
case ImageType.Emf:
encoder = new EmfEncoder();
break;
case ImageType.Gif:
encoder = new GifEncoder();
break;
case ImageType.Pcx:
encoder = new PcxEncoder();
break;
case ImageType.Psd:
encoder = new PsdEncoder();
break;
case ImageType.Tga:
encoder = new TgaEncoder();
break;
case ImageType.Tiff:
encoder = new TiffEncoder();
break;
case ImageType.Wbmp:
encoder = new WbmpEncoder();
break;
case ImageType.Wmf:
encoder = new WmfEncoder();
break;
case ImageType.Tla:
encoder = new TlaEncoder();
break;
default:
MessageBox.Show( "当前的图像格式不支持" );
break;
}
return encoder;
}
/// <summary>
/// Shows the encoder settings dialog and initializes the encoder.
/// </summary>
/// <param name="encoder">The encoder.</param>
/// <param name="canAddImagesToExistingFile">The value indicating whether encoder can add images to the existing multipage image file.</param>
/// <returns>
/// <b>True</b> if settings are applied to the encoder; otherwise, <b>false</b>.
/// </returns>
protected virtual bool ShowEncoderSettingsDialog(
ref EncoderBase encoder,
bool canAddImagesToExistingFile)
{
// set encoder settings
switch (encoder.Name)
{
case "Bmp":
using (BmpEncoderSettingsForm bmpEncoderSettingsForm = new BmpEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(bmpEncoderSettingsForm);
if (bmpEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
BmpEncoder bmpEncoder = (BmpEncoder)encoder;
bmpEncoder.Settings = bmpEncoderSettingsForm.EncoderSettings;
return(true);
}
case "Png":
using (PngEncoderSettingsForm pngEncoderSettingsForm = new PngEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(pngEncoderSettingsForm);
if (pngEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
PngEncoder pngEncoder = (PngEncoder)encoder;
pngEncoder.Settings = pngEncoderSettingsForm.EncoderSettings;
return(true);
}
case "Gif":
using (GifEncoderSettingsForm gifEncoderSettingsForm = new GifEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(gifEncoderSettingsForm);
gifEncoderSettingsForm.CanAddImagesToExistingFile = canAddImagesToExistingFile;
if (gifEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
GifEncoder gifEncoder = (GifEncoder)encoder;
gifEncoder.Settings = gifEncoderSettingsForm.EncoderSettings;
gifEncoder.CreateNewFile = !gifEncoderSettingsForm.AddImagesToExistingFile;
return(true);
}
case "Jpeg":
using (JpegEncoderSettingsForm jpegEncoderSettingsForm = new JpegEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(jpegEncoderSettingsForm);
if (jpegEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
JpegEncoder jpegEncoder = (JpegEncoder)encoder;
jpegEncoder.Settings = jpegEncoderSettingsForm.EncoderSettings;
return(true);
}
case "Tiff":
using (TiffEncoderSettingsForm tiffEncoderSettingsForm = new TiffEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(tiffEncoderSettingsForm);
tiffEncoderSettingsForm.CanAddImagesToExistingFile = canAddImagesToExistingFile;
if (tiffEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
TiffEncoder tiffEncoder = (TiffEncoder)encoder;
tiffEncoder.Settings = tiffEncoderSettingsForm.EncoderSettings;
tiffEncoder.CreateNewFile = !tiffEncoderSettingsForm.AddImagesToExistingFile;
return(true);
}
case "Svg":
using (SvgEncoderSettingsForm svgEncoderSettingsForm = new SvgEncoderSettingsForm())
{
SetEncoderSettingsDialogProperties(svgEncoderSettingsForm);
if (svgEncoderSettingsForm.ShowDialog() != DialogResult.OK)
{
return(false);
}
SvgEncoder svgEncoder = (SvgEncoder)encoder;
svgEncoder.Settings = svgEncoderSettingsForm.EncoderSettings;
return(true);
}
}
return(false);
}
