public void Decompress(TiffDecompressionContext context, ReadOnlyMemory <byte> input, Memory <byte> output) { // Copy frame header JpegFrameHeader frameHeader = _frameHeader; frameHeader = new JpegFrameHeader(frameHeader.SamplePrecision, (ushort)context.ImageSize.Height, (ushort)context.ImageSize.Width, frameHeader.NumberOfComponents, frameHeader.Components); var decoder = new JpegDecoder(); decoder.StartOfFrame = JpegMarker.StartOfFrame0; decoder.MemoryPool = context.MemoryPool; decoder.SetFrameHeader(frameHeader); decoder.SetRestartInterval(_restartInterval); foreach (ComponentInfo componentInfo in _components) { decoder.SetQuantizationTable(componentInfo.QuantizationTable); decoder.SetHuffmanTable(componentInfo.DcTable); decoder.SetHuffmanTable(componentInfo.AcTable); } var outputWriter = new JpegBuffer8BitOutputWriter(context.ImageSize.Width, context.SkippedScanlines, context.SkippedScanlines + context.RequestedScanlines, decoder.NumberOfComponents, output); decoder.SetOutputWriter(outputWriter); var reader = new JpegReader(input); decoder.ProcessScan(ref reader, _scanHeader); }
/// <summary> /// Reads and writes complex EXIF tags /// </summary> private static void ProcessComplexExifTypes() { using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var jpegWriter = new JpegWriter("../../../../_Output/ProcessComplexExifTypes.jpg", 70)) { var exif = new Aurigma.GraphicsMill.Codecs.ExifDictionary(jpegReader.Exif); Object[] latitude = null; if (exif.Contains(ExifDictionary.GpsLatitude)) { latitude = exif.GetItemArray(ExifDictionary.GpsLatitude); latitude[0] = new UnsignedRational(113, 12); } else { // Alexandria, Virginia latitude = new Object[] { new UnsignedRational(38, 1), new UnsignedRational(48, 1), new UnsignedRational(17, 1) }; } exif.SetItemArray(ExifDictionary.GpsLatitude, latitude); var gpsVer = new Object[] { (byte)2, (byte)0, (byte)0, (byte)1 }; exif.SetItemArray(ExifDictionary.GpsVersionId, gpsVer); exif[Aurigma.GraphicsMill.Codecs.ExifDictionary.Software] = "Aurigma Graphics Mill"; jpegWriter.Exif = exif; Aurigma.GraphicsMill.Pipeline.Run(jpegReader + jpegWriter); } }
private static JpegDirectory ProcessBytes([NotNull] string filePath) { var directory = new JpegReader().Extract(File.ReadAllBytes(filePath), JpegSegmentType.Sof0); Assert.NotNull(directory); return(directory); }
/// <summary> /// Extracts and caches the metadata for an image. /// </summary> /// <param name="pictureFileInfo">The FileInfo to the image.</param> /// <returns>The MetaData for the image.</returns> internal static Metadata GetImageData(FileInfo pictureFileInfo) { try { string cacheKey = "data(" + pictureFileInfo.FullName + ")"; Cache cache = HttpContext.Current.Cache; object cached = cache[cacheKey]; if (cached == null) { Metadata data = new Metadata(); ExifReader exif = new ExifReader(pictureFileInfo); exif.Extract(data); IptcReader iptc = new IptcReader(pictureFileInfo); iptc.Extract(data); JpegReader jpeg = new JpegReader(pictureFileInfo); jpeg.Extract(data); cache.Insert(cacheKey, data, new CacheDependency(pictureFileInfo.FullName)); return(data); } return((Metadata)cached); } catch { return(new Metadata()); } }
public override void ProcessScan(ref JpegReader reader, JpegScanHeader scanHeader) { if (scanHeader.Components is null) { throw new InvalidOperationException(); } if (Decoder.GetOutputWriter() is null) { throw new InvalidOperationException(); } // Resolve each component Span <JpegHuffmanDecodingComponent> components = _components.AsSpan(0, InitDecodeComponents(_frameHeader, scanHeader, _components)); foreach (JpegHuffmanDecodingComponent component in components) { if (component.QuantizationTable.IsEmpty) { ThrowInvalidDataException($"Quantization table of component {component.ComponentIndex} is not defined."); } } _restartInterval = Decoder.GetRestartInterval(); _mcusBeforeRestart = _restartInterval; _eobrun = 0; if (components.Length == 1) { DecodeProgressiveDataNonInterleaved(ref reader, scanHeader, components[0]); } else { DecodeProgressiveDataInterleaved(ref reader, scanHeader, components); } }
public override void ProcessScan(ref JpegReader reader, JpegScanHeader scanHeader) { if (scanHeader.Components is null) { throw new InvalidOperationException(); } if (Decoder.GetOutputWriter() is null) { throw new InvalidOperationException(); } // Resolve each component Span <JpegHuffmanDecodingComponent> components = _components.AsSpan(0, InitDecodeComponents(_frameHeader, scanHeader, _components)); _restartInterval = Decoder.GetRestartInterval(); _mcusBeforeRestart = _restartInterval; _eobrun = 0; if (components.Length == 1) { DecodeProgressiveDataNonInterleaved(ref reader, scanHeader, components[0]); } else { DecodeProgressiveDataInterleaved(ref reader, scanHeader, components); } }
/// <summary> /// Reads EXIF and IPTC metadata /// </summary> private static void ReadExifIptc() { using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg")) { // Read metadata var exif = jpegReader.Exif; var iptc = jpegReader.Iptc; // Show EXIF tags if (exif != null) { Console.WriteLine("EXIF"); Console.WriteLine("---------------"); foreach (object key in exif.Keys) { Console.WriteLine("{0}: {1}, {2}", exif.GetKeyDescription(key), exif[key], exif.GetItemString(key)); } } // Show IPTC tags if (iptc != null) { Console.WriteLine("IPTC"); Console.WriteLine("---------------"); foreach (long key in iptc.Keys) { Console.WriteLine("{0}: {1}, {2}", iptc.GetKeyDescription(key), iptc[key], iptc.GetItemString(key)); } } } }
/// <summary> /// Reads image in JPEG format and saves to WebP format using memory-friendly Pipeline API /// </summary> private static void WriteWebPMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var writer = new WebPWriter("../../../../_Output/WriteWebPMemoryFriendly.webp")) { Pipeline.Run(reader + writer); } }
/// <summary> /// Saved bitmap to EPS format using memory-friendly Pipeline API /// </summary> private static void WriteBitmapToEpsMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var writer = new EpsWriter("../../../../_Output/WriteEpsMemoryFriendly.eps")) { Pipeline.Run(reader + writer); } }
/// <summary> /// Reads image in JPEG format and saves to PNG format using memory-friendly Pipeline API /// </summary> private static void WritePngMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var flip = new Flip(FlipType.Vertical)) using (var writer = new PngWriter("../../../../_Output/WritePngMemoryFriendly.png")) { Pipeline.Run(reader + flip + writer); } }
/// <summary> /// Loads and saves image to file with specified encoder options using memory-friendly Pipeline API /// </summary> private static void LoadSaveFileWithOptionsMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) // Set value of JPEG quality to 85 using (var writer = new JpegWriter("../../../../_Output/LoadSaveFileWithOptionsMemoryFriendly.jpg", 85)) { Pipeline.Run(reader + writer); } }
/// <summary> /// Gets thumbnail of image from its EXIF metadata /// </summary> private static void GetExifThumbnail(string inputPath, string outputPath) { using (var jpegReader = new JpegReader(inputPath)) using (var thumbnail = (Bitmap)jpegReader.Exif[ExifDictionary.Thumbnail]) using (var jpegWriter = new JpegWriter(outputPath)) { Pipeline.Run(thumbnail + jpegWriter); } }
private static void ResizeAndPreserveMetadata() { using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var resizer = new Resize(jpegReader.Width / 2, 0)) using (var jpegWriter = new JpegWriter("../../../../_Output/ResizeAndPreserveMetadata.jpg")) { // Read EXIF var exif = jpegReader.Exif; // Check if loaded image contains EXIF metadata if (exif == null) { exif = new ExifDictionary(); } exif[ExifDictionary.Software] = "Aurigma Graphics Mill"; // Read IPTC var iptc = jpegReader.Iptc; // Check if loaded image contains IPTC metadata if (iptc == null) { iptc = new IptcDictionary(); } iptc[IptcDictionary.Keyword] = "mountain"; // Read Adobe resource blocks var adobeResources = jpegReader.AdobeResources; // Check if loaded image contains Adobe image resource blocks if (adobeResources == null) { adobeResources = new AdobeResourceDictionary(); } // Create new adobe image resource block containing copyright metadata var arBlock = new AdobeResourceBlock("Copyright", new byte[] { 1 }); // Set this block to the item with 0x040A ID (copyright flag) adobeResources[0x040A] = arBlock; // Read XMP var xmp = new XmpData(); //Check if loaded image contains XMP metadata if (jpegReader.Xmp != null) { xmp.Load(jpegReader.Xmp); } // Create a node containing dc:contributor metadata var node = new XmpValueNode(XmpNodeType.SimpleProperty, "John Doe", XmpTagNames.DCContributor); xmp.AddNode(node); // Write metadata jpegWriter.Exif = exif; jpegWriter.Iptc = iptc; jpegWriter.AdobeResources = adobeResources; jpegWriter.Xmp = xmp.Save(); Pipeline.Run(jpegReader + resizer + jpegWriter); } }
/// <summary> /// Resizes while reading of JPEG image using memory-friendly Pipeline API /// </summary> private static void ResizeWhileReadingJpegMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var writer = new JpegWriter("../../../../_Output/ResizeWhileReadingJpegMemoryFriendly.jpg")) { reader.Scale = JpegScale.x2; Pipeline.Run(reader + writer); } }
/// <summary> /// Loads and saves image to stream using memory-friendly Pipeline API /// </summary> private static void LoadSaveStreamMemoryFriendly() { using (var readStream = System.IO.File.OpenRead("../../../../_Input/Chicago.jpg")) using (var jpegReader = new JpegReader(readStream)) using (var writerStream = System.IO.File.OpenWrite("../../../../_Output/LoadSaveStreamMemoryFriendly.jpg")) using (var jpegWriter = new JpegWriter(writerStream, 85)) { Pipeline.Run(jpegReader + jpegWriter); } }
/// <summary> /// Resizes image and clipping path using memory-friendly Pipeline API /// </summary> private static void ResizeImageAndClippingPathMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var writer = new JpegWriter("../../../../_Output/ResizeImageAndClippingPathMemoryFriendly.jpg")) using (var resize = new Resize(reader.Width / 2, reader.Height / 2)) { writer.AdobeResources = reader.AdobeResources; Pipeline.Run(reader + resize + writer); } }
/// <summary> /// Crops image and preserves clipping path /// </summary> private static void CropImageAndPreserveClippingPath() { using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var writer = new JpegWriter("../../../../_Output/CropImageAndPreserveClippingPath.jpg")) using (var crop = new Crop(reader.Width / 6, 0, reader.Width / 2, reader.Height / 2)) { writer.AdobeResources = reader.AdobeResources; Pipeline.Run(reader + crop + writer); } }
/// <summary> /// Copies all Adobe resources including clipping path /// </summary> private static void CopyClippingPath() { using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var bitmap = reader.Frames[0].GetBitmap()) { var jpegSettings = new JpegSettings(); jpegSettings.AdobeResources = reader.AdobeResources; bitmap.Save("../../../../_Output/CopyClippingPath.jpg", jpegSettings); } }
/// <summary> /// Resizes while reading of JPEG image /// </summary> private static void ResizeWhileReadingJpeg() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) { reader.Scale = JpegScale.x2; using (var bitmap = reader.Frames[0].GetBitmap()) { bitmap.Save("../../../../_Output/ResizeWhileReadingJpeg.jpg"); } } }
/// <summary> /// Reads image in JPEG format and saves to TIFF format using memory-friendly Pipeline API /// </summary> private static void WriteTiffMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var flip = new Flip(FlipType.Vertical)) using (var writer = new TiffWriter("../../../../_Output/WriteTiffMemoryFriendly.tif")) { writer.Compression = CompressionType.Jpeg; writer.Quality = 85; Pipeline.Run(reader + flip + writer); } }
/// <summary> /// Visualizes clipping path for demonstration purposes /// </summary> private static void VisualizeClippingPath(string inputPath, string outputPath) { using (var reader = new JpegReader(inputPath)) using (var bitmap = reader.Frames[0].GetBitmap()) using (var graphics = bitmap.GetAdvancedGraphics()) { var graphicsPath = reader.ClippingPaths[0].CreateGraphicsPath(reader.Width, reader.Height); graphics.DrawPath(new Pen(new RgbColor(0, 0, 255, 127), 4f), Path.Create(graphicsPath)); bitmap.Save(outputPath); } }
/// <summary> /// Reads and writes image in JPEG format using memory-friendly Pipeline API /// </summary> private static void ReadAndWriteJpegMemoryFriendly() { using (var reader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var flip = new Flip(FlipType.Vertical)) using (var writer = new JpegWriter("../../../../_Output/ReadWriteJpegMemoryFriendly.jpg")) { writer.Quality = 90; writer.UseSubsampling = false; writer.IsProgressive = true; Pipeline.Run(reader + flip + writer); } }
/// <summary> /// Resizes image and clipping path /// </summary> private static void ResizeImageAndClippingPath() { using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var bitmap = reader.Frames[0].GetBitmap()) { var jpegSettings = new Aurigma.GraphicsMill.Codecs.JpegSettings(); jpegSettings.AdobeResources = reader.AdobeResources; bitmap.Transforms.Resize(reader.Width / 2, reader.Height / 2); bitmap.Save("../../../../_Output/ResizeImageAndClippingPath.jpg", jpegSettings); } }
/// <summary> /// Writes multiframe image in TIFF format using memory-friendly Pipeline API /// </summary> private static void WriteMultiframeTiffMemoryFriendly() { using (var writer = new TiffWriter("../../../../_Output/WriteMultiframeTiffMemoryFriendly.tif")) { using (var reader1 = new JpegReader("../../../../_Input/Chicago.jpg")) { Pipeline.Run(reader1 + writer); } using (var reader2 = new JpegReader("../../../../_Input/Copenhagen_RGB.jpg")) { Pipeline.Run(reader2 + writer); } } }
/// <summary> /// Converts clipping path to alpha channel mask /// </summary> private static void ConvertClippingPathToMask() { using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var bitmap = reader.Frames[0].GetBitmap()) using (var maskBitmap = new Bitmap(bitmap.Width, bitmap.Height, PixelFormat.Format8bppGrayscale, new GrayscaleColor(0))) using (var graphics = maskBitmap.GetAdvancedGraphics()) { var graphicsPath = reader.ClippingPaths[0].CreateGraphicsPath(reader.Width, reader.Height); graphics.FillPath(new SolidBrush(new GrayscaleColor(255)), Path.Create(graphicsPath)); bitmap.Channels.SetAlpha(maskBitmap); bitmap.Save("../../../../_Output/ConvertClippingPathToMask.png"); } }
public void JpegReaderObject_Success() { DecodedImage decodedImage; IImageReader reader = null; string image = "anil.jpeg"; string format = image.Substring(image.IndexOf('.') + 1); if (format.Equals("jpeg")) { reader = new JpegReader(image); } Assert.NotNull(reader); Assert.IsType <JpegReader>(reader); }
/// <summary> /// Writes EXIF and IPTC metadata using memory-friendly Pipeline API /// </summary> private static void WriteExifIptcMemoryFriendly() { using (var jpegReader = new JpegReader("../../../../_Input/Chicago.jpg")) using (var jpegWriter = new JpegWriter("../../../../_Output/WriteExifIptcMemoryFriendly.jpg", 70)) { var exif = new Aurigma.GraphicsMill.Codecs.ExifDictionary(); exif[Aurigma.GraphicsMill.Codecs.ExifDictionary.Software] = "Aurigma Graphics Mill"; jpegWriter.Exif = exif; var iptc = new Aurigma.GraphicsMill.Codecs.IptcDictionary(); iptc[Aurigma.GraphicsMill.Codecs.IptcDictionary.Keyword] = "mountain"; iptc[Aurigma.GraphicsMill.Codecs.IptcDictionary.City] = "Olympia"; jpegWriter.Iptc = iptc; Aurigma.GraphicsMill.Pipeline.Run(jpegReader + jpegWriter); } }
private void DecodeProgressiveDataInterleaved(ref JpegReader reader, JpegScanHeader scanHeader, Span <JpegArithmeticDecodingComponent> components) { foreach (JpegArithmeticDecodingComponent component in components) { if (component.DcTable is null || component.DcStatistics is null) { ThrowInvalidDataException(); } } JpegBlockAllocator allocator = _allocator; JpegBitReader bitReader = new JpegBitReader(reader.RemainingBytes); int mcusPerColumn = _mcusPerColumn; int mcusPerLine = _mcusPerLine; for (int rowMcu = 0; rowMcu < mcusPerColumn; rowMcu++) { for (int colMcu = 0; colMcu < mcusPerLine; colMcu++) { foreach (JpegArithmeticDecodingComponent component in components) { int index = component.ComponentIndex; int h = component.HorizontalSamplingFactor; int v = component.VerticalSamplingFactor; int offsetX = colMcu * h; int offsetY = rowMcu * v; for (int y = 0; y < v; y++) { int blockOffsetY = offsetY + y; for (int x = 0; x < h; x++) { ref JpegBlock8x8 blockRef = ref allocator.GetBlockReference(index, offsetX + x, blockOffsetY); ReadBlockProgressiveDC(ref bitReader, component, scanHeader, ref blockRef); } } } if (!HandleRestart(ref bitReader, ref reader, ref scanHeader, ref MemoryMarshal.GetReference(components), components.Length)) { return; } } }
/// <summary> /// Reads all XMP properties /// </summary> private static void ReadXmpMetadata() { using (var reader = new JpegReader(@"../../../../_Input/Chicago.jpg")) { if (reader.Xmp != null) { var xmp = new XmpData(reader.Xmp); foreach (XmpNode node in xmp.Values) { if (node.NodeType == XmpNodeType.SimpleProperty) { Console.WriteLine("{0}: {1}", node.Name, node); } } } } }
/// <summary> /// Modifies clipping path explicitly using memory-friendly Pipeline API /// </summary> private static void ModifyClippingPathExplicitlyMemoryFriendly() { int width = 1000; int height = 1000; using (var reader = new JpegReader("../../../../_Input/Apple.jpg")) using (var generator = new ImageGenerator(width, height, reader.PixelFormat, RgbColor.White)) using (var combiner = new Combiner(CombineMode.Copy)) using (var writer = new JpegWriter("../../../../_Output/ModifyClippingPathExplicitlyMemoryFriendly.jpg")) { combiner.TopImage = reader; combiner.X = (width - reader.Width) / 2; combiner.Y = (height - reader.Height) / 2; // The clipping path has relatives coordinates (0.0f ... 1.f0). So we need to transform it. var transform = new System.Drawing.Drawing2D.Matrix(); transform.Scale((float)reader.Width / (float)width, (float)reader.Height / (float)height); transform.Translate((float)combiner.X / (float)reader.Width, (float)combiner.Y / (float)reader.Height); var adobeResources = reader.AdobeResources; // Remove clipping paths foreach (long key in adobeResources.Keys) { if (key >= FirstPathId && key <= LastPathId) { adobeResources.Remove(key); } } // Transform and save clipping paths for (var i = 0; i < reader.ClippingPaths.Count; i++) { var clippingPath = reader.ClippingPaths[i]; clippingPath.ApplyTransform(transform); adobeResources.Add(FirstPathId + i, new AdobeResourceBlock(clippingPath.Name, clippingPath.Data)); } writer.AdobeResources = adobeResources; Pipeline.Run(generator + combiner + writer); } }