CardPrintBean.java

/*
 * Copyright Codecrew Ry
 * 
 * All rights reserved.
 * 
 * This license applies to any software containing a notice placed by the 
 * copyright holder. Such software is herein referred to as the Software. 
 * This license covers modification, distribution and use of the Software. 
 * 
 * Any distribution and use in source and binary forms, with or without 
 * modification is not permitted without explicit written permission from the 
 * copyright owner. 
 * 
 * A non-exclusive royalty-free right is granted to the copyright owner of the 
 * Software to use, modify and distribute all modifications to the Software in 
 * future versions of the Software. 
 * 
 */
package fi.codecrew.moya.beans;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOInvalidTreeException;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataNode;
import javax.imageio.stream.ImageOutputStream;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.pdfjet.CoreFont;
import com.pdfjet.Image;
import com.pdfjet.ImageType;
import com.pdfjet.PDF;
import com.pdfjet.Page;
import com.pdfjet.TextLine;

import fi.codecrew.moya.enums.CardObjectDataType;
import fi.codecrew.moya.enums.CardTextAlignment;
import fi.codecrew.moya.enums.CardTextDataType;
import fi.codecrew.moya.enums.CardTextStyle;
import fi.codecrew.moya.facade.CardTemplateFacade;
import fi.codecrew.moya.facade.EventUserFacade;
import fi.codecrew.moya.facade.PrintedCardFacade;
import fi.codecrew.moya.facade.UserFacade;
import fi.codecrew.moya.model.CardObjectData;
import fi.codecrew.moya.model.CardTemplate;
import fi.codecrew.moya.model.CardTextData;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.GenericEntity;
import fi.codecrew.moya.model.PrintedCard;
import fi.codecrew.moya.util.MassPrintResult;

/**
 * Session Bean implementation class CardPrintBean
 */
@Stateless
@LocalBean
public class CardPrintBean implements CardPrintBeanLocal {

	@EJB
	private UserBean userBean;
	@EJB
	private EventUserFacade eventUserFacade;
	@EJB
	private CardTemplateBean cardTemplateBean;
	@EJB
	private CardTemplateFacade cardTemplateFacade;
	@EJB
	private UserFacade userfacade;
	@EJB
	private BarcodeBean barcodeBean;
	@EJB
	private PrintedCardFacade printedCardFacade;
	private static final Logger logger = LoggerFactory.getLogger(CardPrintBean.class);

	public static final double ASPECT_RATIO = 0.7317073170731707;

	/**
	 * Default constructor.
	 */
	public CardPrintBean() {
		// TODO Auto-generated constructor stub
	}

	// TODO: Roles?
	public MassPrintResult getUserCardsAsPrintablePdf(List<Integer> userIdList) throws Exception {
		ArrayList<EventUser> listOfEventUsers = new ArrayList<EventUser>();

		for (Integer userId : userIdList) {
			listOfEventUsers.add(eventUserFacade.find(userId));
		}

		return constructPdf(listOfEventUsers);
	}

	public MassPrintResult getUserCardAsPrintablePdf(Integer userId) throws Exception {
		ArrayList<EventUser> listOfEventUsers = new ArrayList<EventUser>();

		listOfEventUsers.add(eventUserFacade.find(userId));

		return constructPdf(listOfEventUsers);
	}

	public void acceptMassPrintResult(MassPrintResult mpr) {
		for (EventUser eu : mpr.getAffectedUsers()) {
			PrintedCard printedCard = cardTemplateBean.checkPrintedCard(eu);
			printedCard.setPrintCount(printedCard.getPrintCount() + 1);
			System.out.println("Print count " + printedCard.getPrintCount());
		}

		cardTemplateFacade.flush();
	}

