コード例 #1
0
  /** Create a lookup table to be used in the case of byte data. */
  private void createLUT() {
    // Allocate memory for the data array references.
    int numBands = abscissas.length;
    byte[][] data = new byte[numBands][];

    // Generate the data for each band.
    for (int band = 0; band < numBands; band++) {
      // Allocate memory for this band.
      data[band] = new byte[256];

      // Cache the references to avoid extra indexing.
      byte[] table = data[band];
      float[] x = abscissas[band];
      float[] a = slopes[band];
      float[] b = intercepts[band];
      float yL = minOrdinates[band];
      float yH = maxOrdinates[band];

      // Initialize the lookup table data.
      for (int value = 0; value < 256; value++) {
        table[value] = ImageUtil.clampRoundByte(binarySearch(x, yL, yH, a, b, value));
      }
    }

    // Construct the lookup table.
    lut = new LookupTableJAI(data);
  }
コード例 #2
0
  // package accessible for SubsampleBinaryToGrayOpImage4x4, etc...
  static ImageLayout layoutHelper(
      RenderedImage source, float scaleX, float scaleY, ImageLayout il, Map config) {

    ImageLayout layout = (il == null) ? new ImageLayout() : (ImageLayout) il.clone();

    // to compute dWidth and dHeight
    // fTol and dWi, dHi must be the same as in computeDestInfo(..)
    // due to static method, a few lines of coding are repeated
    int srcWidth = source.getWidth();
    int srcHeight = source.getHeight();

    float f_dw = scaleX * srcWidth;
    float f_dh = scaleY * srcHeight;
    float fTol = .1F * Math.min(scaleX / (f_dw + 1.0F), scaleY / (f_dh + 1.0F));

    int dWi = (int) (f_dw);
    int dHi = (int) (f_dh);

    // let it be int in the almost int case
    //   espacially in the true int case with float calculation errors
    if (Math.abs(Math.round(f_dw) - f_dw) < fTol) {
      dWi = Math.round(f_dw);
    }

    if (Math.abs(Math.round(f_dh) - f_dh) < fTol) {
      dHi = Math.round(f_dh);
    }

    // Set the top left coordinate of the destination
    layout.setMinX((int) (scaleX * source.getMinX()));
    layout.setMinY((int) (scaleY * source.getMinY()));

    layout.setWidth(dWi);
    layout.setHeight(dHi);

    // sample model
    SampleModel sm = layout.getSampleModel(null);

    if (sm == null
        || sm.getDataType() != DataBuffer.TYPE_BYTE
        || !(sm instanceof PixelInterleavedSampleModel
            || sm instanceof SinglePixelPackedSampleModel && sm.getNumBands() == 1)) {

      // Width and height will be corrected in OpImage.layoutHelper
      sm = new PixelInterleavedSampleModel(DataBuffer.TYPE_BYTE, 1, 1, 1, 1, new int[] {0});
    }

    layout.setSampleModel(sm);

    ColorModel cm = layout.getColorModel(null);

    if (cm == null || !JDKWorkarounds.areCompatibleDataModels(sm, cm)) {

      layout.setColorModel(ImageUtil.getCompatibleColorModel(sm, config));
    }

    return layout;
  }
コード例 #3
0
  private synchronized void initByteTable() {

    if (byteTable != null) {
      return;
    }

    /* Initialize byteTable. */
    byteTable = new byte[0x100][0x100];
    for (int j = 0; j < 0x100; j++) {
      byte[] t = byteTable[j];
      for (int i = 0; i < 0x100; i++) {
        t[i] = ImageUtil.clampBytePositive(j + i);
      }
    }
  }
