imagedata.java

客户端浏览医学图像的jsp源代码。可用于临床工作站。

   * @see   java.awt.Color#HSBtoRGB(float, float, float)
   */
  private int hue2RGB(float hue) {
	  int r = 0, g = 0, b = 0;

    float h = (hue - (float)Math.floor(hue)) * 6.0f;
    float f = h - (float)java.lang.Math.floor(h);
    float q = 1.0f - f;

    switch ((int) h) {
	    case 0:
        r = 255;
		    g = (int) (f * 255.0f + 0.5f);
		    b = 0;
		    break;
	    case 1:
		    r = (int) (q * 255.0f + 0.5f);
		    g = 255;
		    b = 0;
		    break;
	    case 2:
		    r = 0;
		    g = 255;
		    b = (int) (f * 255.0f + 0.5f);
		    break;
	    case 3:
		    r = 0;
		    g = (int) (q * 255.0f + 0.5f);
		    b = 255;
		    break;
	    case 4:
		    r = (int) (f * 255.0f + 0.5f);
		    g = 0;
		    b = 255;
		    break;
	    case 5:
		    r = 255;
		    g = 0;
		    b = (int) (q * 255.0f + 0.5f);
		    break;
    }
	  return 0xff000000 | (r << 16) | (g << 8) | (b << 0);
  }

  private Image getImage() {
    // 僺僋僙儖抣傪曄峏偟偰丄Image傪曉偡丅
    source.newPixels();
    return image;
/*
    // 僀儊乕僕傪嶌傝曉偡丅
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    return toolkit.createImage(new MemoryImageSource(width, height, pixel, 0, width));
*/
  }

   public Image asdf(){
     return img;
   }

  // 尰嵼偺僨僼僅儖僩忬懺偺僀儊乕僕傪曉偡
  public Image getDefaultImage() {
    contrast();
    return getImage();
  }

  // 敀崟,僇儔乕偺忬懺傪曉偡(僇儔乕偺偲偒true)
  public boolean color() {
    return rgbMode;
  }

  // WW/WL傪僀儊乕僕偵斀塮偝偣傞
  public Image wwANDwl(int argWW, int argWL) {
    ww = argWW;
    wl = argWL;
    contrast();
    return getImage();
  }

  // WW/WL偺抣傪僙僢僩偡傞
  public void setWwWl(int argWW, int argWL) {
    ww = argWW;
    wl = argWL;
  }

  // Default偐傜偺嵎傪摼偰丄WW/WL傪僀儊乕僕偵斀塮偝偣傞
  public Image getImageWWWL2Current(int argWW, int argWL) {
    ww = defaultWW + argWW;
    wl = defaultWL + argWL;
    contrast();
    return getImage();
  }

  // WW乛WL傪曉偡
  public int getWW() {
    return ww;
  }
  public int getWL() {
    return wl;
  }

  // 僨僼僅儖僩偺WW乛WL傪曉偡
  public int getDefaultWW() {
    return defaultWW;
  }
  public int getDefaultWL() {
    return defaultWL;
  }

  // 僀儊乕僕暆,崅偝傪曉偡
  public int getWidth() {
    return width;
  }
  public int getHeight() {
    return height;
  }

  // Pixel抣偺嵟戝抣丄嵟彫抣傪曉偡
  public int getPixelMin() {
    return pixelMin;
  }
  public int getPixelMax() {
    return pixelMax;
  }

  // 僱僈億僕斀揮
  public void inverse() {
    inv = !inv;
  }
  public void setInverse(boolean flag) {
    inv = flag;
  }
