Manipulating Photoshop Formats

Exporting Image to PSD

PSD, Photoshop document, is the default file format used by Adobe Photoshop for working with images. Aspose.Imaging lets you save files in PSD format so that they can be opened and edited in Photoshop. This article shows how to save a file to PSD with Aspose.Imaging, and it also discusses some of the settings that can be used when saving to this format.

PsdOptions class is a specialized class in the com.aspose.imaging.imageoptions package used to export images to PSD. In order to export and image format to PSD, first create an instance of the Image class, either loaded from an existing image file or created from scratch. This article explains how.

In the examples below, an existing image is loaded by passing the file path to the Image class' static load method. Once it is loaded, save the image using the Image class' save method, and supply a PsdOptions object as the second argument.

Several of the PsdOptions class' properties can be set for advanced conversion. Some of the properties are ColorMode, CompressionMethod and Version.

Aspose.Imaging for Java supports the following compression methods through the CompressionMethod enumeration:

• CompressionMethod.Raw
• CompressionMethod.RLE
• CompressionMethod.ZipWithoutProtection
• CompressionMethod.ZipWithProtection

The following color modes are supported through the ColorModes enumeration:

• ColorModes.Bitmap
• ColorModes.Grayscale
• ColorModes.RGB

Additional resources can be added, such as thumbnail resources for PSD v4.0, v5.0 and higher, or grid and guide resources for PSD v4.0 and higher.

The code below opens a BMP file from disk and saves it to PSD with RLE compression and RGB color mode.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
//Load an existing image
com.aspose.imaging.Image image = com.aspose.imaging.Image.load(dataDir + "sample.bmp");

//Create an instance of PsdSaveOptions class
//Create an instance of PsdSaveOptions class
com.aspose.imaging.imageoptions.PsdOptions saveOptions = new com.aspose.imaging.imageoptions.PsdOptions();

//Set the CompressionMethod as Raw
//Note: Other supported CompressionMethod is CompressionMethod.Rle [No Compression]
saveOptions.setCompressionMethod(CompressionMethod.Raw);

//Set the ColorMode to GrayScale//Note: Other supported ColorModes are ColorModes.Bitmap and ColorModes.RGB
saveOptions.setColorMode(ColorModes.Rgb);

//Save the image to disk location with supplied PsdOptions settings
image.save(dataDir + "ExportImageToPSD_out.psd", saveOptions);

// Display Status.
System.out.println("Image exported to PSD successfully!");
    

Importing image to PSD layer

This article demonstrates the usage of Aspose.Imaging for Java to add or import an image to a PSD layer. Aspose.Imaging API have exposed efficient & easy to use methods to achieve this goal.

Aspose.Imaging for Java has exposed the DrawImage method of the Layer class to add/import an image into a PSD file. DrawImage method needs location and image values to add/import an image into a PSD file.

The steps to import image into PSD layer are as simple as below:

1. Load a PSD file as an image using the factory method Load exposed by Image class.
2. Convert the image to PsdImage.
3. Create an instance of Layer class and assign the PSD image layer to it.
4. Load the image that is needed to be added.
5. Call the Layer.DrawImage method while specifying location and image instance.
6. Save the results.

The following code example demonstrates how to import an image.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
String sourceFileName = dataDir + "samplePsd.psd";
		String outputFileName = dataDir + "ImportanImageToPSDLayer_out.psd";

		// Load a PSD file as an image and caste it into PsdImage
		com.aspose.imaging.fileformats.psd.PsdImage image = (com.aspose.imaging.fileformats.psd.PsdImage) com.aspose.imaging.Image
				.load(sourceFileName);

		//Extract a layer from PSDImage
		com.aspose.imaging.fileformats.psd.layers.Layer layer = image.getLayers()[1];

		// Load the image that is needed to be imported into the PSD file.
		String normalImagePath = dataDir + "aspose_logo.png";

		com.aspose.imaging.RasterImage drawImage = (com.aspose.imaging.RasterImage) com.aspose.imaging.Image
				.load(normalImagePath);

		// Call DrawImage method of the Layer class and pass the image instance.
		layer.drawImage(new com.aspose.imaging.Point(10, 10), drawImage);

		// Save the results to output path.
		image.save(outputFileName, new com.aspose.imaging.imageoptions.PsdOptions());

Color replacement in PSD layers

This article demonstrates the usage of Aspose.Imaging for Java to replace color in PSD layers. Aspose.Imaging APIs have exposed efficient & easy to use methods to achieve this goal.The steps to replacement into PSD layer are as simple as below:

