コード例 #1
0
 public static PaintContext getContext(
     BufferedImage bufImg, AffineTransform xform, RenderingHints hints, Rectangle devBounds) {
   WritableRaster raster = bufImg.getRaster();
   ColorModel cm = bufImg.getColorModel();
   int maxw = devBounds.width;
   Object val = hints.get(hints.KEY_INTERPOLATION);
   boolean filter =
       (val == null
           ? (hints.get(hints.KEY_RENDERING) == hints.VALUE_RENDER_QUALITY)
           : (val != hints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR));
   if (raster instanceof IntegerInterleavedRaster && (!filter || isFilterableDCM(cm))) {
     IntegerInterleavedRaster iir = (IntegerInterleavedRaster) raster;
     if (iir.getNumDataElements() == 1 && iir.getPixelStride() == 1) {
       return new Int(iir, cm, xform, maxw, filter);
     }
   } else if (raster instanceof ByteInterleavedRaster) {
     ByteInterleavedRaster bir = (ByteInterleavedRaster) raster;
     if (bir.getNumDataElements() == 1 && bir.getPixelStride() == 1) {
       if (filter) {
         if (isFilterableICM(cm)) {
           return new ByteFilter(bir, cm, xform, maxw);
         }
       } else {
         return new Byte(bir, cm, xform, maxw);
       }
     }
   }
   return new Any(raster, cm, xform, maxw, filter);
 }
コード例 #2
0
 public Byte(ByteInterleavedRaster srcRas, ColorModel cm, AffineTransform xform, int maxw) {
   super(cm, xform, srcRas.getWidth(), srcRas.getHeight(), maxw);
   this.srcRas = srcRas;
   this.inData = srcRas.getDataStorage();
   this.inSpan = srcRas.getScanlineStride();
   this.inOff = srcRas.getDataOffset(0);
 }
コード例 #3
0
 public WritableRaster makeRaster(int w, int h) {
   WritableRaster ras = makeByteRaster(srcRas, w, h);
   ByteInterleavedRaster biRas = (ByteInterleavedRaster) ras;
   outData = biRas.getDataStorage();
   outSpan = biRas.getScanlineStride();
   outOff = biRas.getDataOffset(0);
   return ras;
 }
コード例 #4
0
  private static void renderBinary(
      GrayU8 binaryImage, boolean invert, ByteInterleavedRaster raster) {
    int rasterIndex = 0;
    byte data[] = raster.getDataStorage();

    int w = binaryImage.getWidth();
    int h = binaryImage.getHeight();

    int numBands = raster.getNumBands();
    if (numBands == 1) {
      if (invert) {
        for (int y = 0; y < h; y++) {
          int indexSrc = binaryImage.startIndex + y * binaryImage.stride;
          for (int x = 0; x < w; x++) {
            data[rasterIndex++] = (byte) ((1 - binaryImage.data[indexSrc++]) * 255);
          }
        }
      } else {
        for (int y = 0; y < h; y++) {
          int indexSrc = binaryImage.startIndex + y * binaryImage.stride;
          for (int x = 0; x < w; x++) {
            data[rasterIndex++] = (byte) (binaryImage.data[indexSrc++] * 255);
          }
        }
      }
    } else {
      if (invert) {
        for (int y = 0; y < h; y++) {
          int indexSrc = binaryImage.startIndex + y * binaryImage.stride;
          for (int x = 0; x < w; x++) {
            byte val = (byte) ((1 - binaryImage.data[indexSrc++]) * 255);
            for (int i = 0; i < numBands; i++) {
              data[rasterIndex++] = val;
            }
          }
        }
      } else {
        for (int y = 0; y < h; y++) {
          int indexSrc = binaryImage.startIndex + y * binaryImage.stride;
          for (int x = 0; x < w; x++) {
            byte val = (byte) (binaryImage.data[indexSrc++] * 255);
            for (int i = 0; i < numBands; i++) {
              data[rasterIndex++] = val;
            }
          }
        }
      }
    }
  }