	private MassPrintResult constructPdf(List<EventUser> users) throws Exception {

		// double[] pageSize = new double[] { cardBackground.getWidth(),
		// cardBackground.getHeight() };

		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

		PDF pdf = new PDF(outputStream);
		pdf.setTitle("CARD");

		float pagex = 155.52f; // 54,0 mm
		float pagey = 243.84f; // 85,5 mm
		
		

		MassPrintResult mpr = new MassPrintResult();

		HashMap<CardTemplate, List<GenericEntity>> templateHash = new HashMap<CardTemplate, List<GenericEntity>>(); 

		logger.info("constructPdf() users:"); 
		
		for (EventUser user : users) {

			logger.info("User: {}", user.getWholeName());
			
			PrintedCard printedCard = cardTemplateBean.checkPrintedCard(user);

			if (printedCard == null)
				continue;

			logger.info("PrintedCard {}", printedCard);
			
			CardTemplate cardTemplate = printedCard.getTemplate();
			
			logger.info("CardTemplate {}", cardTemplate);
			
			boolean containsKey = templateHash.containsKey(cardTemplate);
			
			logger.info("Containskey {}", containsKey);
			
			if(!containsKey) {
				logger.info("getting objects...");
				List<GenericEntity> objects = sortCardTemplateDatas(cardTemplate);
				logger.info("objects {}", objects);
				templateHash.put(cardTemplate, objects);
			}

			BufferedImage cardBackground = ImageIO.read(new ByteArrayInputStream(cardTemplate.getImage()));

			float k = pagey / (float)cardBackground.getHeight();  
			
			logger.info("Scale k {}", k);
			
			logger.info("cardBackground {}", cardBackground);
			
			BufferedImage faceBufferedImage = null;
			
			if(user.getCurrentImage() != null && user.getCurrentImage().getImageData() != null)
				faceBufferedImage = ImageIO.read(new ByteArrayInputStream(user.getCurrentImage().getImageData()));
			logger.info("faceBufferedImage {}", faceBufferedImage);
			/*
			 * if (faceBufferedImage.getWidth() > 1024 ||
			 * faceBufferedImage.getHeight() > 1024) { throw new
			 * Exception("Image dimensions too large, please take/upload smaller!"
			 * ); }
			 */

			Page page = new Page(pdf, new float[] { pagex, pagey });

			// Render background image
			Image templateImage = new Image(pdf, convertBufferedImageToPng(cardBackground), ImageType.PNG);
			templateImage.setPosition(0, 0);
			templateImage.scaleBy(0.245);
			templateImage.drawOn(page);

			List<GenericEntity> objects = templateHash.get(cardTemplate);
			
			if(objects == null)
				objects = new ArrayList<GenericEntity>();
			
			for(GenericEntity obj : objects) {
				logger.info("GenericEntity {}", obj);
				// force image aspect ratio.
				//for (CardObjectData cardObjectData : objectDatas) {
				CardTextData textData = null;
				CardObjectData objectData = null;
				
				if(obj.getClass().equals(CardTextData.class)) {
					textData = (CardTextData) obj;
				} else if(obj.getClass().equals(CardObjectData.class)) {
					objectData = (CardObjectData) obj;
				}
				if(textData != null) {
					logger.info("TextData {}", textData);
					logger.info("TextData type is {}", textData.getTextDataType());
					com.pdfjet.Font font;
					try {
						if(textData.getFontStyle() == CardTextStyle.BOLD) {
							font = new com.pdfjet.Font(pdf, textData.getFontName(), Font.BOLD); 
						}else if(textData.getFontStyle() == CardTextStyle.ITALIC) {
							font = new com.pdfjet.Font(pdf, textData.getFontName(), Font.ITALIC);
						} else if(textData.getFontStyle() == CardTextStyle.BOLDITALIC) {
							font = new com.pdfjet.Font(pdf, textData.getFontName(), Font.BOLD + Font.ITALIC);
						} else {
							font = new com.pdfjet.Font(pdf, textData.getFontName());
						}
					} catch(Exception ex) {
						font = new com.pdfjet.Font(pdf, CoreFont.HELVETICA);
					}

					
					
					font.setSize(textData.getSize().doubleValue()*k);
					
					
					int[] textColor = new int[] { textData.getFontColorR(), textData.getFontColorG(), textData.getFontColorB()};
					
					
					
					TextLine text = new TextLine(font);
					text.setPosition(textData.getX()*k, textData.getY()*k);
					text.setColor(textColor);
					
					CardTextDataType textDataType = textData.getTextDataType();
					
					if(textDataType == CardTextDataType.NICK) {
						text.setText(user.getUser().getNick());
					} else if(textDataType == CardTextDataType.FIRSTNAME) {
						text.setText(user.getUser().getFirstnames());
					} else if(textDataType == CardTextDataType.LASTNAME) {
						text.setText(user.getUser().getLastname());
					} else if(textDataType == CardTextDataType.WHOLENAME) {
						text.setText(user.getUser().getFirstnames() + " " + user.getUser().getLastname());
					} else if(textDataType == CardTextDataType.ROLE) {
						text.setText(cardTemplate.getName());
					} else if(textDataType == CardTextDataType.AGE){
						text.setText(user.getBirthday().toString());
					} else if(textDataType == CardTextDataType.STATIC) {
						text.setText(textData.getText());
					} else if(textDataType == CardTextDataType.AUTHCODE) {
						text.setText(userBean.getAuthCode(user));
					}
					
					CardTextAlignment alignment = textData.getTextAlignment();
					
					if(alignment == CardTextAlignment.CENTER) {
						float x = k*textData.getX() - text.getWidth() / 2f;
						text.setPosition(x, textData.getY()*k);
					} else if(alignment == CardTextAlignment.RIGHT) {
						float x = textData.getX()*k - text.getWidth();
						text.setPosition(x, textData.getY()*k);
					}
					
					text.drawOn(page);
					logger.info("Draw TextLine on page");
				}
				
				else if(objectData != null) {
					logger.info("ObjectData {}", objectData);
					logger.info("ObjectDatas type is {}", objectData.getObjectDataType());
					if(objectData.getObjectDataType() == CardObjectDataType.USERS_PICTURE) {
						
						if(faceBufferedImage != null) {
							/*
							int originalWidth = faceBufferedImage.getWidth();
							int originalHeight = faceBufferedImage.getHeight();

							int width = (int)objectData.getSize().doubleValue();

							if(objectData.getSize().doubleValue() == 0)
								width = originalWidth;

							int height = (int) Math.round(width * (1 / ASPECT_RATIO));

							if (height > originalHeight) {
								height = originalHeight;
								width = (int) Math.round(originalHeight * ASPECT_RATIO);
							}

							int offsetx = 0;
							int offsety = 0;

							if(objectData.getSize().doubleValue() == 0)
								offsetx = (originalWidth - width) / 2;
							else
								offsetx = ((int)objectData.getSize().doubleValue() - width) / 2;

							offsety = (originalHeight - height) / 2;

							faceBufferedImage = faceBufferedImage.getSubimage(offsetx, offsety, width, height);
*/
							// Render face image
							logger.info("Creating image of face");
							Image faceImage = new Image(pdf, convertBufferedImageToPng(faceBufferedImage), ImageType.PNG);
							faceImage.setPosition((float)objectData.getX()*k, (float)objectData.getY()*k);
							logger.info("Set position of image {}, {}", objectData.getX(), objectData.getY());
							faceImage.scaleBy(k*objectData.getSize().floatValue()/faceImage.getWidth());
							logger.info("Scaled image");
							faceImage.drawOn(page);
							logger.info("drawing image of face on page");
						}
					} else if(objectData.getObjectDataType() == CardObjectDataType.CARDS_BARCODE) {
						BufferedImage barCodeBufferedImage = ImageIO.read(barcodeBean.getCardBarcode(printedCard));
						Image barCodeImage = new Image(pdf, convertBufferedImageToPng(barCodeBufferedImage), ImageType.PNG);
						barCodeImage.setPosition((float)objectData.getX()*k, (float)objectData.getY()*k);
						barCodeImage.scaleBy(k*objectData.getSize().floatValue()/barCodeImage.getWidth());
						barCodeImage.drawOn(page);
						logger.info("Draw Cards barcode on page");
					}
				}
				
				// Barcode
				// String barcodeString =
				// String.valueOf(user.getUser().getCreated().getTime().getTime());

				// barcodeString = barcodeString.substring(barcodeString.length() -
				// 12);
				
				mpr.getAffectedUsers().add(user);
			}
		}
		
		if (mpr.getAffectedUsers().size() == 0) {
			outputStream.close();
			throw new Exception("No cards generated");
		}
		
		pdf.flush();
		outputStream.close();
		
		mpr.setPdf(outputStream.toByteArray());
		
		return mpr;
	}

