Source code: org/modama/jaiutil/operators/MosaicDescriptor.java

   /*
    * Copyright (C) Jerry Huxtable 1998-2001. All rights reserved.
    */
   package org.modama.jaiutil.operators;
   
   import java.util.*;
   import java.awt.*;
   import java.awt.image.*;
   import java.awt.image.renderable.*;
  import javax.media.jai.*;
  
  
  /**
   * A JAI operation descriptor for the Mosaic operation. This operation produces
   * an image from a grid of tile sources, each tile being a separate JAI image.
   * All source images must be the same size and have the same tile size, sample
   * model and color model. The resulting image will have a tile size the same as
   * the sources. The parameters are the number of rows and columns in
   * the grid and a two dimensional array of the source tiles.
   * @author Jerry Huxtable
   */
  public class MosaicDescriptor extends OperationDescriptorImpl implements RenderedImageFactory {
  
    private static final String[][] resources = {
      {"GlobalName",  "Mosaic2"},
      {"LocalName",   "Mosaic2"},
      {"Vendor",      "com.jhlabs"},
      {"Description", "An operation that tiles together images"},
      {"DocURL",      "http://www.jhlabs.com/MosaicDescriptor.html"},
      {"Version",     "1.0"},
      {"arg0Desc",  "rows"},
      {"arg1Desc",  "cols"},
    };
  
    private static final String[] paramNames = {
      "rows",
      "cols",
    };
  
    /** 
     * The class types for the parameters of the "Mosaic" operation.  
     */
    private static final Class[] paramClasses = {
      java.lang.Integer.class,
      java.lang.Integer.class,
    };
   
    /**
     * The default parameter values for the "Mosaic" operation
     * when using a ParameterBlockJAI.
     */
    private static final Object[] paramDefaults = {
      new Integer(0),
      new Integer(0),
    };
   
    private static boolean registered = false;
    
    public static void register() {
      if (!registered) {
        OperationRegistry or = JAI.getDefaultInstance().getOperationRegistry();
  
        MosaicDescriptor d = new MosaicDescriptor();
        String operationName = "mosaic2";
        String productName = "com.jhlabs";
        or.registerOperationDescriptor(d, operationName);
        or.registerRIF(operationName, productName, d);
        registered = true;
      }
    }
  
    /**
     * Construct a MosaicDescriptor.
     */
    public MosaicDescriptor() {
      super(resources, 0, paramClasses, paramNames, paramDefaults);
    }
  
    /** 
     *  Creates a MosaicOpImage with the given ParameterBlock if the 
     *  MosaicOpImage can handle the particular ParameterBlock.
     */
    public RenderedImage create(ParameterBlock paramBlock, RenderingHints renderHints) {
      if (!validateParameters(paramBlock))
        return null;
  
      return new MosaicOpImage(
        ((Integer)paramBlock.getObjectParameter(0)).intValue(),
        ((Integer)paramBlock.getObjectParameter(1)).intValue(),
        paramBlock.getSources()
      );
    }
  
    /**
     *  Checks that all parameters in the ParameterBlock have the 
     *  correct type before constructing the MosaicOpImage
     */
    public boolean validateParameters(ParameterBlock paramBlock) {
      for (int i = 0; i < this.getNumParameters(); i++) {
       Object arg = paramBlock.getObjectParameter(i);
       if (arg == null) {
         return false;
       }
       if ((i == 0 || i == 1) && !(arg instanceof Integer))
         return false;
     }
     return true;
   }
 }
 
 /**
  * The MosaicOpImage class.
  * @see org.modama.jaiutil.operators.MosaicDescriptor
  */
 class MosaicOpImage extends OpImage {
 
   /**
    * The number of rows in the mosaic.
    */
   private int rows;
 
   /**
    * The number of columns in the mosaic.
    */
   private int cols;
 
   /**
    * The image tile width.
    */
   private int tileWidth;
 
   /**
    * The image tile height.
    */
   private int tileHeight;
 
   /**
    * The image width.
    */
   private int width;
 
   /**
    * The image height.
    */
   private int height;
 
   /**
    * The number of tiles across the image.
    */
   private int tilesX;
 
   /**
    * The number of tiles down the image.
    */
   private int tilesY;
 
   /**
    * The width of the source tiles.
    */
   private int majorTileWidth;
 
   /**
    * The height of the source tiles.
    */
   private int majorTileHeight;
 
   public MosaicOpImage(int rows, int cols, Vector sources) {
     super(sources, null, null, true);
     this.rows = rows;
     this.cols = cols;
 
     //if (sources.size() < rows*cols)
     //  throw new IllegalArgumentException("Not enough sources supplied to MosaicOperator");
 
     int count = sources.size();
     for (int i = 0; i < count; i++)
       addSource((PlanarImage)sources.elementAt(i));
 
     PlanarImage baseTile = (PlanarImage)sources.firstElement();
     majorTileWidth = baseTile.getWidth();
     majorTileHeight = baseTile.getHeight();
     tileWidth = baseTile.getTileWidth();
     tileHeight = baseTile.getTileHeight();
     width = cols * majorTileWidth;
     height = rows * majorTileHeight;
 
     tilesX = (width + tileWidth - 1) / tileWidth;
     tilesY = (height + tileHeight - 1) / tileHeight;
     
     SampleModel sampleModel = baseTile.getSampleModel();
     ColorModel colorModel = baseTile.getColorModel();
 
     ImageLayout imageLayout = new ImageLayout(0, 0, width, height, 0, 0, tileWidth, tileHeight, sampleModel, colorModel);
     setImageLayout(imageLayout);
   }
 
   public Raster computeTile(int x, int y) {
     DataBuffer dataBuffer = sampleModel.createDataBuffer();
 
     if (x < 0 || x >= tilesX || y < 0 || y >= tilesY) {
       System.out.println("Error: illegal tile requested from a MosaicOpImage.");
       Raster raster = Raster.createRaster(sampleModel, dataBuffer, new Point(x * tileWidth, y * tileHeight));
       return raster;
     }
     try {
       int tx = x * tileWidth / majorTileWidth;
       int ty = y * tileHeight / majorTileHeight;
       Rectangle r = new Rectangle(tileWidth * (x % (majorTileWidth/tileWidth)), tileHeight * (y % (majorTileHeight/tileHeight)), tileWidth, tileHeight);
       PlanarImage op = getSourceImage(ty*cols+tx);
       Raster raster = null;
       synchronized(op) {
         raster = op.getData(r);
         raster = raster.createTranslatedChild(x * tileWidth, y * tileHeight);
       }
       return raster;
     }
     catch (Exception e) {
       e.printStackTrace();
     }
     return Raster.createRaster(sampleModel, dataBuffer, new Point(x * tileWidth, y * tileHeight));
   }
 
     public Rectangle mapDestRect(Rectangle rectangle, int i) {
       return rectangle;
     }
     
     public Rectangle mapSourceRect(Rectangle rectangle, int i) {
       return rectangle;
     }
 }