コード例 #5
0
 public ByteFilter(
     ByteInterleavedRaster srcRas, ColorModel cm, AffineTransform xform, int maxw) {
   super(
       (cm.getTransparency() == Transparency.OPAQUE ? xrgbmodel : argbmodel),
       xform,
       srcRas.getWidth(),
       srcRas.getHeight(),
       maxw);
   this.inPalette = new int[256];
   ((IndexColorModel) cm).getRGBs(this.inPalette);
   this.srcRas = srcRas;
   this.inData = srcRas.getDataStorage();
   this.inSpan = srcRas.getScanlineStride();
   this.inOff = srcRas.getDataOffset(0);
 }
コード例 #6
0
ファイル: BoofTesting.java プロジェクト: registerpoint/BoofCV
  /**
   * Checks to see if the BufferedImage has the same intensity values as the ImageUInt8
   *
   * @param imgA BufferedImage
   * @param imgB ImageUInt8
   */
  public static void checkEquals(BufferedImage imgA, ImageInt16 imgB) {

    if (imgA.getRaster() instanceof ByteInterleavedRaster
        && imgA.getType() != BufferedImage.TYPE_BYTE_INDEXED) {
      ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA.getRaster();

      if (raster.getNumBands() == 1) {
        int strideA = raster.getScanlineStride();
        int offsetA = raster.getDataOffset(0) - raster.getNumBands() + 1;

        // handle a special case where the RGB conversion is screwed
        for (int i = 0; i < imgA.getHeight(); i++) {
          for (int j = 0; j < imgA.getWidth(); j++) {
            int valB = imgB.get(j, i);
            int valA = raster.getDataStorage()[offsetA + i * strideA + j];
            if (!imgB.getTypeInfo().isSigned()) valA &= 0xFFFF;

            if (valA != valB)
              throw new RuntimeException("Images are not equal: " + valA + " " + valB);
          }
        }
        return;
      }
    } else if (imgA.getRaster() instanceof ShortInterleavedRaster) {
      ShortInterleavedRaster raster = (ShortInterleavedRaster) imgA.getRaster();

      if (raster.getNumBands() == 1) {
        int strideA = raster.getScanlineStride();
        int offsetA = raster.getDataOffset(0) - raster.getNumBands() + 1;

        // handle a special case where the RGB conversion is screwed
        for (int i = 0; i < imgA.getHeight(); i++) {
          for (int j = 0; j < imgA.getWidth(); j++) {
            int valB = imgB.get(j, i);
            int valA = raster.getDataStorage()[offsetA + i * strideA + j];
            if (!imgB.getTypeInfo().isSigned()) valA &= 0xFFFF;

            if (valA != valB)
              throw new RuntimeException("Images are not equal: " + valA + " " + valB);
          }
        }
      }
    } else {
      for (int y = 0; y < imgA.getHeight(); y++) {
        for (int x = 0; x < imgA.getWidth(); x++) {
          int rgb = imgA.getRGB(x, y);

          int gray = ((((rgb >>> 16) & 0xFF) + ((rgb >>> 8) & 0xFF) + (rgb & 0xFF)) / 3);
          int grayB = imgB.get(x, y);
          if (!imgB.getTypeInfo().isSigned()) gray &= 0xFFFF;

          if (Math.abs(gray - grayB) != 0) {
            throw new RuntimeException(
                "images are not equal: (" + x + " , " + y + ") A = " + gray + " B = " + grayB);
          }
        }
      }
    }
  }
コード例 #7
0
ファイル: BoofTesting.java プロジェクト: registerpoint/BoofCV
  /**
   * Checks to see if the BufferedImage has the same intensity values as the ImageUInt8
   *
   * @param imgA BufferedImage
   * @param imgB ImageUInt8
   */
  public static void checkEquals(BufferedImage imgA, InterleavedU8 imgB) {

    if (imgA.getRaster() instanceof ByteInterleavedRaster) {
      ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA.getRaster();

      if (raster.getNumBands() == 1) {
        // handle a special case where the RGB conversion is screwed
        for (int i = 0; i < imgA.getHeight(); i++) {
          for (int j = 0; j < imgA.getWidth(); j++) {
            int valB = imgB.getBand(j, i, 0);
            int valA = raster.getDataStorage()[i * imgA.getWidth() + j] & 0xFF;

            if (valA != valB) throw new RuntimeException("Images are not equal");
          }
        }
        return;
      }
    }

    for (int y = 0; y < imgA.getHeight(); y++) {
      for (int x = 0; x < imgA.getWidth(); x++) {
        int rgb = imgA.getRGB(x, y);

        int r = (rgb >>> 16) & 0xFF;
        int g = (rgb >>> 8) & 0xFF;
        int b = rgb & 0xFF;

        if (Math.abs(b - imgB.getBand(x, y, 0) & 0xFF) != 0)
          throw new RuntimeException("images are not equal: ");
        if (Math.abs(g - imgB.getBand(x, y, 1) & 0xFF) != 0)
          throw new RuntimeException("images are not equal: ");
        if (Math.abs(r - imgB.getBand(x, y, 2) & 0xFF) != 0)
          throw new RuntimeException("images are not equal: ");
      }
    }
  }