1. Load a PSD file as an image using the factory method Load exposed by Image class.
2. Traverse through layers of image and replace color.
3. Save the results.

The following code snippet shows you how to import image to PSD layer.

The following code example demonstrates how to import an image.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
       		
     String fileName = "photooverlay_5_new";
     PngOptions pngOptions = new PngOptions() {{ setColorType(PngColorType.TruecolorWithAlpha); }};
     PsdImage input = (PsdImage)Image.load(fileName + ".psd");
     try
     {
 for (Layer layer : input.getLayers())
        {
           if (layer.getName().equals("Maincolor"))
           {
			layer.replaceNonTransparentColors(Orange);
                 //      replaceNonTransparentColors(Color.getOrange());
			input.save(fileName + "_nonTransparentColors_result.png");
			input.save(fileName + "_nonTransparentColors_result.psd");
			break;
           }
       }
      }
     finally
     {
       input.dispose();
     }

       input = (PsdImage)Image.load(fileName + ".psd");
       try
       {
               for (Layer layer : input.getLayers())
               {
                       if (layer.getName().equals("Maincolor"))
                       {
                               layer.replaceColor(LightGreen,(byte)40,Orange);

                               input.save(fileName + "_specificColor_result.png");
                               input.save(fileName + "_specificColor_result.psd");
                               break;
                       }
               }
       }
       finally
       {
               input.dispose();
   
       }

Creating Thumbnails from PSD Files

PSD is the native document format of Adobe’s Photoshop application. Adobe Photoshop (version 5.0 and later) stores thumbnail information for preview display in an image resource block that consists of an initial 28-byte header, followed by a JFIF thumbnail in RGB (red, green, blue) order.

Aspose.Imaging for Java API provides an easy to use mechanism to access the resources of PSD file. These resources also include the thumbnail resource that in turn can be fetched and saved to disc as per application needs.

