Java ImageProcessor.getWidth方法代碼示例

import ij.process.ImageProcessor; //導入方法依賴的package包/類
/** Gets x and y coordinates of maximum intensity pixel on image. */	
int [] getmaxpositions(ImageProcessor ipp)
{
	int [] results = new int [2];
	results[0]=0;
	results[1]=0;

	double s;
	double smax=Double.MIN_VALUE;
	
	for (int i=0;i<ipp.getWidth();i++)
	{
		for (int j=0;j<ipp.getHeight();j++)
		{
			s=ipp.get(i, j);	
			if (s>smax)
			{
				smax=s;
				results[0]=i;
				results[1]=j;
			}
		}
	}
	return results;		
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
/** 
* some parts from ij.plugin.FFT code
*  
* */
  ImageProcessor pad(ImageProcessor ip) 
  {
      int originalWidth = ip.getWidth();
      int originalHeight = ip.getHeight();
      int maxN = Math.max(originalWidth, originalHeight);
      int i = 2;
      while(i<maxN) i *= 2;
      if (i==maxN && originalWidth==originalHeight) 
      {
      
          return ip;
      }
      maxN = i;
 
      ImageStatistics stats = ImageStatistics.getStatistics(ip, ImageStatistics.MEAN, null);
      ImageProcessor ip2 = ip.createProcessor(maxN, maxN);
      ip2.setValue(stats.mean);
      ip2.fill();
      ip2.insert(ip, 0, 0);

      Undo.reset();
      //new ImagePlus("padded", ip2.duplicate()).show();
      return ip2;
  }
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
ImageProcessor padzeros(ImageProcessor ip) 
{
    int originalWidth = ip.getWidth();
    int originalHeight = ip.getHeight();
    int maxN = Math.max(originalWidth, originalHeight);
    int i = 2;
    while(i<maxN) i *= 2;
    if (i==maxN && originalWidth==originalHeight) 
    {
    
        return ip;
    }
    maxN = i;
   
    ImageProcessor ip2 = ip.createProcessor(maxN, maxN);
    ip2.setValue(0);
    ip2.fill();
    ip2.insert(ip, 0, 0);
  
    Undo.reset();
    //new ImagePlus("padded", ip2.duplicate()).show();
    return ip2;
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
public void applyTo(ImageProcessor ip) {
	M = ip.getWidth();
	N = ip.getHeight();
	FilterOperator fm = null;
	if (ip instanceof ColorProcessor) {
		switch (params.colorMode) {
		case SeparateChannels : 	fm = new FilterColorSeparate(); break;
		case BrightnessGradient : 	fm = new FilterColorBrightnessGradient(); break;
		case ColorGradient : 	  	fm = new FilterColorColorGradient(); break;
		}
	}
	else {
		fm = new FilterScalar();
	}
		fm.filter(ip);
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
/**
 * This is a brute-force drawing method which simply marks all
 * image pixels that are sufficiently close to the HoughLine hl.
 * The drawing color for ip must be previously set.
 * @param ip The ImageProcessor to draw to.
 * @param thickness The thickness of the lines to be drawn.
 */
public void draw(ImageProcessor ip, double thickness) {
	final int w = ip.getWidth();
	final int h = ip.getHeight();
	final double dmax = 0.5 * thickness;
	for (int u = 0; u < w; u++) {
		for (int v = 0; v < h; v++) {
			// get the distance between (u,v) and the line hl:
			double d = Math.abs(this.getDistance(u, v));
			if (d <= dmax) {
				ip.drawPixel(u, v);
			}
		}
	}
	
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
/**
 * Fills the image {@code R} from the source image 
 * {@code I} (referenced by {@code this} object).
 * The image {@code R} is extracted from a quadrilateral patch of the source image,
 * defined by the transformation of the boundary of {@code R} by {@code T(x)}.
 * Grayscale and color images my not be mixed (i.e., {@code R} must be of the same type as {@code I}).
 * @param R the image to be filled.
 * @param T a {@link LinearMapping} object.
 */	
public void extractImage(ImageProcessor R, LinearMapping T) {
	int prevInterpolationMethod = I.getInterpolationMethod();
	// save current interpolation method
	I.setInterpolationMethod(interpolationMethod);
	
	ImageAccessor iaI = ImageAccessor.create(I);
	ImageAccessor iaR = ImageAccessor.create(R);

	int wT = R.getWidth();
	int hT = R.getHeight();
	for (int u = 0; u < wT; u++) {
		for (int v = 0; v < hT; v++) {
			Point2D uv = new Point(u, v);
			Point2D xy = T.applyTo(uv);
			float[] val = iaI.getPix(xy.getX(), xy.getY());
			iaR.setPix(u, v, val);
		}
	}
	// restore interpolation method
	I.setInterpolationMethod(prevInterpolationMethod);
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
public static double moment(ImageProcessor I, int p, int q) {
	double Mpq = 0.0;
	for (int v = 0; v < I.getHeight(); v++) { 
		for (int u = 0; u < I.getWidth(); u++) { 
			if (I.getPixel(u, v) != BACKGROUND) {
				Mpq+= Math.pow(u, p) * Math.pow(v, q);
			}
		}
	}
	return Mpq;
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
public static double centralMoment(ImageProcessor I, int p, int q) {
	double m00  = moment(I, 0, 0);	// region area
	double xCtr = moment(I, 1, 0) / m00;
	double yCtr = moment(I, 0, 1) / m00;
	double cMpq = 0.0;
	for (int v = 0; v < I.getHeight(); v++) { 
		for (int u = 0; u < I.getWidth(); u++) {
			if (I.getPixel(u, v) != BACKGROUND) { 
				cMpq+= Math.pow(u - xCtr, p) * Math.pow(v - yCtr, q);
			}
		}
	}
	return cMpq;
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
/**
 * Transforms the source image (contained in "srcInterpol") to the "target"
 * image using this geometric mapping and the specified pixel interpolator.
 * 
 * @param sourceAcc accessor to the source image
 * @param targetAcc accessor to the target image
 */
public void applyTo(ImageAccessor sourceAcc, ImageAccessor targetAcc) {
	Mapping invMap = this.getInverse(); // get inverse mapping
	ImageProcessor target = targetAcc.getProcessor();
	final int w = target.getWidth();
	final int h = target.getHeight();
	for (int v = 0; v < h; v++) {
		for (int u = 0; u < w; u++) {
			Point2D sourcePt = invMap.applyTo(new Point(u, v));
			float[] val = sourceAcc.getPix(sourcePt.getX(),sourcePt.getY());
			targetAcc.setPix(u, v, val);
		}
	}
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
private void initialize(ImageProcessor ip) {
		M = ip.getWidth(); 
		N = ip.getHeight(); 
		K = (ip instanceof ColorProcessor) ? 3 : 1;
		I  = new float[K][M][N];
		Dx  = new float[K][M][N];
		Dy  = new float[K][M][N];
		G = new float[3][M][N];
		A = new float[3][M][N];
		B = new float[K][M][N];
//		Hk = new float[3][M][N];

		if (ip instanceof ColorProcessor) {
			final int[] pixel = new int[K];	
			for (int u = 0; u < M; u++) {
				for (int v = 0; v < N; v++) {
					ip.getPixel(u, v, pixel);
					for (int k = 0; k < K; k++) {
						float c = pixel[k];
						I[k][u][v] = params.useLinearRgb ? srgbToRgb(c) : c;
					}
				}
			}
		}
		else {	// 8-bit, 16-bit or 32-bit (float) processor
			for (int u = 0; u < M; u++) {
				for (int v = 0; v < N; v++) {
					I[0][u][v] = ip.getf(u,v);
				}
			}
		}
		getImageMinMax();
	}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
public CannyEdgeDetector(ImageProcessor I, Parameters params) {
		if (params.isInValid()) throw new IllegalArgumentException();
		this.params = params;
//		this.I = I;
		M = I.getWidth();
		N = I.getHeight();
		makeGradientsAndMagnitude(I);
	}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
private ImageAccessor(ImageProcessor ip, OutOfBoundsStrategy obs, InterpolationMethod ipm) {
	this.width  = ip.getWidth();
	this.height = ip.getHeight();
	this.outOfBoundsStrategy = (obs != null) ? obs : DefaultOutOfBoundsStrategy;
	this.interpolationMethod = (ipm != null) ? ipm : DefaultInterpolationMethod;
	this.indexer = PixelIndexer.create(width, height, outOfBoundsStrategy);
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
private void drawLine(int x, int y, int x2, int y2, ImageProcessor ip, long time) {
    int w = x2 - x ;
    int h = y2 - y ;
    int dx1, dy1, dx2, dy2;

    dx1 = (w < 0) ? -1 : 1;
    dy1 = (h < 0) ? -1 : 1;
    dx2 = (w < 0) ? -1 : 1;
    dy2 = (h < 0) ? -1 : 1;

    int longest = Math.abs(w) ;
    int shortest = Math.abs(h) ;
    if (!(longest > shortest)) {
        longest = Math.abs(h) ;
        shortest = Math.abs(w) ;
        dy2 = h < 0 ? -1: 1;
        dx2 = 0 ;
    }
    int numerator = longest >> 1;
    for (int i = 0; i <= longest; i++) {
        if(x > 0 && y > 0 && x < ip.getWidth() && y < ip.getHeight())
            ip.setf(x,y, ip.getf(x, y) + time);
        numerator += shortest ;
        if (!(numerator<longest)) {
            numerator -= longest ;
            x += dx1 ;
            y += dy1 ;
        } else {
            x += dx2 ;
            y += dy2 ;
        }
    }
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
private void fillRectangle(Rectangle rectangle, ImageProcessor ip, long time) {
    int x = (int)rectangle.getX();
    int y = (int)rectangle.getY();
    int w = (int)rectangle.getWidth();
    int h = (int)rectangle.getHeight();

    for(int i = x; i < x + w; i++) {
        for(int j = y; j < y + h; j++) {
            if(i >=0 && j >= 0 && i < ip.getWidth() && j < ip.getHeight())
                ip.setf(i, j, ip.getf(i, j) + time);
        }
    }
}
 

import ij.process.ImageProcessor; //導入方法依賴的package包/類
@Override
public double getFOVSize() {
    ImageProcessor ip = stack.getProcessor(count);
    return getObjectSpacePixelSize()*getObjectSpacePixelSize()*ip.getWidth()*ip.getHeight();
}