public void TestJira2990_ExtractIccProfiles_ApplyIcc()

{

	string dir = @"c:\aspose.work\IMAGINGNET\2990\";

	string sourcePath = dir + "gray-d15.psd";            

	string outputPath = dir + "gray-d15.psd.apply-icc.tif";

	// Save to grayscale TIFF

	TiffOptions saveOptions = new TiffOptions(TiffExpectedFormat.Default);

	saveOptions.Photometric = TiffPhotometrics.MinIsBlack;

	saveOptions.BitsPerSample = new ushort[] { 8 };

	// If the image contains a built-in Gray ICC profile, it is not be applied by default in contrast of the CMYK profile.

	// Enable ICC conversion explicitly.

	LoadOptions loadOptions = new LoadOptions();

	loadOptions.UseIccProfileConversion = true;

	using (PsdImage psdImage = (PsdImage)Image.Load(sourcePath, loadOptions))

	{

		// Embed the gray ICC profile to the output TIFF.

		// The built-in Gray Profile can be read via the PsdImage.GrayColorProfile property.

		saveOptions.IccProfile = ToMemoryStream(psdImage.GrayColorProfile);

		psdImage.Save(outputPath, saveOptions);

	}

}

private static MemoryStream ToMemoryStream(StreamSource streamSource)

{

	Stream srcStream = streamSource.Stream;

	MemoryStream dstStream = new MemoryStream();

	int byteCount;

	byte[] buffer = new byte[1024];

	long pos = srcStream.Position;

	srcStream.Seek(0, SeekOrigin.Begin);

	while ((byteCount = srcStream.Read(buffer, 0, buffer.Length)) > 0)

	{

		dstStream.Write(buffer, 0, byteCount);

	}

	srcStream.Seek(pos, SeekOrigin.Begin);

	return dstStream;

}

 public void TestJira2990_ExtractIccProfiles_IgnoreIcc()

{

	string dir = @"c:\aspose.work\IMAGINGNET\2990\";

	string sourcePath = dir + "gray-d15.psd";

	string outputPath = dir + "gray-d15.psd.ignore-icc.tif";

	// Save to grayscale TIFF

	TiffOptions saveOptions = new TiffOptions(TiffExpectedFormat.Default);

	saveOptions.Photometric = TiffPhotometrics.MinIsBlack;

	saveOptions.BitsPerSample = new ushort[] { 8 };

	// Disable the ICC color conversion explicitly to get the original colors without applying a built-in ICC profile.

	LoadOptions loadOptions = new LoadOptions();

	loadOptions.UseIccProfileConversion = false;

	// Or just omit loadOptions because the built-in Gray ICC profile is not applied by default in contrast of the CMYK profile. 

	using (PsdImage psdImage = (PsdImage)Image.Load(sourcePath))

	{

		// Embed the gray ICC profile to the output TIFF.

		// The built-in Gray Profile can be read via the PsdImage.GrayColorProfile property.

		saveOptions.IccProfile = ToMemoryStream(psdImage.GrayColorProfile);

		psdImage.Save(outputPath, saveOptions);

	}

}

 string sourceFile = "layerLock.psd";

string outputFile = "result.psd";

using (PsdImage image = (PsdImage)Image.Load(sourceFile))

                {

                    Layer[] layers = image.Layers;

                    layers[4].LayerLock = LayerLockType.LockAll;

                    layers[2].LayerLock = LayerLockType.None;

                    layers[3].LayerLock = LayerLockType.LockTransparentPixels;

                    layers[1].LayerLock = LayerLockType.LockImagePixels;

                    layers[5].LayerLock = LayerLockType.LockPosition;

                    layers[5].Flags = LayerFlags.TransparencyProtected;

                    image.Save(outputFile);

                }

 public void TestSaveEmf()

{

    var path = @"TestEmfBezier.emf";

    using (var image = (MetaImage)Image.Load(path))

    {

        image.Save(path + ".emf", new EmfOptions());

    }

}

public void TestSaveEmfPlus()

{

    var path = @"TestEmfPlusFigures.emf";

    using (var image = (MetaImage)Image.Load(path))

    {

        image.Save(path + ".emf", new EmfOptions());

    }

}

public void TestSaveEmfGraphics()

{

    EmfRecorderGraphics2D graphics = new EmfRecorderGraphics2D(

        new Rectangle(0, 0, 5000, 5000),

        new Size(5000, 5000),

        new Size(1000, 1000));

    {

        Font font = new Font("Arial", 10, FontStyle.Bold | FontStyle.Underline);

        graphics.DrawString(font.Name + " " + font.Size + " " + font.Style.ToString(), font, Color.Brown, 10, 10);

        graphics.DrawString("some text", font, Color.Brown, 10, 30);

        font = new Font("Arial", 24, FontStyle.Italic | FontStyle.Strikeout);

        graphics.DrawString(font.Name + " " + font.Size + " " + font.Style.ToString(), font, Color.Brown, 20, 50);

        graphics.DrawString("some text", font, Color.Brown, 20, 80);

        using (EmfImage image = graphics.EndRecording())

        {

            var path = @"Fonts.emf";

            image.Save(path, new EmfOptions());

        }

    }

}

 using (Image image = Image.Load("mysvg.svg"))

