Ejemplo n.º 1
0
 private Point2D getImageOffset(ImageListViewCell cell) {
   Point2D imgSize = getScaledImageSize(cell);
   Dimension latestSize = cell.getLatestSize();
   return new Point2D.Double(
       (latestSize.width + 2 * cell.getCenterOffset().getX() - (int) imgSize.getX()) / 2,
       (latestSize.height + 2 * cell.getCenterOffset().getY() - (int) imgSize.getY()) / 2);
 }
Ejemplo n.º 2
0
  @Override
  public void paintCellROIs(ImageListViewCellPaintEvent evt) {
    ImageListViewCell cell = evt.getSource();
    Graphics2D g2d = (Graphics2D) evt.getGc().getGraphics2D().create();
    Graphics2D userGraphics = (Graphics2D) g2d.create();
    Point2D imageOffset = getImageOffset(cell);

    userGraphics.transform(
        AffineTransform.getTranslateInstance(imageOffset.getX(), imageOffset.getY()));
    cell.getRoiDrawingViewer().paint(new GC(userGraphics));
  }
Ejemplo n.º 3
0
  protected BufferedImage getWindowedImage(ImageListViewCell displayedCell) {
    BufferedImage windowedImage = tryWindowRawImage(displayedCell);
    if (windowedImage != null) {
      return windowedImage;
    } else {
      // TODO: caching of windowed images, probably using
      //       displayedCell.getDisplayedModelElement().getImageKey() and the windowing parameters
      // as the cache key
      BufferedImage srcImg = displayedCell.getDisplayedModelElement().getImage().getBufferedImage();
      // TODO: use the model element's RawImage instead of the BufferedImage when possible
      /// *
      if (srcImg.getColorModel().getColorSpace().getType() == ColorSpace.TYPE_GRAY) {
        try {
          windowedImage =
              windowMonochrome(
                  displayedCell,
                  srcImg,
                  displayedCell.getWindowLocation(),
                  displayedCell.getWindowWidth());
        } catch (IllegalArgumentException e) {
          // TODO: store message somehow so ILVInitStateController can render it
          //      either into ILVModelElt#errorInfo (in which case errorInfo would be a warning for
          // initialized elements),
          //      or, probably better, into a new attribute in the cell
          logger.warn("couldn't window grayscale image: " + e.getLocalizedMessage() /*, e*/);
          return srcImg;
        }
      } else if (srcImg.getColorModel().getColorSpace().isCS_sRGB()) {
        try {
          windowedImage =
              windowRGB(srcImg, displayedCell.getWindowLocation(), displayedCell.getWindowWidth());
        } catch (IllegalArgumentException e) {
          // TODO: store message somehow so ILVInitStateController can render it (see
          // windowMonochrome above)
          logger.warn("couldn't window RGB image: " + e.getLocalizedMessage() /*, e*/);
          return srcImg;
        }
      } else {
        throw new IllegalStateException(
            "don't know how to window image with color space "
                + srcImg.getColorModel().getColorSpace());
        // TODO: do something cleverer here? Like, create windowedImage
        //    with a color space that's "compatible" to srcImg (using
        //    some createCompatibleImage() method in BufferedImage or elsewhere),
        //    window all bands of that, and let the JRE figure out how to draw the result?
      }
      // */
      // windowedImage = windowWithRasterOp(srcImg, windowLocation, windowWidth);
      // windowedImage = srcImg;

      return windowedImage;
    }
  }