/*
  public Image inverse() {
    inv = !inv;
    contrast();
    return getImage();
  }
*/

  // 媅帡僇儔乕壔
  public void setColor(boolean flag) {
    blackANDwhite = !flag;
  }
  public void changeColor() {
    blackANDwhite = !blackANDwhite;
  }

  // 弶婜忬懺偵栠偡丅(WW/WL埲奜)
  public void setDefaultPixel() {
    System.arraycopy(defaultPixel, 0, orgPixel, 0, pixLength);
    width =  defaultWidth;
    height = defaultHeight;

    blackANDwhite = true;				// 敀崟夋憸偺帪true
    inv = false;								// 僱僈億僕斀揮
  }

  // 90搙夋憸夞揮
  public void rotateL() {
    int[] tmpPixel = new int[orgPixel.length];
    int temp;

    System.arraycopy(orgPixel, 0, tmpPixel, 0, tmpPixel.length);
    for(int i=0; i < height; i++) {
      for(int j=0; j < width; j++) {
        orgPixel[(width - j -1) * height + i] = tmpPixel[i * width + j];
      }
    }
    temp = width;
    width = height;
    height = temp;
  }
  public void rotateR() {
    int[] tmpPixel = new int[orgPixel.length];
    int temp;

    System.arraycopy(orgPixel, 0, tmpPixel, 0, tmpPixel.length);
    for(int i=0; i < height; i++) {
      for(int j=0; j < width; j++) {
        orgPixel[j * height + (height - i -1)] = tmpPixel[i * width + j];
      }
    }
    temp = width;
    width = height;
    height = temp;
  }

  // 嵍塃夋憸斀揮
  public void flipLR() {
    int[] tmpPixel = new int[orgPixel.length];
    int temp1, temp2;

    System.arraycopy(orgPixel, 0, tmpPixel, 0, tmpPixel.length);
    for(int i=0; i < height; i++) {
      temp1 = i * width;
      temp2 = temp1 + width -1;
      for(int j=0; j < width; j++) {
        orgPixel[temp2 - j] = tmpPixel[temp1 + j];
      }
    }
  }

  // 忋壓夋憸斀揮
  public void flipUD() {
    int[] tmpPixel = new int[orgPixel.length];
    int temp1, temp2;

    System.arraycopy(orgPixel, 0, tmpPixel, 0, tmpPixel.length);
    for(int i=0; i < height; i++) {
      temp1 = (height - i -1) * width;
      temp2 = i * width;
      for(int j=0; j < width; j++) {
        orgPixel[temp1 + j] = tmpPixel[temp2 + j];
      }
    }
  }

  // 僸僗僩僌儔儉偺嶌惉
  private void makeHistogram()
  {
    // 弶婜壔
    for(int i=0; i<256; i++)
    	histogram[i] = 0;
    histMax = 0;

    // 僸僗僩僌儔儉偺嶌惉
    for(int i=0; i<pixel.length; i++){
      int data = (0x000000ff & pixel[i]);
      histogram[data]++;
    }

    // 僸僗僩僌儔儉偺嵟戝悢傪媮傔傞
    for(int i=0; i<256; i++){
      if(histMax < histogram[i])
      	histMax = histogram[i];
    }
  }

  // 僸僗僩僌儔儉,僸僗僩僌儔儉偺嵟戝抣傪曉偡
  public int[] getHistogram()
  {
    return histogram;
  }

  public int getHistMax()
  {
    return histMax;
  }

  // 僸僗僩僌儔儉偺曗惓傪偡傞
  public Image reviseHistogram()
  {
    calcRevisedHistogram();
    return getImage();
  }

  // 僸僗僩僌儔儉偺曗惓傪寁嶼偡傞
  private void calcRevisedHistogram(){
    double[]	aFreq 				= new double[256];        // 椵愊搙悢
    int				sum   				= 0;                      // 僸僗僩僌儔儉偺榓
    double		allPixelsInv; 				                  // 1./慡夋慺悢
    double		vmin;                 				          // 椵愊搙悢偺嵟彫抣
    double		vminInv;
    int[]			fixed 				= new int[256];           // 曗惓偝傟偨僸僗僩僌儔儉

    // 僸僗僩僌儔儉傪嶌傞
    makeHistogram();

    for(int i=0; i<pixel.length; i++){
      pixel[i] = (0x000000ff & pixel[i]); 						// 偲傝偁偊偢敀崟偩偗峫偊傞
    }

    // 椵愊搙悢偺寁嶼
    allPixelsInv = 1. / (height * width);
    for(int i=0; i<256; i++){
      sum += histogram[i];
      aFreq[i] = (double)sum * allPixelsInv;
    }

    // 僸僗僩僌儔儉偺曗惓
    vmin = aFreq[0];
    vminInv = (double)255. / (1.- vmin);
    for(int i=0; i<256; i++){
      fixed[i] = (int)((aFreq[i] - vmin) * vminInv);
    }
    for(int i=0; i<pixel.length; i++){
      pixel[i] = ((255 << 24)
      				  | (fixed[pixel[i]] << 16)
                | (fixed[pixel[i]] << 8)
                | fixed[pixel[i]]);
    }
  }
}