{

    using (FileStream fs = new FileStream("yoursvg.svg", FileMode.Create, FileAccess.ReadWrite))

    {

        image.Save(fs);

    }

}

 string path = "source.gif";

string outputPath = "result.png";

using (GifImage image = (GifImage)Image.Load(path))

                {

                    image.Save(outputPath, new PngOptions());

                }

 private readonly string[] inputFiles = new string[]

{

    "tiger.bmp",

    "ImagePaletteColor.dicom",

    "2086.gif",

    "10.jpg",

    "multi.jpx",

    "1.png",

    "3layers_maximized_comp.psd",

    "33266.tif",

    "Animation1.webp"

};

private readonly StringBuilder stackTrace = new StringBuilder();

private bool isError = false;

// this method should throw no exceptions

public void TestSaveJpeg2000Multithreaded()

{

    Thread[] threads = new Thread[inputFiles.Length];

    for (int x = 0; x < inputFiles.Length; x++)

    {

        string inputFile = inputFiles[x];

        threads[x] = new Thread(new ThreadStart(delegate { SaveAsJpeg2000(inputFile); }));

        threads[x].Start();

    }

    foreach (Thread thread in threads)

    {

        thread.Join();

    }

    if (this.isError)

    {

        throw new Exception(stackTrace.ToString());

    }

}

private void SaveAsJpeg2000(string inputFile)

{

    string outFile = inputFile + ".jp2";

    using (Image img = Image.Load(inputFile))

    {

        try

        {

            img.Save(outFile, new Jpeg2000Options());

        }

        catch (Exception e)

        {

            this.isError = true;

            stackTrace.AppendLine(e.ToString());

        }

    }

    File.Delete(outFile);

}

  string dir = @"c:\aspose.work\IMAGINGNET\2934\";

string fileName = "16bit Uncompressed, BigEndian, Rgb, Contiguous Gamma1.0.tif";

// ICC profile is not applied for 16-bit color components at the moment, so disable that option explicitly.

LoadOptions loadOptions = new LoadOptions();

loadOptions.UseIccProfileConversion = false;

Rectangle desiredArea = new Rectangle(470, 1350, 30, 30);

using (RasterImage image = (RasterImage)Image.Load(dir + fileName, loadOptions))

{

	long[] colors64Bit = image.LoadArgb64Pixels(image.Bounds);

	ushort alpha, red, green, blue;

	for (int y = desiredArea.Top; y < desiredArea.Bottom; ++y)

	{

		for (int x = desiredArea.Left; x < desiredArea.Right; ++x)

		{

			int offset = y * image.Width + x;

			long color64 = colors64Bit[offset];

			alpha = (ushort)((color64 >> 48) & 0xffff);

			red = (ushort)((color64 >> 32) & 0xffff);

			green = (ushort)((color64 >> 16) & 0xffff);

			blue = (ushort)(color64 & 0xffff);

			Console.WriteLine("A={0}, R={1}, G={2}, B={3}", alpha, red, green, blue);

		}

	}

}

             string fileDir = @"D:\";

            string[] files = new string[2]

           {

                "Abu_Dhabi_Media.svg",

                "az-alkmaar.svg"

           };

            foreach (string fileName in files)

            {

                string inputFileName = Path.Combine(fileDir, fileName);

                string outputFileName = inputFileName + ".jpg";

                using (Image image = Image.Load(inputFileName))

                {

                    JpegOptions options = new JpegOptions();

                    image.Save(outputFileName, options);

                }

            }

 string sourceFileName =

                "alphachannel.psd";

            string outputFileName = "result.jpg";

using (

                    PsdImage image =

                        (PsdImage)

                        Image.Load(

                            sourceFileName,

                            new PsdLoadOptions() { ReadOnlyMode = true, IgnoreAlphaChannel = true }))

                {

                    image.Save(outputFileName, new JpegOptions());

                }

 string animFileName = "Animation1.webp";

string animPathReSavedOptions = "Animation1_reSavedOptions.webp";

WebPOptions options = new WebPOptions();

options.Quality = 90f;

options.AnimLoopCount = 5;

options.AnimBackgroundColor = (uint)Color.Gray.ToArgb();

options.Lossless = true;

using (WebPImage image = Image.Load(animFileName) as WebPImage)

{

    Debug.Assert(4278190080 == image.Options.AnimBackgroundColor);

    Debug.Assert(0 == image.Options.AnimLoopCount);

    image.Save(animPathReSavedOptions, options);

}

using (WebPImage reSavedOptions = Image.Load(animPathReSavedOptions) as WebPImage)

{

    Debug.Assert(reSavedOptions.Options.AnimBackgroundColor == options.AnimBackgroundColor);

    Debug.Assert(reSavedOptions.Options.AnimLoopCount == options.AnimLoopCount);

    Debug.Assert(reSavedOptions.Options.Lossless == options.Lossless);

}

 string fileName = @"D:\NavyExchangeCmyk.psd";

using (PsdImage image = (PsdImage)Image.Load(fileName))

{

	image.UseRawData = true;

	TiffOptions options = new TiffOptions(TiffExpectedFormat.TiffLzwCmyk);                

	if (image.CmykColorProfile != null)

	{

	  options.IccProfile = image.CmykColorProfile.Stream as MemoryStream;

	}

	image.Save(fileName + ".NoLic.tif", options);

}