	private List<GenericEntity> sortCardTemplateDatas(CardTemplate cardTemplate) {
		
		logger.info("getting datas...");
		List<CardTextData> textDatas = cardTemplateBean.findCardTextDatas(cardTemplate);
		logger.info("got cardtextDatas for template {}", cardTemplate);
		List<CardObjectData> objectDatas = cardTemplateBean.findCardObjectDatas(cardTemplate);
		logger.info("got cardObjectDatas for template {}", cardTemplate);

		if(textDatas == null)
			textDatas = new ArrayList<CardTextData>();
		if(objectDatas == null)
			objectDatas = new ArrayList<CardObjectData>();

		List<GenericEntity> objects = new ArrayList<GenericEntity>();

		CardObjectData objectZ = null;
		CardTextData textZ = null;
		
		while(objectDatas.size() > 0 || textDatas.size() > 0) {
			logger.info("objectDatas.size() {}, textDatas.size() {}", objectDatas.size(), textDatas.size());
			
			objectZ = null;
			textZ = null;

			for(CardObjectData obj : objectDatas) {
				if(objectZ == null) {
					objectZ = obj;
					logger.info("biggestObjectZ is {} ", objectZ);
				}
				else if(obj.getzIndex() < objectZ.getzIndex()) {
					objectZ = obj;
					logger.info("biggestObjectZ is {} ", objectZ);
				}
			}
			for(CardTextData obj : textDatas) {
				if(textZ == null) {
					textZ = obj;
					logger.info("biggestTextZ is {} ", textZ);
				}
				else if(obj.getzIndex() < textZ.getzIndex()) {
					textZ = obj;
					logger.info("biggestTextZ is {} ", textZ);
				}
			}

			if(objectZ != null && textZ != null) {
				if(objectZ.getzIndex() >= textZ.getzIndex()) {
					objects.add(objectZ);
					objectDatas.remove(objectZ);
					logger.info("remove objectData {} ", objectZ);
				} else {
					objects.add(textZ);
					textDatas.remove(textZ);
					logger.info("remove textData {} ", textZ);
				}
			}
			else if(objectZ != null) {
				objects.add(objectZ);
				objectDatas.remove(objectZ);
				logger.info("remove objectData {} ", objectZ);
			}
			else if(textZ != null) {
				objects.add(textZ);
				textDatas.remove(textZ);
				logger.info("remove textData {} ", textZ);
			}
		}
		logger.info("return {} ", objects);
		return objects;
	}
	