Ejemplo n.º 4
0
  private BufferedImage windowMonochrome(
      ImageListViewCell displayedCell,
      BufferedImage srcImg,
      float windowLocation,
      float windowWidth) {
    BufferedImage destImg =
        new BufferedImage(srcImg.getWidth(), srcImg.getHeight(), BufferedImage.TYPE_INT_RGB);

    boolean isSigned = false;
    int minValue = 0;
    {
      // hack: try to determine signedness and minValue from DICOM metadata if available --
      // the BufferedImage's metadata don't contain that information reliably.
      // Only works for some special cases
      ImageListViewModelElement elt = displayedCell.getDisplayedModelElement();
      if (elt instanceof DicomImageListViewModelElement) {
        DicomImageListViewModelElement delt = (DicomImageListViewModelElement) elt;
        DicomObject imgMetadata = delt.getDicomImageMetaData();
        int bitsAllocated = imgMetadata.getInt(Tag.BitsAllocated);
        isSigned = (1 == imgMetadata.getInt(Tag.PixelRepresentation));
        if (isSigned && (bitsAllocated > 0)) {
          minValue = -(1 << (bitsAllocated - 1));
        }
      }
    }

    final int windowedImageGrayscalesCount = 256; // for BufferedImage.TYPE_INT_RGB
    float scale = windowedImageGrayscalesCount / windowWidth;
    float offset = (windowWidth / 2 - windowLocation) * scale;
    if (!(srcImg.getColorModel().getColorSpace().getType() == ColorSpace.TYPE_GRAY)) {
      throw new IllegalArgumentException("source image must be grayscales");
    }
    Raster srcRaster = srcImg.getRaster();
    if (srcRaster.getNumBands() != 1) {
      throw new IllegalArgumentException(
          "grayscale source image must have one color band, but has "
              + srcRaster.getNumBands()
              + "??");
    }
    WritableRaster resultRaster = destImg.getRaster();
    for (int x = 0; x < srcImg.getWidth(); x++) {
      for (int y = 0; y < srcImg.getHeight(); y++) {
        int srcGrayValue = srcRaster.getSample(x, y, 0);
        if (isSigned) {
          srcGrayValue = (int) (short) srcGrayValue; // will only work for 16-bit signed...
        }
        float destGrayValue = scale * srcGrayValue + offset;
        // clamp
        if (destGrayValue < 0) {
          destGrayValue = 0;
        } else if (destGrayValue >= windowedImageGrayscalesCount) {
          destGrayValue = windowedImageGrayscalesCount - 1;
        }
        resultRaster.setSample(x, y, 0, destGrayValue);
        resultRaster.setSample(x, y, 1, destGrayValue);
        resultRaster.setSample(x, y, 2, destGrayValue);
      }
    }
    return destImg;
  }
Ejemplo n.º 5
0
  @Override
  public void printLUTIntoCell(
      ImageListViewCellPaintEvent e,
      int lutWidth,
      int lutHeight,
      int intervals,
      Point2D lutPosition,
      Point2D textPosition,
      Color textColor,
      List<String> scaleList) {
    ImageListViewCell cell = e.getSource();
    LookupTable lut = cell.getLookupTable();
    Graphics2D g2d = (Graphics2D) e.getGc().getGraphics2D().create();

    Graphics2D userGraphics = (Graphics2D) g2d.create();

    // draw lut values
    g2d.setColor(textColor);
    int posx = (int) textPosition.getX();
    int posy = (int) textPosition.getY() - 5;
    int lineHeight = lutHeight / intervals;

    for (String scale : scaleList) {
      g2d.drawString(scale, posx - scale.length() * 10, posy);
      posy += lineHeight;
    }
    // draw lut legend
    BufferedImage lutImage =
        scaleImage(
            rotateImage(LutController.getLutMap().get(lut.getName()).getBimg()),
            lutWidth,
            lutHeight);

    // create bordered image
    BufferedImage borderedImage =
        new BufferedImage(lutImage.getWidth() + 2, lutImage.getHeight() + 2, lutImage.getType());
    Graphics2D graphic = borderedImage.createGraphics();
    graphic.setColor(Color.GRAY);
    graphic.fillRect(0, 0, borderedImage.getWidth(), borderedImage.getHeight());
    graphic.drawImage(lutImage, 1, 1, null);

    userGraphics.drawImage(borderedImage, null, (int) lutPosition.getX(), (int) lutPosition.getY());
  }