コード例 #8
0
ファイル: BoofTesting.java プロジェクト: registerpoint/BoofCV
  /**
   * Checks to see if the BufferedImage has the same intensity values as the ImageUInt8
   *
   * @param imgA BufferedImage
   * @param imgB ImageUInt8
   */
  public static void checkEquals(BufferedImage imgA, ImageFloat32 imgB, float tol) {

    if (imgA.getRaster() instanceof ByteInterleavedRaster
        && imgA.getType() != BufferedImage.TYPE_BYTE_INDEXED) {
      ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA.getRaster();

      if (raster.getNumBands() == 1) {
        int strideA = raster.getScanlineStride();
        int offsetA = raster.getDataOffset(0) - raster.getNumBands() + 1;

        // handle a special case where the RGB conversion is screwed
        for (int i = 0; i < imgA.getHeight(); i++) {
          for (int j = 0; j < imgA.getWidth(); j++) {
            float valB = imgB.get(j, i);
            int valA = raster.getDataStorage()[offsetA + i * strideA + j];
            valA &= 0xFF;

            if (Math.abs(valA - valB) > tol)
              throw new RuntimeException("Images are not equal: A = " + valA + " B = " + valB);
          }
        }
        return;
      }
    }

    for (int y = 0; y < imgA.getHeight(); y++) {
      for (int x = 0; x < imgA.getWidth(); x++) {
        int rgb = imgA.getRGB(x, y);

        float gray = (((rgb >>> 16) & 0xFF) + ((rgb >>> 8) & 0xFF) + (rgb & 0xFF)) / 3.0f;
        float grayB = imgB.get(x, y);

        if (Math.abs(gray - grayB) > tol) {
          throw new RuntimeException("images are not equal: A = " + gray + " B = " + grayB);
        }
      }
    }
  }