	@Override
	public byte[] constructPNG(PrintedCard card) throws Exception {
		if (card == null) {
			return null;
		}

		card = printedCardFacade.reload(card);
		// logger.info("Printing card tpl {} with template image  {}",
		// card.getTemplate(), card.getTemplate().getImage());
		EventUser user = card.getUser();

		BufferedImage face = ImageIO.read(new ByteArrayInputStream(user.getUser().getCurrentImage().getImageData()));

		BufferedImage base = ImageIO.read(new ByteArrayInputStream(card.getTemplate().getImage()));

		BufferedImage outimage = new BufferedImage(base.getWidth(), base.getHeight(), BufferedImage.TYPE_INT_RGB);

		List<GenericEntity> objects = sortCardTemplateDatas(card.getTemplate());
		
		Graphics2D g = outimage.createGraphics();
		
		g.drawImage(base, 0, 0, base.getWidth(), base.getHeight(), null);
		
		for(GenericEntity entity : objects) {
			
			CardTextData textData = null;
			CardObjectData objectData = null;
			
			if(entity.getClass().equals(CardTextData.class)) {
				textData = (CardTextData) entity;
			} else if(entity.getClass().equals(CardObjectData.class)) {
				objectData = (CardObjectData) entity;
			}
			
			if(textData != null) {
				Color color = new Color(textData.getFontColorR(), textData.getFontColorG(), textData.getFontColorB());
				//Font font = textData.getFont();
				
				Font font;
				if(textData.getFontStyle() == CardTextStyle.BOLD) {
					font = new Font(textData.getFontName(),Font.BOLD, textData.getSize().intValue()); 
				}else if(textData.getFontStyle() == CardTextStyle.ITALIC) {
					font = new Font(textData.getFontName(),Font.ITALIC, textData.getSize().intValue());
				} else if(textData.getFontStyle() == CardTextStyle.BOLDITALIC) {
					font = new Font(textData.getFontName(),Font.BOLD + Font.ITALIC, textData.getSize().intValue());
				} else {
					font = new Font(textData.getFontName(), Font.PLAIN, textData.getSize().intValue());
				}
				
				g.setColor(color);
				g.setFont(font);
				
				int x = textData.getX();
				int y = textData.getY();
				
				if(textData.getTextAlignment() == CardTextAlignment.CENTER) {
					int width = g.getFontMetrics().charsWidth(user.getUser().getNick().toCharArray(), 0, user.getUser().getNick().length());
					x -= width/2;
				} else if(textData.getTextAlignment() == CardTextAlignment.RIGHT) {
					int width = g.getFontMetrics().charsWidth(user.getUser().getNick().toCharArray(), 0, user.getUser().getNick().length());
					x -= width;
				}
				
				if(textData.getTextDataType() == CardTextDataType.NICK) {
					logger.info("Drawing nick to card.");
					g.drawString(user.getUser().getNick(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.FIRSTNAME) {
					logger.info("Drawing firstname to card.");
					g.drawString(user.getUser().getFirstnames(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.LASTNAME) {
					logger.info("Drawing lastname to card.");
					g.drawString(user.getUser().getLastname(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.WHOLENAME) {
					logger.info("Drawing wholename to card.");
					String wholename = user.getUser().getFirstnames() + " " + user.getUser().getLastname();
					g.drawString(wholename, x, y);
				} else if(textData.getTextDataType() == CardTextDataType.AGE) {
					logger.info("Drawing age to card.");
					g.drawString(user.getUser().getAge().toString(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.ROLE) {
					logger.info("Drawing cards templates name to card.");
					g.drawString(card.getTemplate().getName(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.STATIC) {
					logger.info("Drawing static text '" + textData.getText() + "' to card.");
					g.drawString(textData.getText(), x, y);
				} else if(textData.getTextDataType() == CardTextDataType.AUTHCODE) {
					logger.info("Drawing auth code text '" + textData.getText() + "' to card.");
					g.drawString(userBean.getAuthCode(user), x, y);
				}
				
			} else if(objectData != null) {
				if(objectData.getObjectDataType() == CardObjectDataType.USERS_PICTURE) {
					logger.info("Drawing user's picture to card.");
					//g.drawImage(face, AffineTransform.getScaleInstance(0.31, 0.31),null);
					int height = (int) Math.round(objectData.getSize().intValue() * (1 / ASPECT_RATIO));
					g.drawImage(face, objectData.getX(), objectData.getY(), objectData.getSize().intValue(), height, null);
					
				} else if(objectData.getObjectDataType() == CardObjectDataType.CARDS_BARCODE) {
					logger.info("Drawing card's barcode to card.");
					BufferedImage barCodeBufferedImage = null;
					PrintedCard printedCard = cardTemplateBean.checkPrintedCard(user);
					if (printedCard != null) {
						barCodeBufferedImage = ImageIO.read(barcodeBean.getCardBarcode(printedCard));
						g.drawImage(barCodeBufferedImage, objectData.getX(), objectData.getY(), objectData.getSize().intValue(), barCodeBufferedImage.getHeight(), null);
						g.setColor(Color.white);
					}
				} else if(objectData.getObjectDataType() == CardObjectDataType.USERS_BARCODE) {
					
				}
			}
			
			
			//g.drawImage(org, AffineTransform.getScaleInstance(0.31, 0.31), null);
			
			

			/*
			Color transparentWhite = new Color(255, 255, 255, 140);
			g.setColor(transparentWhite);
			g.fillRect(nickX - 20, nickY - 50, nickWidth + 40, 50);
			int[] nickTextColor = new int[] { 197, 220, 85 };
*/
			//SKynett printCOlor

			/*
			g.setFont(new Font("Arial", Font.BOLD, 35));
			g.drawString(name, 595 -
					g.getFontMetrics().charsWidth(name.toCharArray(), 0, name.length()),890);

			g.drawString(owner.getId().toString(), 60, 948);

			g.setFont(new Font("Century gothic", Font.BOLD, 40));
			g.drawString(wholeName.toString(), 60, 865);
			g.drawString(card.getTemplate().getName(), 60, 915);

			g.drawString(card.getTemplate().getName(), 60, 915);
*/
			

			/* Ei insomniassa
				g.setFont(new Font("Century gothic", Font.PLAIN, 30));
				g.setColor(Color.white);
				BufferedImage barCodeBufferedImage = null;
				if (printedCard != null) {
					int barcodeX = (base.getWidth() - 400) / 2;
					int barcodeY = base.getHeight() - 50;
					g.drawString(barcodeBean.getVrAuthCodeForCard(printedCard), 445, 905);
					barCodeBufferedImage = ImageIO.read(barcodeBean.getCardBarcode(printedCard));
					g.drawImage(barCodeBufferedImage, barcodeX, barcodeY, 400, barCodeBufferedImage.getHeight(), null);
					g.setColor(Color.white);
				}
			 */

			//g.fillRect(0, base.getHeight() - 20, base.getWidth(), base.getHeight());

			
		}
		
		g.dispose();
		
		ByteArrayOutputStream ostr = new ByteArrayOutputStream();

		for (Iterator<ImageWriter> pngWriter = ImageIO.getImageWritersByFormatName("png"); pngWriter.hasNext();)
		{
			ImageWriter writer = pngWriter.next();
			logger.info("Trying to write with writer {}", writer);

			ImageWriteParam writeParam = writer.getDefaultWriteParam();
			ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
			IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, writeParam);
			if (metadata.isReadOnly() || !metadata.isStandardMetadataFormatSupported()) {
				continue;
			}

			setDPI(metadata);

			final ImageOutputStream stream = ImageIO.createImageOutputStream(ostr);
			try {
				writer.setOutput(stream);
				writer.write(metadata, new IIOImage(outimage, null, metadata), writeParam);
			} finally {
				stream.close();
			}
			break;

		}

		ImageIO.write(outimage, "png", ostr);

		byte[] ret = ostr.toByteArray();
		logger.info("Returning {} bytes for pngimage", ret.length);

		/*
		double meter2inchRatio = 1d / 0.0254d;
		int dpi = 300;
		int dim = (int) (dpi * meter2inchRatio) + 1;
*/
		return ret;
	}

	private ByteArrayInputStream convertBufferedImageToPng(BufferedImage img)
			throws IOException {
		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
		ImageIO.write(img, "png", outStream);
		outStream.close();

		return new ByteArrayInputStream(outStream.toByteArray());
	}

	private static void setDPI(IIOMetadata metadata) throws IIOInvalidTreeException {

		// for PMG, it's dots per millimeter
		double dotsPerMilli = 1.0 * 300 / 10 / 2.54;

		IIOMetadataNode horiz = new IIOMetadataNode("HorizontalPixelSize");
		horiz.setAttribute("value", Double.toString(dotsPerMilli));

		IIOMetadataNode vert = new IIOMetadataNode("VerticalPixelSize");
		vert.setAttribute("value", Double.toString(dotsPerMilli));

		IIOMetadataNode dim = new IIOMetadataNode("Dimension");
		dim.appendChild(horiz);
		dim.appendChild(vert);

		IIOMetadataNode root = new IIOMetadataNode("javax_imageio_1.0");
		root.appendChild(dim);

		metadata.mergeTree("javax_imageio_1.0", root);
	}
}