Ejemplo n.º 6
0
  private BufferedImage tryWindowRawImage(ImageListViewCell displayedCell) {
    ImageListViewModelElement elt = displayedCell.getDisplayedModelElement();
    ViskitImage img = elt.getImage();
    if (!(img.hasRawImage() && img.isRawImagePreferable())) {
      return null;
    }

    // logger.debug("trying to create windowed BufferedImage for: " + elt.getImageKey());

    float[] pixelTransform =
        new float[] {1, 0}; // compute the complete raw input => output pixel transformation in here

    // rescale/slope tags
    if (elt instanceof DicomImageListViewModelElement) {
      try {
        DicomImageListViewModelElement delt = (DicomImageListViewModelElement) elt;
        if (delt.getDicomImageMetaData().contains(Tag.RescaleSlope)
            && delt.getDicomImageMetaData().contains(Tag.RescaleIntercept)) {
          float rscSlope = delt.getDicomImageMetaData().getFloat(Tag.RescaleSlope);
          float rscIntercept = delt.getDicomImageMetaData().getFloat(Tag.RescaleIntercept);
          LinAlg.matrMult1D(new float[] {rscSlope, rscIntercept}, pixelTransform, pixelTransform);
        }
      } catch (Exception e) {
        // ignore -- no error
      }
    }

    // normalization to [0,1]
    FloatRange pxValuesRange = img.getMaximumPixelValuesRange();
    float minGrayvalue = pxValuesRange.getMin();
    float nGrayvalues = pxValuesRange.getDelta();
    LinAlg.matrMult1D(
        new float[] {1.0F / nGrayvalues, -minGrayvalue / nGrayvalues},
        pixelTransform,
        pixelTransform);

    // window level/width
    float wl = (displayedCell.getWindowLocation() - minGrayvalue) / nGrayvalues;
    float ww = displayedCell.getWindowWidth() / nGrayvalues;
    float scale = 1F / ww;
    float offset = (ww / 2 - wl) * scale;
    LinAlg.matrMult1D(new float[] {scale, offset}, pixelTransform, pixelTransform);

    LookupTable lut = displayedCell.getLookupTable();
    /*if (displayedCell.isOutputGrayscaleRGBs()) {
        //TODO: perform 12-bit grayscale output in J2D as well
    } else */ if (lut != null) {
      // transformation to output LUT index
      int lutLength = lut.getRGBAValues().limit() / 4;
      LinAlg.matrMult1D(new float[] {lutLength, 0}, pixelTransform, pixelTransform);
    } else {
      // transformation to output grayscale range ( [0,256) )
      LinAlg.matrMult1D(new float[] {256, 0}, pixelTransform, pixelTransform);
    }

    RawImage rimg = img.getRawImage();
    if (rimg.getPixelFormat() != RawImage.PIXEL_FORMAT_LUMINANCE) {
      return null; // can't window raw RGB images for now
    } else {
      switch (rimg.getPixelType()) {
          // will only window RawImages whose pixelData buffer is a ShortBuffer for now
        case RawImage.PIXEL_TYPE_UNSIGNED_BYTE:
        case RawImage.PIXEL_TYPE_SIGNED_12BIT:
        case RawImage.PIXEL_TYPE_SIGNED_16BIT:
        case RawImage.PIXEL_TYPE_UNSIGNED_12BIT:
          {
            // TODO: maybe reuse BufferedImages of the same size to relieve the GC
            float txscale = pixelTransform[0];
            float txoffset = pixelTransform[1];
            ShortBuffer srcBuffer = (ShortBuffer) rimg.getPixelData();
            int w = rimg.getWidth();
            int h = rimg.getHeight();
            BufferedImage result = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            WritableRaster resultRaster = result.getRaster();
            if (lut != null) {
              windowLUTShort(srcBuffer, w, h, txscale, txoffset, lut, resultRaster);
            } else {
              windowGrayShort(srcBuffer, w, h, txscale, txoffset, resultRaster);
            }
            return result;
          }
          // ...and IntBuffer
        case RawImage.PIXEL_TYPE_UNSIGNED_16BIT:
          {
            // TODO: maybe reuse BufferedImages of the same size to relieve the GC
            float txscale = pixelTransform[0];
            float txoffset = pixelTransform[1];
            IntBuffer srcBuffer = (IntBuffer) rimg.getPixelData();
            int w = rimg.getWidth();
            int h = rimg.getHeight();
            BufferedImage result = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            WritableRaster resultRaster = result.getRaster();
            if (lut != null) {
              windowLUTInt(srcBuffer, w, h, txscale, txoffset, lut, resultRaster);
            } else {
              windowGrayInt(srcBuffer, w, h, txscale, txoffset, resultRaster);
            }
            return result;
          }
        default:
          return null;
      }
    }
  }
Ejemplo n.º 7
0
 protected AffineTransform getDicomToUiTransform(ImageListViewCell cell) {
   double z = cell.getScale();
   return AffineTransform.getScaleInstance(z, z);
 }
Ejemplo n.º 8
0
 private Point2D getScaledImageSize(ImageListViewCell cell) {
   ViskitImage img = cell.getDisplayedModelElement().getImage();
   return getDicomToUiTransform(cell)
       .transform(new Point2D.Double(img.getWidth(), img.getHeight()), null);
 }