The following code snippet demonstrates the usage of Aspose.Imaging for Java API to achieve the same.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
String sourceFileName = dataDir + "samplePsd.psd";
		String outputFileName = dataDir + "result.psd";
		 PsdImage image = (PsdImage) Image.load(sourceFileName);

		// Iterate over the PSD resources
		for (ResourceBlock resource : image.getImageResources()) {
			// Check if the resource is of thumbnail type
			if (resource instanceof ThumbnailResource) {
				// Retrieve the ThumbnailResource
				ThumbnailResource thumbnail = (ThumbnailResource) resource;
				// Check the format of the ThumbnailResource
				if (thumbnail.getFormat() == ThumbnailFormat.KJpegRgb) {
					// Create a new BmpImage by specifying the width and height
					BmpImage thumnailImage = new BmpImage(thumbnail.getWidth(), thumbnail.getHeight());
					// Store the pixels of thumbnail on to the newly created BmpImage
					thumnailImage.savePixels(thumnailImage.getBounds(), thumbnail.getThumbnailData());
					// Save thumbnail on disc
					thumnailImage.save(outputFileName);
				}
			}

Creating Indexed PSD Files

Aspose.Imaging for Java API can create Indexed PSD files from scratch. This article demonstrates the use of PsdOptions and PsdImage classes to create an Indexed PSD while drawing some shapes over the newly created canvas.

The following simple steps are required to create an Indexed PSD file.

1. Create an instance of PsdOptions and set it’s source.
2. Set ColorMode property of the PsdOptions to ColorModes.Indexed.
3. Create a new palette of colors from RGB space and set it as Palette property of PsdOptions.
4. Set CompressionMethod property to required compression algorithm.
5. Create a new PSD image by calling the PsdImage.create method.
6. Draw graphics or perform other operations as per requirement.
7. Call PsdImage.save method to commit all changes.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
PsdOptions createOptions = new PsdOptions();
		// Set source
		createOptions.setSource(new FileCreateSource(dataDir + "output.psd", false));
		// Set ColorMode to Indexed
		createOptions.setColorMode(ColorModes.Indexed);
		// Set PSD file version
		createOptions.setVersion(5);
		// Create a new color patelle having RGB colors
		Color[] palette = new Color[] { Color.getRed(), Color.getGreen(), Color.getBlue() };
		// Set Palette property to newly created palette
		createOptions.setPalette(new com.aspose.imaging.fileformats.psd.PsdColorPalette(palette));
		// Set compression method
		createOptions.setCompressionMethod(CompressionMethod.RLE);

		// Create a new PSD with PsdOptions created previously
		PsdImage psd = (PsdImage) PsdImage.create(createOptions, 500, 500);
		// Draw some graphics over the newly created PSD
		Graphics graphics = new Graphics(psd);
		graphics.clear(Color.getWhite());
		graphics.drawEllipse(new Pen(Color.getRed(), 6), new Rectangle(0, 0, 400, 400));
		psd.save();

Exporting PSD Layer to Raster Image

Aspose.Imaging allows you to export layers in a PSD file into raster images. Please use the com.aspose.imaging.fileformats.psd.layers.Layer.save method to export the layer to image.

The following sample code loads a PSD file and exports each of its layer into a PNG image using com.aspose.imaging.fileformats.psd.layers.Layer.save. Once all layers are exported into PNG images, you can open them using your favorite image viewer.

Here is sample code.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
// Create an instance of Image class and load PSD file as image.
com.aspose.imaging.Image objImage = com.aspose.imaging.Image.load(sourceFileName);

// Cast image object to PSD image
com.aspose.imaging.fileformats.psd.PsdImage psdImage = (com.aspose.imaging.fileformats.psd.PsdImage) objImage;

// Create an instance of PngOptions class
com.aspose.imaging.imageoptions.PngOptions pngOptions = new com.aspose.imaging.imageoptions.PngOptions();
pngOptions.setColorType(com.aspose.imaging.fileformats.png.PngColorType.TruecolorWithAlpha);

// Loop through the list of layers
for (int i = 0; i < psdImage.getLayers().length; i++) {
	// convert and save the layer to PNG file format.
	psdImage.getLayers()[i].save("ExportPSDLayertoRasterImage_out" + i + 1 + ".png", pngOptions);
}

Update Text Layer In PSD File

Aspose.Imaging for Java allows you to manipulate the text in the text layer of a PSD file. Please use the com.aspose.imaging.fileformats.psd.Layers.TextLayer class to update text in PSD layer.

Exporting PSD Layer to Raster Image

The following sample code loads a PSD file, access the text layer, update the text and save the PSD file with a new name using com.aspose.imaging.fileformats.psd.Layers.TextLayer.UpdateText method.

Here is sample code.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
// Create an instance of Image class and load PSD file as image.
com.aspose.imaging.Image objImage = com.aspose.imaging.Image.load(sourceFileName);

// Cast image object to PSD image
com.aspose.imaging.fileformats.psd.PsdImage psdImage = (com.aspose.imaging.fileformats.psd.PsdImage) objImage;

// Create an instance of PngOptions class
com.aspose.imaging.imageoptions.PngOptions pngOptions = new com.aspose.imaging.imageoptions.PngOptions();
pngOptions.setColorType(com.aspose.imaging.fileformats.png.PngColorType.TruecolorWithAlpha);

// Loop through the list of layers
for (int i = 0; i < psdImage.getLayers().length; i++) {
	// convert and save the layer to PNG file format.
	psdImage.getLayers()[i].save("ExportPSDLayertoRasterImage_out" + i + 1 + ".png", pngOptions);
}

Detecting Flattened PSD

Aspose.Imaging for Java allows you to detect whether a given PSD file is flatten or not. IsFlatten property has been introduced in the com.aspose.imaging.fileformats.psd.PsdImage class to achieve this functionality.

The following sample code loads a PSD file and access the property isFlatten.

Here is sample code.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
// Create an instance of Image class and load PSD file as image.
com.aspose.imaging.Image objImage = com.aspose.imaging.Image.load(flattenPath);

// Cast image object to PSD image
com.aspose.imaging.fileformats.psd.PsdImage psdImage = (com.aspose.imaging.fileformats.psd.PsdImage) objImage;

// do processing

// Get the true value if PSD is flatten and false in case the PSD is not flatten.
System.out.println(psdImage.isFlatten());

Merge PSD layers While Converting PSD to JPG

This article shows how to merge layers in a PSD file while converting a PSD file to JPG with Aspose.Imaging.

In the example below, an existing PSD file is loaded by passing the file path to the Image class' static Load method. Once it is loaded, convert/cast the image to PsdImage. Create a JPG file stream. Create an instance of the JpegOptions class. Set the Source property to JPG file stream. Now call the Save method of the PsdImage instance.

Here is sample code.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
String sourceFileName = dataDir + "samplePsd.psd";

		// Load an existing PSD file as image
		com.aspose.imaging.Image image = com.aspose.imaging.Image.load(sourceFileName);

		// Convert the loaded image to PSDImage
		com.aspose.imaging.fileformats.psd.PsdImage psdImage = (com.aspose.imaging.fileformats.psd.PsdImage) image;

		// create a JPG file stream
		java.io.FileInputStream fs = new java.io.FileInputStream(dataDir + "aspose-logo.jpg");

		// Create JPEG option class object
		JpegOptions jpgOptions = new JpegOptions();

		// call the Save the method of PSDImage class to merge the layers and
		// save it as jpg image.
		psdImage.save(dataDir + "MergPSDlayers_out.jpg", jpgOptions);

Grayscale Support with Alpha for PSD

This article shows how to support Grayscale with alpha for PSD file while converting a PSD file to PNG with Aspose.Imaging. In the example below, an existing PSD file is loaded by passing the file path to the Image class static Load method. Once it is loaded, convert/cast the image to PsdImage. Create an instance of the PngOptions class. Set the color property to PNG file . Now call the Save method of the PngOptions instance. The following code snippet shows you how to support Grayscale with Alpha.

Here is sample code.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
		
String filePath = "ill_bado_gs723.psd";
              Image image = Image.load(filePath);
              try
              {
         // Cast image object to PSD image
         PsdImage psdImage = (PsdImage)image;

               // Create an instance of PngOptions class
         PngOptions pngOptions = new PngOptions();
         pngOptions.setColorType(PngColorType.TruecolorWithAlpha);
         image.save("result.png", pngOptions);
                }
                
              finally
               {
              
                image.dispose();
              }

Support for Subscript PSD

This article shows how to add the Subscript option parsing and rendering for PSD text layer. The following code snippet shows you how to support Subscript.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
Image image = Image.load("test.bmp");
try
  {
image.save("test.bmp.png", new PngOptions());
  }
finally
  {
image.dispose();
}

Support for EPS Format

This article shows how to support Formats like EPS in Aspose.Imaging. The following code snippet shows you how to support EPS.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
     
String dataDir = Utils.getSharedDataDir(SupportForEPS.class) + "EPS/"; 
EpsImage epsImage = (EpsImage)Image.load(dataDir+"anyEpsFile.eps");
try
{
	// check if EPS image has any raster preview to proceed (for now only raster preview is supported)
	if (epsImage.hasRasterPreview())
	{
		if (epsImage.getPhotoshopThumbnail() != null)
		{
			// process Photoshop thumbnail if it's present
		}

		if (epsImage.getEpsType() == EpsType.Interchange)
		{
			// Get EPS Interchange subformat instance
			EpsInterchangeImage epsInterchangeImage = (EpsInterchangeImage)epsImage;

			if (epsInterchangeImage.getRasterPreview() != null)
			{
				// process black-and-white Interchange raster preview if it's present
			}
		}
		else
		{
			// Get EPS Binary subformat instance
			EpsBinaryImage epsBinaryImage = (EpsBinaryImage)epsImage;

			if (epsBinaryImage.getTiffPreview() != null)
			{
				// process TIFF preview if it's present
			}

			if (epsBinaryImage.getWmfPreview() != null)
			{
				// process WMF preview if it's present
			}
		}

		// export EPS image to PNG (by default, best available quality preview is used for export)
		epsImage.save(dataDir+"anyEpsFile.png", new PngOptions());
	}
}
finally
{
	epsImage.close();
}

Support for SmallCap PSD

This article shows how to add the SmallCap option parsing and rendering for PSD text layer. The following code snippet shows you how to support SmallCap.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
Image image = Image.load(dataDir + "aspose-logo.jpg");

image.resize(300, 300);
image.save(dataDir + "SimpleResizing_out.jpg");

Support Layer Effects For PSD

This article shows how support different effects like Blur, Inner Glow, Outer Glow for PSD layer. The following code snippet shows you how to support layer effects.

// For complete examples and data files, please go to https://github.com/Muhammad-Adnan-Ahmad/Aspose.Imaging-for-Java
String dataDir = Utils.getSharedDataDir(SupportEffectsforPSD.class) + "Photoshop/";
String output = "dropShadow.png";

PsdLoadOptions psdLoadOptions=new PsdLoadOptions();
psdLoadOptions.setLoadEffectsResource(true);
psdLoadOptions.setUseDiskForLoadEffectsResource(true);
PsdImage image = (PsdImage)Image.load(dataDir+"test.psd",psdLoadOptions);
try
{
 //Debug.assert_(image.getLayers()[2] != null, "Layer with effects resource was not recognized");

 PngOptions pngOptions=new PngOptions();

 pngOptions.setColorType (PngColorType.TruecolorWithAlpha);


 image.save(output,pngOptions);
}
finally
{
 image.dispose();
} 

}