コード例 #9
0
ファイル: BoofTesting.java プロジェクト: registerpoint/BoofCV
  public static void checkEquals(
      BufferedImage imgA, MultiSpectral imgB, boolean boofcvBandOrder, float tol) {

    if (imgA.getRaster() instanceof ByteInterleavedRaster
        && imgA.getType() != BufferedImage.TYPE_BYTE_INDEXED) {
      ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA.getRaster();

      if (raster.getNumBands() == 1) {
        GImageSingleBand band = FactoryGImageSingleBand.wrap(imgB.getBand(0));

        int strideA = raster.getScanlineStride();
        int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;

        // handle a special case where the RGB conversion is screwed
        for (int i = 0; i < imgA.getHeight(); i++) {
          for (int j = 0; j < imgA.getWidth(); j++) {
            double valB = band.get(j, i).doubleValue();
            int valA = raster.getDataStorage()[offsetA + i * strideA + j];
            valA &= 0xFF;

            if (Math.abs(valA - valB) > tol)
              throw new RuntimeException("Images are not equal: A = " + valA + " B = " + valB);
          }
        }
        return;
      }
    }

    int bandOrder[];

    if (boofcvBandOrder) {
      if (imgB.getNumBands() == 4) {
        bandOrder = new int[] {1, 2, 3, 0};
      } else {
        bandOrder = new int[] {0, 1, 2};
      }
    } else {
      if (imgA.getType() == BufferedImage.TYPE_INT_RGB) {
        bandOrder = new int[] {0, 1, 2};
      } else if (imgA.getType() == BufferedImage.TYPE_INT_BGR
          || imgA.getType() == BufferedImage.TYPE_3BYTE_BGR) {
        bandOrder = new int[] {2, 1, 0};
      } else if (imgA.getType() == BufferedImage.TYPE_4BYTE_ABGR) {
        bandOrder = new int[] {0, 3, 2, 1};
      } else if (imgA.getType() == BufferedImage.TYPE_INT_ARGB) {
        bandOrder = new int[] {0, 1, 2, 3};
      } else {
        bandOrder = new int[] {0, 1, 2};
      }
    }

    int expected[] = new int[4];

    for (int y = 0; y < imgA.getHeight(); y++) {
      for (int x = 0; x < imgA.getWidth(); x++) {
        // getRGB() automatically converts the band order to ARGB
        int rgb = imgA.getRGB(x, y);

        expected[0] = ((rgb >>> 24) & 0xFF); // alpha
        expected[1] = ((rgb >>> 16) & 0xFF); // red
        expected[2] = ((rgb >>> 8) & 0xFF); // green
        expected[3] = (rgb & 0xFF); // blue

        if (imgB.getNumBands() == 4) {

          for (int i = 0; i < 4; i++) {
            double found = GeneralizedImageOps.get(imgB.getBand(bandOrder[i]), x, y);
            if (Math.abs(Math.exp(expected[i] - found)) > tol) {
              for (int j = 0; j < 4; j++) {
                System.out.println(
                    expected[j] + " " + GeneralizedImageOps.get(imgB.getBand(bandOrder[j]), x, y));
              }
              throw new RuntimeException(
                  "Images are not equal: band - " + i + " type " + imgA.getType());
            }
          }

        } else if (imgB.getNumBands() == 3) {

          for (int i = 0; i < 3; i++) {
            double found = GeneralizedImageOps.get(imgB.getBand(bandOrder[i]), x, y);
            if (Math.abs(expected[i + 1] - found) > tol) {
              for (int j = 0; j < 3; j++) {
                System.out.println(
                    expected[j + 1]
                        + " "
                        + GeneralizedImageOps.get(imgB.getBand(bandOrder[j]), x, y));
              }
              throw new RuntimeException(
                  "Images are not equal: band - " + i + " type " + imgA.getType());
            }
          }

        } else {
          throw new RuntimeException("Unexpectd number of bands");
        }
      }
    }
  }
コード例 #10
0
ファイル: BoofTesting.java プロジェクト: registerpoint/BoofCV
  public static void checkEquals(WritableRaster imgA, MultiSpectral imgB, float tol) {

    if (imgA.getNumBands() != imgB.getNumBands()) {
      throw new RuntimeException("Number of bands not equals");
    }

    if (imgA instanceof ByteInterleavedRaster) {
      ByteInterleavedRaster raster = (ByteInterleavedRaster) imgA;

      byte dataA[] = raster.getDataStorage();
      int strideA = raster.getScanlineStride();
      int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;

      // handle a special case where the RGB conversion is screwed
      for (int y = 0; y < imgA.getHeight(); y++) {
        int indexA = offsetA + strideA * y;

        for (int x = 0; x < imgA.getWidth(); x++) {
          for (int k = 0; k < imgB.getNumBands(); k++) {
            int valueA = dataA[indexA++] & 0xFF;
            double valueB = GeneralizedImageOps.get(imgB.getBand(k), x, y);
            if (Math.abs(valueA - valueB) > tol)
              throw new RuntimeException("Images are not equal: A = " + valueA + " B = " + valueB);
          }
        }
      }

    } else if (imgA instanceof IntegerInterleavedRaster) {
      IntegerInterleavedRaster raster = (IntegerInterleavedRaster) imgA;

      int dataA[] = raster.getDataStorage();
      int strideA = raster.getScanlineStride();
      int offsetA = raster.getDataOffset(0) - raster.getPixelStride() + 1;

      // handle a special case where the RGB conversion is screwed
      for (int y = 0; y < imgA.getHeight(); y++) {
        int indexA = offsetA + strideA * y;

        for (int x = 0; x < imgA.getWidth(); x++) {
          int valueA = dataA[indexA++];
          if (imgB.getNumBands() == 4) {
            int found0 = (valueA >> 24) & 0xFF;
            int found1 = (valueA >> 16) & 0xFF;
            int found2 = (valueA >> 8) & 0xFF;
            int found3 = valueA & 0xFF;

            double expected0 = GeneralizedImageOps.get(imgB.getBand(0), x, y);
            double expected1 = GeneralizedImageOps.get(imgB.getBand(1), x, y);
            double expected2 = GeneralizedImageOps.get(imgB.getBand(2), x, y);
            double expected3 = GeneralizedImageOps.get(imgB.getBand(3), x, y);

            if (Math.abs(found0 - expected0) > tol)
              throw new RuntimeException("Images are not equal");
            if (Math.abs(found1 - expected1) > tol)
              throw new RuntimeException("Images are not equal");
            if (Math.abs(found2 - expected2) > tol)
              throw new RuntimeException("Images are not equal");
            if (Math.abs(found3 - expected3) > tol)
              throw new RuntimeException("Images are not equal");
          } else if (imgB.getNumBands() == 3) {
            int found0 = (valueA >> 16) & 0xFF;
            int found1 = (valueA >> 8) & 0xFF;
            int found2 = valueA & 0xFF;

            double expected0 = GeneralizedImageOps.get(imgB.getBand(0), x, y);
            double expected1 = GeneralizedImageOps.get(imgB.getBand(1), x, y);
            double expected2 = GeneralizedImageOps.get(imgB.getBand(2), x, y);

            if (Math.abs(found0 - expected0) > tol)
              throw new RuntimeException("Images are not equal");
            if (Math.abs(found1 - expected1) > tol)
              throw new RuntimeException("Images are not equal");
            if (Math.abs(found2 - expected2) > tol)
              throw new RuntimeException("Images are not equal");
          } else {
            throw new RuntimeException("Unexpectd number of bands");
          }
        }
      }
    } else {
      throw new RuntimeException("Add support for raster type " + imgA.getClass().getSimpleName());
    }
  }