コード例 #4
0
  private void computeRectUShort(RasterAccessor src, RasterAccessor dst) {
    int dstWidth = dst.getWidth();
    int dstHeight = dst.getHeight();
    int dstBands = dst.getNumBands();

    int dstLineStride = dst.getScanlineStride();
    int dstPixelStride = dst.getPixelStride();
    int[] dstBandOffsets = dst.getBandOffsets();
    short[][] dstData = dst.getShortDataArrays();

    int srcLineStride = src.getScanlineStride();
    int srcPixelStride = src.getPixelStride();
    int[] srcBandOffsets = src.getBandOffsets();
    short[][] srcData = src.getShortDataArrays();

    for (int b = 0; b < dstBands; b++) {
      short[] d = dstData[b];
      short[] s = srcData[b];

      int dstLineOffset = dstBandOffsets[b];
      int srcLineOffset = srcBandOffsets[b];

      // Cache the references to avoid extra indexing.
      float[] x = abscissas[b];
      float[] gain = slopes[b];
      float[] bias = intercepts[b];
      float yL = minOrdinates[b];
      float yH = maxOrdinates[b];

      for (int h = 0; h < dstHeight; h++) {
        int dstPixelOffset = dstLineOffset;
        int srcPixelOffset = srcLineOffset;

        dstLineOffset += dstLineStride;
        srcLineOffset += srcLineStride;

        for (int w = 0; w < dstWidth; w++) {
          d[dstPixelOffset] =
              ImageUtil.clampRoundUShort(
                  binarySearch(x, yL, yH, gain, bias, s[srcPixelOffset] & 0xFFFF));

          dstPixelOffset += dstPixelStride;
          srcPixelOffset += srcPixelStride;
        }
      }
    }
  }
コード例 #5
0
  private void computeRectUShort(RasterAccessor[] srcs, RasterAccessor dst) {
    int dstWidth = dst.getWidth();
    int dstHeight = dst.getHeight();
    int dstBands = dst.getNumBands();

    int dstLineStride = dst.getScanlineStride();
    int dstPixelStride = dst.getPixelStride();
    int[] dstBandOffsets = dst.getBandOffsets();
    short[][] dstData = dst.getShortDataArrays();

    int numSrcs = getNumSources();

    for (int i = 0; i < numSrcs; i++) {
      RasterAccessor src = srcs[i];
      int srcLineStride = src.getScanlineStride();
      int srcPixelStride = src.getPixelStride();
      int[] srcBandOffsets = src.getBandOffsets();
      short[][] srcData = src.getShortDataArrays();

      for (int b = 0; b < dstBands; b++) {
        int dstLineOffset = dstBandOffsets[b];
        int srcLineOffset = srcBandOffsets[b];

        short[] d = dstData[b];
        short[] s = srcData[b];

        for (int h = 0; h < dstHeight; h++) {
          int dstPixelOffset = dstLineOffset;
          int srcPixelOffset = srcLineOffset;

          dstLineOffset += dstLineStride;
          srcLineOffset += srcLineStride;

          for (int w = 0; w < dstWidth; w++) {
            d[dstPixelOffset] =
                ImageUtil.clampUShortPositive(
                    (d[dstPixelOffset] & 0xffff) + (s[srcPixelOffset] & 0xffff));

            dstPixelOffset += dstPixelStride;
            srcPixelOffset += srcPixelStride;
          }
        }
      }
    }
  }