Specifying a Font Folder

The FontSettings. addFontsFolder() method is used to indicate where Aspose.Imaging should look for fonts. When a valid path is passed to this method, Aspose.Imaging no longer looks in the registry or the Windows\Font folder to look for fonts and only scans for fonts within the specified folder. When a custom font folder is set using this method, the folder is checked that it exists and is accessible. If the folder cannot be found, then it sets the default folder.

The following examples demonstrates how to set the folder

// The path to the documents directory.
String dataDir = Utils.getSharedDataDir(SetFontsFolder.class) + "Photoshop/";
String sourceFile = dataDir+"grinched-regular-font.psd";
String output = dataDir+"grinched-regular-font.psd.png";
//Folder that contains fonts that we want to use for rendering
//(file GrinchedRegular.otf must be in this folder for proper work of example)
// You can use FontSettings.addFontsFolder or you can use FontSettings.setFontsFolder to avoid system fonts
FontSettings.addFontsFolder(dataDir+"Fonts\\");
FontSettings.updateFonts();
PsdImage image = (PsdImage) Image.load(sourceFile, new PsdLoadOptions());
try {
 image.save(output, new PngOptions());
} finally {
 image.close();
}

Rendering of Rotated Text Layers

 Aspose.Imaging for Java provides the feature of rendering of rotated Text layers. In the example below, an existing PSD file is loaded by passing the file path to the Image class static Load method. Now call the Save method of the PsdImage instance.