コード例 #11
0
ファイル: LCMS.java プロジェクト: grimtraveller/LightZone
 public void doTransform(ByteInterleavedRaster input, ByteInterleavedRaster output) {
   if (cmsTransform != null) {
     ByteInterleavedRaster ri = normalizeRaster(input);
     ByteInterleavedRaster ro;
     int outBands = output.getNumBands();
     if (!input.getBounds().equals(output.getBounds())) {
       int[] offsets = outBands == 1 ? new int[] {0} : new int[] {0, 1, 2};
       SampleModel sm =
           new PixelInterleavedSampleModel(
               DataBuffer.TYPE_BYTE,
               ri.getWidth(),
               ri.getHeight(),
               outBands,
               outBands * ri.getWidth(),
               offsets);
       ro = new ByteInterleavedRaster(sm, new Point(ri.getMinX(), ri.getMinY()));
     } else ro = normalizeRaster(output);
     int pixels =
         outBands == 1 ? ro.getDataStorage().length : ro.getDataStorage().length / outBands;
     cmsDoTransform(cmsTransform.handle, ri.getDataStorage(), ro.getDataStorage(), pixels);
     if (ro != output) Functions.copyData(output, ro);
   }
 }
コード例 #12
0
ファイル: LCMS.java プロジェクト: grimtraveller/LightZone
  private static ByteInterleavedRaster normalizeRaster(ByteInterleavedRaster raster) {
    boolean reallocBuffer = false;
    int scanLineStride = raster.getScanlineStride();
    int dataOffsets[] = raster.getDataOffsets();
    for (int i = 0; i < dataOffsets.length; i++)
      if (dataOffsets[i] != i) {
        reallocBuffer = true;
        break;
      }
    int bands = raster.getNumBands();
    if (!reallocBuffer
        && (raster.getPixelStride() != bands || scanLineStride != raster.getWidth() * bands))
      reallocBuffer = true;
    if (reallocBuffer) {
      PixelInterleavedSampleModel sm = (PixelInterleavedSampleModel) raster.getSampleModel();

      PixelInterleavedSampleModel newSM =
          new PixelInterleavedSampleModel(
              sm.getDataType(),
              raster.getWidth(),
              raster.getHeight(),
              bands,
              bands * raster.getWidth(),
              bands == 1 ? new int[] {0} : new int[] {0, 1, 2});

      ByteInterleavedRaster newRaster =
          new ByteInterleavedRaster(newSM, new Point(raster.getMinX(), raster.getMinY()));
      Functions.copyData(newRaster, raster);
      raster = newRaster;
    }
    return raster;
  }