コード例 #6
0
  /**
   * Gets a RenderedImage that represents a rendering of this image using a given RenderContext.
   * This is the most general way to obtain a rendering of a RenderableImage.
   *
   * <p>This method does not validate sources and parameters supplied in the <code>ParameterBlock
   * </code> supplied at construction against the specification of the operation this node
   * represents. It is the caller's responsibility to ensure that the data in the <code>
   * ParameterBlock</code> are suitable for this operation. Otherwise, some kind of exception or
   * error will occur. Invoking this method will cause any <code>DeferredData</code> parameters to
   * be evaluated.
   *
   * <p>The <code>RenderContext</code> may contain a <code>Shape</code> that represents the
   * area-of-interest (aoi). If the aoi is specifed, it is still legal to return an image that's
   * larger than this aoi. Therefore, by default, the aoi, if specified, is ignored at the
   * rendering.
   *
   * <p>Any hints in the <code>RenderContext</code> will be merged with any set on the node via
   * <code>setRenderingHints()</code> with the hints in the <code>RenderContext</code> taking
   * precedence.
   *
   * @param renderContext the RenderContext to use to produce the rendering.
   * @return a RenderedImage containing the rendered data.
   */
  public RenderedImage createRendering(RenderContext renderContext) {
    findCRIF();

    // Clone the original ParameterBlock; if the ParameterBlock
    // contains RenderableImage sources, they will be replaced by
    // RenderedImages.
    ParameterBlock nodePB = nodeSupport.getParameterBlock();
    Vector nodeParams = ImageUtil.evaluateParameters(nodePB.getParameters());
    ParameterBlock renderedPB =
        new ParameterBlock((Vector) nodePB.getSources().clone(), nodeParams);
    Vector sources = getRenderableSources();

    try {
      // This assumes that if there is no renderable source, that there
      // is a rendered source in the ParameterBlock.

      // If there are any hints set on the node, create a new
      // RenderContext which merges them with those in the RenderContext
      // passed in with the passed in hints taking precedence.
      RenderContext rcIn = renderContext;
      RenderingHints nodeHints = nodeSupport.getRenderingHints();
      if (nodeHints != null) {
        RenderingHints hints = renderContext.getRenderingHints();
        RenderingHints mergedHints = JAI.mergeRenderingHints(nodeHints, hints);
        if (mergedHints != hints) {
          rcIn =
              new RenderContext(
                  renderContext.getTransform(), renderContext.getAreaOfInterest(), mergedHints);
        }
      }

      if (sources != null) {
        Vector renderedSources = new Vector();
        for (int i = 0; i < sources.size(); i++) {
          RenderContext rcOut = crif.mapRenderContext(i, rcIn, renderedPB, this);
          RenderableImage src = (RenderableImage) sources.elementAt(i);
          RenderedImage renderedImage = src.createRendering(rcOut);
          if (renderedImage == null) {
            return null;
          }

          // Add this rendered image to the ParameterBlock's
          // list of RenderedImages.
          renderedSources.addElement(renderedImage);
        }

        if (renderedSources.size() > 0) {
          renderedPB.setSources(renderedSources);
        }
      }

      RenderedImage rendering = crif.create(rcIn, renderedPB);

      // Replace with the actual rendering if a RenderedOp.
      if (rendering instanceof RenderedOp) {
        rendering = ((RenderedOp) rendering).getRendering();
      }

      // Copy properties to the rendered node.
      if (rendering != null && rendering instanceof WritablePropertySource) {
        String[] propertyNames = getPropertyNames();
        if (propertyNames != null) {
          WritablePropertySource wps = (WritablePropertySource) rendering;

          // Save the names of rendered properties.
          HashSet wpsNameSet = null;
          String[] wpsNames = wps.getPropertyNames();
          if (wpsNames != null) {
            wpsNameSet = new HashSet();
            for (int j = 0; j < wpsNames.length; j++) {
              wpsNameSet.add(new CaselessStringKey(wpsNames[j]));
            }
          }

          // Copy any properties not already defined by the rendering.
          for (int j = 0; j < propertyNames.length; j++) {
            String name = propertyNames[j];
            if (wpsNameSet == null || !wpsNameSet.contains(new CaselessStringKey(name))) {
              Object value = getProperty(name);
              if (value != null && value != java.awt.Image.UndefinedProperty) {
                wps.setProperty(name, value);
              }
            }
          }
        }
      }

      return rendering;
    } catch (ArrayIndexOutOfBoundsException e) {
      // This should never happen
      return null;
    }
  }
コード例 #7
0
 /** Gets the minimum Y coordinate of the rendering-independent image data. */
 public float getMinY() {
   findCRIF();
   ParameterBlock paramBlock = ImageUtil.evaluateParameters(nodeSupport.getParameterBlock());
   Rectangle2D boundingBox = crif.getBounds2D(paramBlock);
   return (float) boundingBox.getY();
 }