The following code snippet shows you how to render rotated Text layers.

     
   String dataDir = Utils.getSharedDataDir(RenderingOfRotatedTextLayerByTransformMatrix.class) + "Photoshop/";
   
   String sourceFileName = dataDir + "TransformedText.psd";
   String exportPath = dataDir + "TransformedTextExport.psd";
   String exportPathPng = dataDir + "TransformedTextExport.png";
 
   PsdImage im = (PsdImage) Image.load(sourceFileName);
 
   try
   {
       im.save(exportPath);
       im.save(exportPathPng, new PngOptions()
       {{
           setColorType(PngColorType.TruecolorWithAlpha);
       }});
   }
   finally
   {
       im.close();
   }
   

Support of Fill Layers With Gradient Fill

This article demonstrates the usage of Gradient fill to fill PSD layer. Aspose.Imaging for Java APIs have exposed efficient and easy to use methods to achieve this goal. Aspose.Imaging has exposed the GradientColorPoint and GradientTransparencyPoint classes to add Gradient effect into a layer.

 The steps to fill PSD layer with Gradient fill are as simple as below:

• Load a PSD file as an image using the factory method Load exposed by Image class.
• Set settings properties of FillLayer object.
• Create list of ColorPoints with required colors and position of color.
• Create list of TransparencyPoints with required opacity and position of transparency point.
• Call the FillLayer.Update method
• Save the results.

