package de.desy.acop.video.analysis;
   
   import de.desy.acop.video.Definitions;
   import de.desy.tine.structUtils.TTaggedStructure;
   import de.desy.tine.types.IMAGE;
   
   /**
    * 
    * <code>AImage</code> is the object that is transferred across the
   * system from the video analysis server to the video client.
   * This object carries with it the raw tine IMAGE and analysis results
   * and parameters. For details on parameters see the constructor
   * documentation.
   *
   * @author <a href="mailto:jaka.bobnar@cosylab.com">Jaka Bobnar</a>
   *
   */
  public class AImage extends TTaggedStructure {
  
  	private final IMAGE[] image = new IMAGE[1];
  	private final int[] imageW = new int[1];
  	private final int[] imageH = new int[1];
  	private final int[] roiX = new int[1];
  	private final int[] roiY = new int[1];
  	private final int[] roiW = new int[1];
  	private final int[] roiH = new int[1];
  	private final int[] roi2X = new int[1];
  	private final int[] roi2Y = new int[1];
  	private final int[] roi2W = new int[1];
  	private final int[] roi2H = new int[1];
  	private final int[] thresholdPoints = new int[1];
  	private final double[] threshold = new double[1];
  	private final double[] sideViewX = new double[Definitions.MAX_WIDTH];
  	private final double[] sideViewY = new double[Definitions.MAX_HEIGHT];
  	private final double[] sideViewAmplitudeX = new double[1];
  	private final double[] sideViewAmplitudeY = new double[1];
  	private final double[] sideViewConstX = new double[1];
  	private final double[] sideViewConstY = new double[1];
  	private final double[] stdX = new double[1];
  	private final double[] stdY = new double[1];
  	private final double[] meanX = new double[1];
  	private final double[] meanY = new double[1];
  	private final double[] stdA = new double[1];
  	private final double[] stdB = new double[1];
  	private final double[] amplitude2D = new double[1];
  	private final double[] angle2D = new double[1];
  	private final double[] const2D = new double[1];
  	private final double[] meanXFit = new double[1];
  	private final double[] stdXFit = new double[1];
  	private final double[] amplitudeXFit = new double[1];
  	private final double[] constXFit = new double[1];
  	private final double[] slopeXFit = new double[1];
  	private final double[] meanYFit = new double[1];
  	private final double[] stdYFit = new double[1];
  	private final double[] amplitudeYFit = new double[1];
  	private final double[] constYFit = new double[1];
  	private final double[] slopeYFit = new double[1];
  	private final byte[] calculateThreshold = new byte[1];
  	private final byte[] performFit = new byte[1];
  	private final byte[] performSmoothing = new byte[1];
  	
  	private final int width;
  	private final int height;
  	/**
  	 * Constructs a new AImage, with default values (empty image and 0 value parameters
  	 * and results).
  	 */
  	public AImage() {
  		super("AISr4");
  		image[0] = new IMAGE();
  //		sideViewX = new double[0];
  //		sideViewY = new double[0];
  		width = 0;
  		height = 0;
  		initStructure();
  	}
  	
  	/**
  	 * Constructs a new AImage from the given AImage. This method creates a clone
  	 * of the given image.
  	 * 
  	 * @param image the image
  	 */
  	public AImage(AImage image) {
  		this(image.getImage(),image.getRoiX(),image.getRoiY(),image.getRoiW(),image.getRoiH(),
  				image.getRoi2X(), image.getRoi2Y(), image.getRoi2W(), image.getRoi2H(), image.getThreshold(),
  				image.getSideViewX(), image.getMeanX(), image.getStdX(), image.getSideViewAmplitudeX(),image.getSideViewConstX(),
  				image.getMeanXFit(), image.getStdXFit(), image.getAmplitudeXFit(), image.getConstXFit(), image.getSlopeXFit(),
  				image.getSideViewY(), image.getMeanY(), image.getStdY(), image.getSideViewAmplitudeY(), image.getSideViewConstY(),
  				image.getMeanYFit(), image.getStdYFit(), image.getAmplitudeYFit(), image.getConstYFit(), image.getSlopeYFit(),
  				image.getStdA(), image.getStdB(), image.getAngle2D(), image.getAmplitude2D(), image.getConst2D(),
  				image.getThresholdPoints(),image.isCalculateThreshold(),image.isPerformFit(),image.isPerformSmoothing());
  	}
  	
  	/**
  	 * Constructs a new AImage.
  	 *  
  	 * @param image the raw image, which was analyzed and all data was obtained from
  	 * @param roiX the region of interest right coordinate (image is analyzed inside region of interest)
 	 * @param roiY the region of interest upper coordinate (image is analyzed inside region of interest)
 	 * @param roiW the width of region of interest (image is analyzed inside region of interest)
 	 * @param roiH the height of region of interest (image is analyzed inside region of interest)
 	 * @param roi2X the region of interest used for automatic threshold calculation right coordinate
 	 * @param roi2Y the region of interest used for automatic threshold calculation upper coordinate
 	 * @param roi2W the region of interest used for automatic threshold calculation width
 	 * @param roi2H the region of interest used for automatic threshold calculation height
 	 * @param threshold the used threshold value (calculated or user defined)
 	 * @param sideViewX horizontal side view values
 	 * @param meanX horizontal statistical mean value 
 	 * @param stdX horizontal statistical standard deviation value
 	 * @param sideAmplitudeX horizontal statistical amplitude value 
 	 * @param sideConstX horizontal statistical constant value
 	 * @param meanXFit horizontal fitted mean value
 	 * @param stdXFit horizontal fitted standard deviation value 
 	 * @param sideAmplitudeXFit horizontal fitted amplitude value
 	 * @param sideConstXFit horizontal fitted constant value
 	 * @param slopeXFit the slope of the linear function in the fit
 	 * @param sideViewY vertical side view values
 	 * @param meanY vertical statistical mean value 
 	 * @param stdY vertical statistical standard deviation value
 	 * @param sideAmplitudeY vertical statistical amplitude value 
 	 * @param sideConstY vertical statistical constant value
 	 * @param meanYFit vertical fitted mean value
 	 * @param stdYFit vertical fitted standard deviation value 
 	 * @param sideAmplitudeYFit vertical fitted amplitude value
 	 * @param sideConstYFit vertical fitted constant value
 	 * @param slopeYFit the slope of the linear function in the fit
 	 * @param stdA main 2D axis statistical standard deviation
 	 * @param stdB secondary 2D axis statistical standard deviation
 	 * @param angle2D the statistical rotation angle of the main axis according to x-y coordinate system
 	 * @param amplitude2D the statistical 2D amplitude  
 	 * @param const2D the statistical 2D constant (minimum value)
 	 * @param thresholdPoints the number of points on which the threshold was calculated
 	 * @param calculateThreshold flag indicating if threshold calculation is automatic
 	 * @param performFit flag indicating if fitting was performed (if false the 'fit' parameters
 	 * 			are a-priori invalid)
 	 * @param performSmoothing flag indicating if smoothing should be performed
 	 */
 	public AImage(IMAGE image, int roiX, int roiY, int roiW, int roiH, int roi2X, int roi2Y,
 			int roi2W, int roi2H, double threshold,
 			double[] sideViewX, double meanX, double stdX, double sideAmplitudeX, double sideConstX,
 			double meanXFit, double stdXFit, double sideAmplitudeXFit, double sideConstXFit, double slopeXFit,
 			double[] sideViewY, double meanY, double stdY, double sideAmplitudeY, double sideConstY,
 			double meanYFit, double stdYFit, double sideAmplitudeYFit, double sideConstYFit, double slopeYFit,
 			double stdA, double stdB, double angle2D, double amplitude2D, double const2D, 
 			int thresholdPoints, boolean calculateThreshold, boolean performFit, boolean performSmoothing) {
 		super("AISr4");
 		
 		int width = image.getFrameHeader().sourceWidth;
 		int height = image.getFrameHeader().sourceHeight;
 		int aoiWidth = image.getFrameHeader().aoiWidth;
 		int aoiHeight = image.getFrameHeader().aoiHeight;
 		
 		if (aoiWidth != -1 || aoiHeight != -1) {
 			if (sideViewX.length != aoiWidth) throw new IllegalArgumentException("Incompatible size of X side view array.");
 			if (sideViewY.length != aoiHeight) throw new IllegalArgumentException("Incompatible size of Y side view array.");
 			if (roiX < 0 || roiY < 0 || roiW < 0 || roiH < 0 || roiX+roiW > aoiWidth || roiY+roiH > aoiHeight) throw new IllegalArgumentException("Illegal region of interest specified.");
 			if (roi2X < 0 || roi2Y < 0 || roi2W < 0 || roi2H < 0 || roi2X+roi2W > aoiWidth || roi2Y+roiH > aoiHeight) throw new IllegalArgumentException("Illegal region of interest 2 specified.");
 			this.width = aoiWidth;
 			this.height = aoiHeight;
 		}
 		else {
 			if (sideViewX.length != width) throw new IllegalArgumentException("Incompatible size of X side view array.");
 			if (sideViewY.length != height) throw new IllegalArgumentException("Incompatible size of Y side view array.");
 			if (roiX < 0 || roiY < 0 || roiW < 0 || roiH < 0 || roiX+roiW > width || roiY+roiH > height) throw new IllegalArgumentException("Illegal region of interest specified.");
 			if (roi2X < 0 || roi2Y < 0 || roi2W < 0 || roi2H < 0 || roi2X+roi2W > width || roi2Y+roi2H > height) throw new IllegalArgumentException("Illegal region of interest 2 specified.");
 			this.width = width;
 			this.height = height;
 		}
 		
 //		this.sideViewX = new double[sideViewX.length];
 //		this.sideViewY = new double[sideViewY.length];
 		for (int i = 0; i < sideViewX.length; i++) {
 			this.sideViewX[i] = sideViewX[i];
 		}
 		this.stdX[0] = stdX;
 		this.meanX[0] = meanX;
 		this.sideViewAmplitudeX[0] = sideAmplitudeX;
 		this.sideViewConstX[0] = sideConstX;
 		
 		for (int i = 0; i < sideViewY.length; i++) {
 			this.sideViewY[i] = sideViewY[i];
 		}
 		this.stdY[0] = stdY;
 		this.meanY[0] = meanY;
 		this.sideViewAmplitudeY[0] = sideAmplitudeY;
 		this.sideViewConstY[0] = sideConstY;
 		this.stdA[0] = stdA;
 		this.stdB[0] = stdB;
 		this.amplitude2D[0] = amplitude2D;
 		this.angle2D[0] = angle2D;
 		this.const2D[0] = const2D;
 		this.roiX[0] = roiX;
 		this.roiY[0] = roiY;
 		this.roiW[0] = roiW;
 		this.roiH[0] = roiH;
 		this.roi2X[0] = roi2X;
 		this.roi2Y[0] = roi2Y;
 		this.roi2W[0] = roi2W;
 		this.roi2H[0] = roi2H;
 		this.imageW[0] = width;
 		this.imageH[0] = height;
 		this.threshold[0] = threshold;
 		this.meanXFit[0] = meanXFit;
 		this.stdXFit[0] = stdXFit;
 		this.amplitudeXFit[0] = sideAmplitudeXFit;
 		this.constXFit[0] = sideConstXFit;
 		this.slopeXFit[0] = slopeXFit;
 		this.meanYFit[0] = meanYFit;
 		this.stdYFit[0] = stdYFit;
 		this.amplitudeYFit[0] = sideAmplitudeYFit;
 		this.constYFit[0] = sideConstYFit;
 		this.slopeYFit[0] = slopeYFit;
 		this.thresholdPoints[0] = thresholdPoints;
 		this.calculateThreshold[0] = calculateThreshold ? (byte)1 : (byte)0;
 		this.performFit[0] = performFit ? (byte)1 : (byte)0;
 		this.performSmoothing[0] = performSmoothing ? (byte)1 : (byte)0;
 		//assign directly, but make sure you pass in a clean copy
 		this.image[0] = image;
 //		loadImage(this.image, image);
 		
 		initStructure();
 		initDone();
 	}
 	
 	private void initStructure() {
 		addField(image,"image");
 		addField(imageW,"imageW");
 	    addField(imageH,"imageH");
 		addField(roiX,"roiX");
 		addField(roiY,"roiY");
 		addField(roiW,"roiW");
 	    addField(roiH,"roiH");
 	    addField(roi2X,"roi2X");
 		addField(roi2Y,"roi2Y");
 		addField(roi2W,"roi2W");
 	    addField(roi2H,"roi2H");
 	    addField(threshold,"threshold");
 	    addField(sideViewX, "sideViewX");
 	    addField(sideViewY, "sideViewY");
 	    addField(sideViewAmplitudeX,"sideViewAmplitudeX");
 	    addField(sideViewAmplitudeY,"sideViewAmplitudeY");
 	    addField(sideViewConstX, "sideViewConstX");
 	    addField(sideViewConstY, "sideViewConstY");
 	    addField(stdX,"stdX");    	  
 	    addField(stdY,"stdY");
 	    addField(meanX,"meanX");
 	    addField(meanY,"meanY");
 	    addField(stdA,"stdA");
 	    addField(stdB,"stdB");
 	    addField(amplitude2D,"amplitude2D");
 	    addField(angle2D,"angle2D");
 	    addField(const2D, "const2D");
 	    addField(meanXFit, "meanXFit");
 	    addField(stdXFit, "stdXFit");
 	    addField(amplitudeXFit, "amplitudeXFit");
 	    addField(constXFit, "constXFit");
 	    addField(slopeXFit, "slopeXFit");
 	    addField(meanYFit, "meanYFit");
 	    addField(stdYFit, "stdYFit");
 	    addField(amplitudeYFit, "amplitudeYFit");
 	    addField(constYFit, "constYFit");
 	    addField(slopeYFit, "slopeYFit");
 	    addField(thresholdPoints, "thresholdPoints");
 	    addField(performFit, "performFit");
 	    addField(performSmoothing, "performSmoothing");
 	    addField(calculateThreshold, "calculateThreshold");
 	    
 	}
 	
 	/**
 	 * Returns the image which was analyzed.
 	 * 
 	 * @return the original image
 	 */
 	public IMAGE getImage() {
 		return image[0];
 	}
 	
 	/**
 	 * The width of the image.
 	 * 
 	 * @return the width
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public int getImageW() {
 		return imageW[0];
 	}
 
 	/** 
 	 * The height of the image.
 	 * 
 	 * @return the height
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public int getImageH() {
 		return imageH[0];
 	}
 	
 	/**
 	 * Left coordinate of the region of interest.
 	 * 
 	 * @return the left coordinate
 	 */
 	public int getRoiX() {
 		return roiX[0];
 	}
 
 	/**
 	 * Upper coordinate of the region of interest.
 	 * 
 	 * @return the upper coordinate
 	 */
 	public int getRoiY() {
 		return roiY[0];
 	}
 
 	/**
 	 * The width of the region of interest.
 	 * 
 	 * @return the width
 	 */
 	public int getRoiW() {
 		return roiW[0];
 	}
 
 	/**
 	 * The height of the region of interest.
 	 * 
 	 * @return the height
 	 */
 	public int getRoiH() {
 		return roiH[0];
 	}
 	
 	/**
 	 * Left coordinate of the second region of interest.
 	 * 
 	 * @return the left coordinate
 	 */
 	public int getRoi2X() {
 		return roi2X[0];
 	}
 
 	/**
 	 * Upper coordinate of the second region of interest.
 	 * 
 	 * @return the upper coordinate
 	 */
 	public int getRoi2Y() {
 		return roi2Y[0];
 	}
 
 	/**
 	 * The width of the second region of interest.
 	 * 
 	 * @return the width
 	 */
 	public int getRoi2W() {
 		return roi2W[0];
 	}
 
 	/**
 	 * The height of the second region of interest.
 	 * 
 	 * @return the height
 	 */
 	public int getRoi2H() {
 		return roi2H[0];
 	}
 	
 	/**
 	 * The threshold value used for analysis of the image.
 	 * 
 	 * @return the threshold value
 	 */
 	public double getThreshold() {
 		return threshold[0];
 	}
 
 	/**
 	 * Returns the standard deviation of the 2-dimensional intensity image in the
 	 * direction of the "a" axis of the profile (assuming an elliptical profile).
 	 * 
 	 * @return the standard deviation in a direction
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getStdA() {
 		return stdA[0];
 	}
 
 	/**
 	 * Returns the standard deviation of the 2-dimensional intensity image in the
 	 * direction of the "b" axis of the profile (assuming an elliptical profile).
 	 *  
 	 * @return the standard deviation in b direction
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getStdB() {
 		return stdB[0];
 	}
 	
 	/**
 	 * Returns the maximum amplitude of pixel value (as returned by </code>ColorDecoder</code> 
 	 * assigned to this </code>AnalyzedImage</code>) across the entire image.
 	 * Maximum pixel value is amplitude2D plus const2D.
 	 * 
 	 * @return the amplitude
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getAmplitude2D() {
 		return amplitude2D[0];
 	}
 
 	/**
 	 * Returns the angle of rotation of the 2-dimensional intensity profile around
 	 * its center (the angle between x and a and y and b axes).
 	 * 
 	 * @return the angle of rotation of the 2-dimensional intensity profile
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getAngle2D() {
 		return angle2D[0];
 	}
 	
 	/**
 	 * Returns the minimum pixel value (as returned by <code>ColorDecoder</code> 
 	 * assigned to this <code>AnalyzedImage</code>) across the entire image. This
 	 * value indicates the background level of the image.
 	 * 
 	 * @return the constant value of the intensity profile
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double getConst2D() {
 		return const2D[0];
 	}
 
 	/**
 	 * Returns the array representing the side projection of the intensity image
 	 * on the X axis.
 	 * 
 	 * @return the projection on the x axis
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double[] getSideViewX() {
 		double[] result = new double[width];
 		System.arraycopy(sideViewX, 0, result, 0, result.length);
 		return result;
 	}
 
 	/**
 	 * Returns the array representing the side projection of the intensity image
 	 * on the Y axis.
 	 * 
 	 * @return the projection on the y axis
 	 * 
 	 * @see {@link #getImage()}
 	 */
 	public double[] getSideViewY() {
 		double[] result = new double[height];
 		System.arraycopy(sideViewY, 0, result, 0, result.length);
 		return result;
 	}
 
 	/**
 	 * Returns the standard deviation of the side view projection
 	 * of the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the standard deviation
 	 */
 	public double getStdX() {
 		return stdX[0];
 	}
 
 	/**
 	 * Returns the standard deviation of the side view projection
 	 * of the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the standard deviation
 	 */
 	public double getStdY() {
 		return stdY[0];
 	}
 
 	/**
 	 * Returns the mean value of the side view projection of the
 	 * image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the mean value
 	 */
 	public double getMeanX() {
 		return meanX[0];
 	}
 
 	/**
 	 * Returns the mean value of the side view projection of the
 	 * image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the mean value
 	 */
 	public double getMeanY() {
 		return meanY[0];
 	}
 
 	/**
 	 * Returns the amplitude (maximum minus minimum) value of the side view 
 	 * projection of the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the amplitude
 	 */
 	public double getSideViewAmplitudeX() {
 		return sideViewAmplitudeX[0];
 	}
 
 	/**
 	 * Returns the amplitude (maximum minus minimum) value of the side view 
 	 * projection of the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the amplitude
 	 */
 	public double getSideViewAmplitudeY() {
 		return sideViewAmplitudeY[0];
 	}
 	
 	/**
 	 * Returns the constant (minimum) value of the side view projection of
 	 * the image on the x axis. This is calculated from the values
 	 * returned by the {@link #getSideViewX()}.
 	 * 
 	 * @return the constant
 	 */
 	public double getSideViewConstX() {
 		return sideViewConstX[0];
 	}
 	
 	/**
 	 * Returns the constant (minimum) value of the side view projection of
 	 * the image on the y axis. This is calculated from the values
 	 * returned by the {@link #getSideViewY()}.
 	 * 
 	 * @return the constant
 	 */
 	public double getSideViewConstY() {
 		return sideViewConstY[0];
 	}
 	
 	/**
 	 * Returns true if the calculation of threshold was automatic or false if
 	 * threshold was user defined.
 	 * 
 	 * @return true if calculation of threshold is automatic
 	 */
 	public boolean isCalculateThreshold() {
 		return calculateThreshold[0] == 1;
 	}
 	
 	/**
 	 * Returns true if the fitting algorithm was used during analysis.
 	 * 
 	 * @return true if fitting was performed
 	 */
 	public boolean isPerformFit() {
 		return performFit[0] == 1;
 	}
 	
 	/**
 	 * Returns true if the smoothing algorithm was used during analysis.
 	 * 
 	 * @return true if fitting was performed
 	 */
 	public boolean isPerformSmoothing() {
 		return performSmoothing[0] == 1;
 	}
 	
 	/**
 	 * Returns the fitted amplitude in x axis.
 	 *  
 	 * @return
 	 */
 	public double getAmplitudeXFit() {
 		return amplitudeXFit[0];
 	}
 	
 	/**
 	 * Returns the fitted constant in x axis.
 	 * 
 	 * @return
 	 */
 	public double getConstXFit() {
 		return constXFit[0];
 	}
 	
 	/**
 	 * Returns the fitted mean value in x axis.
 	 *  
 	 * @return
 	 */
 	public double getMeanXFit() {
 		return meanXFit[0];
 	}
 	
 	/**
 	 * Returns the fitted std value in x axis.
 	 * 
 	 * @return
 	 */
 	public double getStdXFit() {
 		return stdXFit[0];
 	}
 	
 	/**
 	 * Returns the fitted amplitude in y axis.
 	 *  
 	 * @return
 	 */
 	public double getAmplitudeYFit() {
 		return amplitudeYFit[0];
 	}
 	
 	/**
 	 * Returns the slope of the linear function in the fit.
 	 * 
 	 * @return the slope
 	 */
 	public double getSlopeXFit() {
 		return slopeXFit[0];
 	}
 	
 	/**
 	 * Returns the fitted constant in y axis.
 	 * 
 	 * @return
 	 */
 	public double getConstYFit() {
 		return constYFit[0];
 	}
 	
 	/**
 	 * Returns the fitted mean value in y axis.
 	 *  
 	 * @return
 	 */
 	public double getMeanYFit() {
 		return meanYFit[0];
 	}
 	
 	/**
 	 * Returns the fitted std value in y axis.
 	 * 
 	 * @return
 	 */
 	public double getStdYFit() {
 		return stdYFit[0];
 	}
 	
 	/**
 	 * Returns the slope of the linear function in the fit.
 	 * 
 	 * @return
 	 */
 	public double getSlopeYFit() {
 		return slopeYFit[0];
 	}
 	
 	/**
 	 * Returns the number of points on which the threshold was calculated.
 	 * 
 	 * @return the number of points threshold was calculated on
 	 */
 	public int getThresholdPoints() {
 		return thresholdPoints[0];
 	}
 	
 //	private void loadImage(IMAGE destination, IMAGE input) {
 //		int headerSize = TFormat.getFormatHeaderSize(TFormat.CF_IMAGE);
 //		
 //		byte[] byteArray = new byte[headerSize+Definitions.MAX_SIZE];
 //		byte[] allData = input.toByteArray();
 //		
 //		// TODO workaround for some unusually long allData arrays...
 //		int length = (allData.length > byteArray.length) ? byteArray.length : allData.length;
 //		System.arraycopy(allData, 0, byteArray, 0, length);
 //		
 //		destination.setByteArray(byteArray);
 //		destination.toStruct();
 //		
 //	}
 //	
 //	private IMAGE extractImage(IMAGE source) {
 //		byte[] allData = source.toByteArray();
 //		int headerSize = TFormat.getFormatHeaderSize(TFormat.CF_IMAGE);
 //		byte[] headerArray = new byte[headerSize];
 //		
 //		System.arraycopy(allData, 0, headerArray, 0, headerSize);
 //		
 //		IMAGE result = new IMAGE();
 //		result.setByteArray(headerArray);
 //		result.toStruct();
 //		
 //		// TODO workaround for some unusually long allData arrays...
 //		int length = (result.getFrameHeader().appendedFrameSize < Definitions.MAX_SIZE) ? result.getFrameHeader().appendedFrameSize : Definitions.MAX_SIZE;
 //		byte[] imageBuffer = new byte[length];
 //		System.arraycopy(allData, headerSize, imageBuffer, 0, length);
 //		
 //		result.setImageFrameBuffer(imageBuffer);
 //		
 //		return result;
 //	}
 }