title: Transparency between SWT<->AWT Image Conversions
body: <p>I have created a dialog in which a user can browse for an image and then <strong>see a preview of the image drawn on a canvas</strong>.  The image is <strong>scaled</strong> so that its aspect ratio is maintained while fitting in the box.  I used the method of resizing found in <a href="https://stackoverflow.com/a/10548630/1961815">this answer</a>, which involves converting an image from SWT to AWT, performing the resize, converting back from AWT to SWT, and finally drawing it on the canvas.  Since this process is very costly in terms of time and processing power, I elect to <strong>skip the resizing step if the image is exactly the correct size</strong>, and thus does not need to be transformed in any way.</p>
  
  <p>The issue comes up when dealing with images with alpha transparency.  In some cases, images that have transparency that are converted first are drawn on the canvas with a black background.  A copy of the same image that has been sized to the exact size of the canvas, and thus is not converted, has a white background.</p>
  
  <p><img src="https://i.stack.imgur.com/CZHtj.png" alt="Fluttershy&#39;s background is so flaky and inconsistent."></p>
  
  <p>However, this is also not always the case.  Some images with transparent backgrounds will always show as white, whether they've been converted or not.</p>
  
  <p><img src="https://i.stack.imgur.com/aQlnp.png" alt="They&#39;ve seen angrier days."></p>
  
  <p><strong>What causes an image with a transparent background to draw with one color over another in an SWT canvas?</strong>  How does the AWT conversion affect it, and how can I cause it to become consistent if I so desire?</p>
  
  <p>Here is the conversion code, taken in whole from another source:</p>
  
  <pre><code>public static BufferedImage convertToAWT (ImageData data) {
      ColorModel colorModel = null;
      PaletteData palette = data.palette;
      if (palette.isDirect) {
          colorModel = new DirectColorModel(data.depth, palette.redMask, palette.greenMask, palette.blueMask);
          BufferedImage bufferedImage = new BufferedImage(colorModel, colorModel.createCompatibleWritableRaster(data.width, data.height),
                  false, null);
          WritableRaster raster = bufferedImage.getRaster();
          int[] pixelArray = new int[3];
          for (int y = 0; y &lt; data.height; y++) {
              for (int x = 0; x &lt; data.width; x++) {
                  int pixel = data.getPixel(x, y);
                  RGB rgb = palette.getRGB(pixel);
                  pixelArray[0] = rgb.red;
                  pixelArray[1] = rgb.green;
                  pixelArray[2] = rgb.blue;
                  raster.setPixels(x, y, 1, 1, pixelArray);
              }
          }
          return bufferedImage;
      }
      else {
          RGB[] rgbs = palette.getRGBs();
          byte[] red = new byte[rgbs.length];
          byte[] green = new byte[rgbs.length];
          byte[] blue = new byte[rgbs.length];
          for (int i = 0; i &lt; rgbs.length; i++) {
              RGB rgb = rgbs[i];
              red[i] = (byte) rgb.red;
              green[i] = (byte) rgb.green;
              blue[i] = (byte) rgb.blue;
          }
          if (data.transparentPixel != -1) {
              colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue, data.transparentPixel);
          } else {
              colorModel = new IndexColorModel(data.depth, rgbs.length, red, green, blue);
          }
          BufferedImage bufferedImage = new BufferedImage(colorModel, colorModel.createCompatibleWritableRaster(data.width, data.height),
                  false, null);
          WritableRaster raster = bufferedImage.getRaster();
          int[] pixelArray = new int[1];
          for (int y = 0; y &lt; data.height; y++) {
              for (int x = 0; x &lt; data.width; x++) {
                  int pixel = data.getPixel(x, y);
                  pixelArray[0] = pixel;
                  raster.setPixel(x, y, pixelArray);
              }
          }
          return bufferedImage;
      }
  }
  
  public static ImageData convertToSWT (BufferedImage bufferedImage) {
      if (bufferedImage.getColorModel() instanceof DirectColorModel) {
          DirectColorModel colorModel = (DirectColorModel) bufferedImage.getColorModel();
          PaletteData palette = new PaletteData(colorModel.getRedMask(), colorModel.getGreenMask(), colorModel.getBlueMask());
          ImageData data = new ImageData(bufferedImage.getWidth(), bufferedImage.getHeight(), colorModel.getPixelSize(), palette);
          WritableRaster raster = bufferedImage.getRaster();
          int[] pixelArray = new int[3];
          for (int y = 0; y &lt; data.height; y++) {
              for (int x = 0; x &lt; data.width; x++) {
                  raster.getPixel(x, y, pixelArray);
                  int pixel = palette.getPixel(new RGB(pixelArray[0], pixelArray[1], pixelArray[2]));
                  data.setPixel(x, y, pixel);
              }
          }
          return data;
      }
      else if (bufferedImage.getColorModel() instanceof IndexColorModel) {
          IndexColorModel colorModel = (IndexColorModel) bufferedImage.getColorModel();
          int size = colorModel.getMapSize();
          byte[] reds = new byte[size];
          byte[] greens = new byte[size];
          byte[] blues = new byte[size];
          colorModel.getReds(reds);
          colorModel.getGreens(greens);
          colorModel.getBlues(blues);
          RGB[] rgbs = new RGB[size];
          for (int i = 0; i &lt; rgbs.length; i++) {
              rgbs[i] = new RGB(reds[i] &amp; 0xFF, greens[i] &amp; 0xFF, blues[i] &amp; 0xFF);
          }
          PaletteData palette = new PaletteData(rgbs);
          ImageData data = new ImageData(bufferedImage.getWidth(), bufferedImage.getHeight(), colorModel.getPixelSize(), palette);
          data.transparentPixel = colorModel.getTransparentPixel();
          WritableRaster raster = bufferedImage.getRaster();
          int[] pixelArray = new int[1];
          for (int y = 0; y &lt; data.height; y++) {
              for (int x = 0; x &lt; data.width; x++) {
                  raster.getPixel(x, y, pixelArray);
                  data.setPixel(x, y, pixelArray[0]);
              }
          }
          return data;
      }
      return null;
  }
  </code></pre>