The following code snippet shows you how to add Gradient fill to PSD layer. 

     
   String dataDir = Utils.getSharedDataDir(SupportOfGradientFillLayer.class) + "Photoshop/";
   String sourceFileName = dataDir + "ComplexGradientFillLayer.psd";
   String outputFile = dataDir +  "ComplexGradientFillLayer_output.psd";
 
   PsdImage im = (PsdImage) Image.load(sourceFileName);
 
   try
   {
       for (Layer layer : im.getLayers())
       {
           if (layer instanceof FillLayer)
           {
               FillLayer fillLayer = (FillLayer) layer;
 
               if (fillLayer.getFillSettings().getFillType() != FillType.Gradient)
               {
                   throw new RuntimeException("Wrong Fill Layer");
               }
 
               IGradientFillSettings settings = (IGradientFillSettings) fillLayer.getFillSettings();
 
               if (
                       Math.abs(settings.getAngle() - 45) > 0.25 ||
                               settings.getDither() != true ||
                               settings.getAlignWithLayer() != false ||
                               settings.getReverse() != false ||
                               Math.abs(settings.getHorizontalOffset() - (-39)) > 0.25 ||
                               Math.abs(settings.getVerticalOffset() - (-5)) > 0.25 ||
                               settings.getTransparencyPoints().length != 3 ||
                               settings.getColorPoints().length != 2 ||
                               Math.abs(100.0 - settings.getTransparencyPoints()[0].getOpacity()) > 0.25 ||
                               settings.getTransparencyPoints()[0].getLocation() != 0 ||
                               settings.getTransparencyPoints()[0].getMedianPointLocation() != 50 ||
                               !settings.getColorPoints()[0].getColor().equals(Color.fromArgb(203, 64, 140)) ||
                               settings.getColorPoints()[0].getLocation() != 0 ||
                               settings.getColorPoints()[0].getMedianPointLocation() != 50)
               {
                   throw new RuntimeException("Gradient Fill was not read correctly");
               }
 
               settings.setAngle(0.0);
               settings.setDither(false);
               settings.setAlignWithLayer(true);
               settings.setReverse(true);
               settings.setHorizontalOffset(25);
               settings.setVerticalOffset(-15);
 
               List<IGradientColorPoint> colorPoints = new ArrayList<IGradientColorPoint>();
               Collections.addAll(colorPoints, settings.getColorPoints());
               List<IGradientTransparencyPoint> transparencyPoints = new ArrayList<IGradientTransparencyPoint>();
               Collections.addAll(transparencyPoints, settings.getTransparencyPoints());
 
               GradientColorPoint gr1 = new GradientColorPoint();
               gr1.setColor(Color.getViolet());
               gr1.setLocation(4096);
               gr1.setMedianPointLocation(75);
 
               colorPoints.add(gr1);
 
               colorPoints.get(1).setLocation(3000);
 
               GradientTransparencyPoint gr2 = new GradientTransparencyPoint();
               gr2.setOpacity(80.0);
               gr2.setLocation(4096);
               gr2.setMedianPointLocation(25);
 
               transparencyPoints.add(gr2);
 
               transparencyPoints.get(2).setLocation(3000);
 
               settings.setColorPoints(colorPoints.toArray(new IGradientColorPoint[0]));
               settings.setTransparencyPoints(transparencyPoints.toArray(new IGradientTransparencyPoint[0]));
               fillLayer.update();
 
               im.save(outputFile, new PsdOptions(im));
 
               break;
           }
       }
   }
   finally
   {
       im.close();
   }

Support of Fill Layers With Color Fill

This article demonstrates how to fill PSD layer with Color. Please use the Aspose.Imaging.FileFormats.Psd.Layers.FillLayer to add Color in PSD layer. The following code snippets loads a PSD file, access the Filllayer class and sets the color using the FillLayer.FillSettings property.

     
   String dataDir = Utils.getSharedDataDir(SupportOfColorFillLayer.class) + "Photoshop/";
   String sourceFileName = dataDir + "ColorFillLayer.psd";
   String exportPath = dataDir + "ColorFillLayer_output.psd";
   String exportPathPng = dataDir + "ColorFillLayer_output.png";
 
   PsdImage im = (PsdImage) Image.load(sourceFileName);
 
   try
   {
       for (Layer layer : im.getLayers())
       {
           if (layer instanceof FillLayer)
           {
               FillLayer fillLayer = (FillLayer) layer;
 
               if (fillLayer.getFillSettings().getFillType() != FillType.Color)
               {
                   throw new RuntimeException("Wrong Fill Layer");
               }
 
               IColorFillSettings settings = (IColorFillSettings) fillLayer.getFillSettings();
 
               settings.setColor(Color.getRed());
               fillLayer.update();
               im.save(exportPath);
               break;
           }
       }
   }
   finally
   {
       im.close();
   }

Support of VmskResource

This article shows support of VmskResource in a PSD file with Aspose.Imaging.

• Load a PSD file as an image using the factory method Load exposed by Image class
• Get VmskResource from image layer
• Set required properties of VmskResource
• Save the results

The following code snippet shows you how Aspose.Imaging supports VmskResource.

     
   String dataDir = Utils.getSharedDataDir(SupportOfVmskResource.class) + "Photoshop/";
   
   String sourceFileName = dataDir+ "Rectangle.psd";
String exportPath = dataDir + "Rectangle_changed.psd";
 
PsdImage im = (PsdImage)Image.load(sourceFileName);
 
try
    {
   VmskResource resource = getVmskResource(im);
 
   // Reading
   if (resource.isDisabled() != false ||
           resource.isInverted() != false ||
           resource.isNotLinked() != false ||
           resource.getPaths().length != 7 ||
           resource.getPaths()[0].getType() != VectorPathType.PathFillRuleRecord ||
           resource.getPaths()[1].getType() != VectorPathType.InitialFillRuleRecord ||
           resource.getPaths()[2].getType() != VectorPathType.ClosedSubpathLengthRecord ||
           resource.getPaths()[3].getType() != VectorPathType.ClosedSubpathBezierKnotUnlinked ||
           resource.getPaths()[4].getType() != VectorPathType.ClosedSubpathBezierKnotUnlinked ||
           resource.getPaths()[5].getType() != VectorPathType.ClosedSubpathBezierKnotUnlinked ||
           resource.getPaths()[6].getType() != VectorPathType.ClosedSubpathBezierKnotUnlinked)
   {
       throw new RuntimeException("VmskResource was read wrong");
   }
 
   PathFillRuleRecord pathFillRule = (PathFillRuleRecord) resource.getPaths()[0];
   InitialFillRuleRecord initialFillRule = (InitialFillRuleRecord) resource.getPaths()[1];
   LengthRecord subpathLength = (LengthRecord) resource.getPaths()[2];
 
   // Path fill rule doesn't contain any additional information
   if (pathFillRule.getType() != VectorPathType.PathFillRuleRecord ||
           initialFillRule.getType() != VectorPathType.InitialFillRuleRecord ||
           initialFillRule.isFillStartsWithAllPixels() != false ||
           subpathLength.getType() != VectorPathType.ClosedSubpathLengthRecord ||
           subpathLength.isClosed() != true ||
           subpathLength.isOpen() != false)
   {
       throw new RuntimeException("VmskResource paths were read wrong");
   }
 
   // Editing
   resource.setDisabled(true);
   resource.setInverted(true);
   resource.setNotLinked(true);
 
   BezierKnotRecord bezierKnot = (BezierKnotRecord) resource.getPaths()[3];
   bezierKnot.getPoints()[0] = new Point(0, 0);
 
   bezierKnot = (BezierKnotRecord) resource.getPaths()[4];
   bezierKnot.getPoints()[0] = new Point(8039797, 10905190);
 
   initialFillRule.setFillStartsWithAllPixels(true);
   subpathLength.setClosed(false);
   im.save(exportPath);
    }
finally
    {
   im.close();
    }

static VmskResource getVmskResource(PsdImage image)
{
Layer layer = image.getLayers()[1];
 
VmskResource resource = null;
LayerResource[] resources = layer.getResources();
for (int i = 0; i < resources.length; i++)
    {
   if (resources[i] instanceof VmskResource)
   {
       resource = (VmskResource) resources[i];
       break;
   }
    }
 
if (resource == null)
    {
   throw new RuntimeException("VmskResource not found");
    }
 
return resource;
}

Support of GdFlResource

This article demonstrates how Aspose.Imaging for Java supports GdFIResource in a PSD file. GdFIResource contains information about blending of clipped element.

• Load a PSD file as an image using the factory method Load exposed by Image class.
• Get GdFlResource from image layer
• Create list of ColorPoints with required colors and position of color.
• Create list of TransparencyPoints with required opacity and position of transparency point.
• Save the results.

The following code snippet shows how Aspose.Imaging for Java supports GdFIResource.

     
   String dataDir = Utils.getSharedDataDir(SupportOfGdFlResource.class) + "Photoshop/";
   
   
   String sourceFileName = dataDir + "ComplexGradientFillLayer.psd";
   String exportPath = dataDir + "ComplexGradientFillLayer_after.psd";
 
   PsdImage im = (PsdImage) Image.load(sourceFileName);
 
   try
   {
       for (Layer layer : im.getLayers())
       {
           if (layer instanceof FillLayer)
           {
               FillLayer fillLayer = (FillLayer) layer;
 
               for (LayerResource res : fillLayer.getResources())
               {
                   if (res instanceof GdFlResource)
                   {
                       // Reading
                       GdFlResource resource = (GdFlResource) res;
 
                       if (resource.getAlignWithLayer() != false ||
                               (Math.abs(resource.getAngle() - 45.0) > 0.001) ||
                               resource.getDither() != true ||
                               resource.getReverse() != false ||
                               !resource.getColor().equals(Color.getEmpty()) ||
                               Math.abs(resource.getHorizontalOffset() - (-39)) > 0.001 ||
                               Math.abs(resource.getVerticalOffset() - (-5)) > 0.001 ||
                               resource.getTransparencyPoints().length != 3 ||
                               resource.getColorPoints().length != 2)
                       {
                           throw new RuntimeException("Resource Parameters were read wrong");
                       }
 
                       IGradientTransparencyPoint[] transparencyPoints = resource.getTransparencyPoints();
 
                       if (Math.abs(100.0 - transparencyPoints[0].getOpacity()) > 0.25 ||
                               transparencyPoints[0].getLocation() != 0 ||
                               transparencyPoints[0].getMedianPointLocation() != 50 ||
                               Math.abs(50.0 - transparencyPoints[1].getOpacity()) > 0.25 ||
                               transparencyPoints[1].getLocation() != 2048 ||
                               transparencyPoints[1].getMedianPointLocation() != 50 ||
                               Math.abs(100.0 - transparencyPoints[2].getOpacity()) > 0.25 ||
                               transparencyPoints[2].getLocation() != 4096 ||
                               transparencyPoints[2].getMedianPointLocation() != 50)
                       {
                           throw new RuntimeException("Gradient Transparency Points were read Wrong");
                       }
 
                       IGradientColorPoint[] colorPoints = resource.getColorPoints();
 
                       if (!colorPoints[0].getColor().equals(Color.fromArgb(203, 64, 140)) ||
                               colorPoints[0].getLocation() != 0 ||
                               colorPoints[0].getMedianPointLocation() != 50 ||
                               !colorPoints[1].getColor().equals(Color.fromArgb(203, 0, 0)) ||
                               colorPoints[1].getLocation() != 4096 ||
                               colorPoints[1].getMedianPointLocation() != 50)
                       {
                           throw new RuntimeException("Gradient Color Points were read Wrong");
                       }
 
                       // Editing
                       resource.setAngle(30.0);
                       resource.setDither(false);
                       resource.setAlignWithLayer(true);
                       resource.setReverse(true);
                       resource.setHorizontalOffset(25);
                       resource.setVerticalOffset(-15);
 
                       List<IGradientColorPoint> newColorPoints = new ArrayList<IGradientColorPoint>();
                       Collections.addAll(newColorPoints, resource.getColorPoints());
                       List<IGradientTransparencyPoint> newTransparencyPoints = new ArrayList<IGradientTransparencyPoint>();
                       Collections.addAll(newTransparencyPoints, resource.getTransparencyPoints());
 
                       GradientColorPoint gr = new GradientColorPoint();
                       gr.setMedianPointLocation(75);
                       gr.setLocation(4096);
                       gr.setColor(Color.getViolet());
                       newColorPoints.add(gr);
 
                       colorPoints[1].setLocation(3000);
 
                       GradientTransparencyPoint gr2 = new GradientTransparencyPoint();
                       gr2.setOpacity(80.0);
                       gr2.setLocation(4096);
                       gr2.setMedianPointLocation(25);
 
                       newTransparencyPoints.add(gr2);
 
                       transparencyPoints[2].setLocation(3000);
 
                       resource.setColorPoints(newColorPoints.toArray(new IGradientColorPoint[0]));
                       resource.setTransparencyPoints(newTransparencyPoints.toArray(new IGradientTransparencyPoint[0]));
 
                       im.save(exportPath);
                   }
 
                   break;
               }
 
               break;
           }
       }
   }
   finally
   {
       im.close();
   }
    }

Support of SoCoResource

This article demonstrates how Aspose.Imaging for Java supports SoCoResource in a PSD file.

• Load a PSD file as an image using the factory method Load exposed by Image class.
• Get SoCoResource from image layer
• Set required properties
• Save the results

 The following code snippet shows how Aspose.Imaging for Java supports SoCoResource.

     
   String dataDir = Utils.getSharedDataDir(SupportOfSoCoResource.class) + "Photoshop/";
   
   // Support of SoCoResource
   String sourceFileName = dataDir +"ColorFillLayer.psd";
   String exportPath = dataDir +"SoCoResource_Edited.psd";
 
   PsdImage im = (PsdImage) Image.load(sourceFileName);
 
   try
   {
       for (Layer layer : im.getLayers())
       {
           if (layer instanceof FillLayer)
           {
               FillLayer fillLayer = (FillLayer) layer;
               for (LayerResource resource : fillLayer.getResources())
               {
                   if (resource instanceof SoCoResource)
                   {
                       SoCoResource socoResource = (SoCoResource) resource;
                       Assert.areEqual(Color.fromArgb(63, 83, 141), socoResource.getColor());
                       socoResource.setColor(Color.getRed());
                       break;
                   }
               }
               break;
           }
           im.save(exportPath);
       }
   }
   finally
   {
       im.close();
   }