gov/nasa/worldwind/DDSConverter.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind;
   8
   9 import java.awt.image.*;
  10 import java.nio.*;
  11 import java.io.*;
  12
  13 /**
  14  * @author Tom Gaskins
  15  * @version $Id: DDSConverter.java 2027 2007-06-14 02:41:44Z tgaskins $
  16  */
  17 public class DDSConverter
  18 {
  19     static final int DDSD_CAPS = 0x0001;
  20     static final int DDSD_HEIGHT = 0x0002;
  21     static final int DDSD_WIDTH = 0x0004;
  22     static final int DDSD_PIXELFORMAT = 0x1000;
  23     static final int DDSD_MIPMAPCOUNT = 0x20000;
  24     static final int DDSD_LINEARSIZE = 0x80000;
  25     static final int DDPF_FOURCC = 0x0004;
  26     static final int DDSCAPS_TEXTURE = 0x1000;
  27
  28     protected static class Color
  29     {
  30         private int r, g, b;
  31
  32         public Color()
  33         {
  34             this.r = this.g = this.b = 0;
  35         }
  36
  37         public Color(int r, int g, int b)
  38         {
  39             this.r = r;
  40             this.g = g;
  41             this.b = b;
  42         }
  43
  44         public boolean equals(Object o)
  45         {
  46             if (this == o)
  47                 return true;
  48             if (o == null || getClass() != o.getClass())
  49                 return false;
  50
  51             final gov.nasa.worldwind.DDSConverter.Color color = (gov.nasa.worldwind.DDSConverter.Color) o;
  52
  53             if (b != color.b)
  54                 return false;
  55             if (g != color.g)
  56                 return false;
  57             //noinspection RedundantIfStatement
  58             if (r != color.r)
  59                 return false;
  60
  61             return true;
  62         }
  63
  64         public int hashCode()
  65         {
  66             int result;
  67             result = r;
  68             result = 29 * result + g;
  69             result = 29 * result + b;
  70             return result;
  71         }
  72     }
  73
  74     public static ByteBuffer convertToDDS(ByteBuffer image, String mimeType) throws IOException
  75     {
  76         if (image == null)
  77         {
  78             String message = WorldWind.retrieveErrMsg("nullValue.ByteBufferIsNull");
  79             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  80             throw new IllegalArgumentException(message);
  81         }
  82
  83         if (mimeType == null)
  84         {
  85             String message = WorldWind.retrieveErrMsg("nullValue.MimeTypeIsNull");
  86             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
  87             throw new IllegalArgumentException(message);
  88         }
  89
  90         String suffix = WWIO.getSuffixForMimeType(mimeType);
  91         if (suffix == null)
  92         {
  93             String message = WorldWind.retrieveErrMsg("DDSConverter.UnsupportedMimeType") + mimeType;
  94             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  95             throw new IllegalArgumentException(message);
  96         }
  97
  98         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
  99
 100         return convertToDDS(tempFile);
 101     }
 102
 103     public static ByteBuffer convertToDDS(File file) throws IOException
 104     {
 105         if (file == null)
 106         {
 107             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 108             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 109             throw new IllegalArgumentException(message);
 110         }
 111
 112         if (!file.exists() || !file.canRead())
 113         {
 114             String message = WorldWind.retrieveErrMsg("DDSConverter.NoFileOrNoPermission");
 115             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 116             throw new IllegalArgumentException(message);
 117         }
 118
 119         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 120         if (image == null)
 121         {
 122             return null;
 123         }
 124
 125         // Don't waste the space for transparency if
 126         if (image.getColorModel().hasAlpha())
 127             return convertToDxt3(image);
 128         else
 129             return convertToDxt1NoTransparency(image);
 130     }
 131
 132     public static ByteBuffer convertToDxt1NoTransparency(ByteBuffer image, String mimeType)
 133         throws IOException
 134     {
 135         if (image == null)
 136         {
 137             String message = WorldWind.retrieveErrMsg("nullValue.ByteBufferIsNull");
 138             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 139             throw new IllegalArgumentException(message);
 140         }
 141
 142         if (mimeType == null)
 143         {
 144             String message = WorldWind.retrieveErrMsg("nullValue.MimeTypeIsNull");
 145             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
 146             throw new IllegalArgumentException(message);
 147         }
 148
 149         String suffix = WWIO.getSuffixForMimeType(mimeType);
 150         if (suffix == null)
 151         {
 152             String message = WorldWind.retrieveErrMsg("DDSConverter.UnsupportedMimeType") + mimeType;
 153             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 154             throw new IllegalArgumentException(message);
 155         }
 156
 157         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
 158
 159         return convertToDxt1NoTransparency(tempFile);
 160     }
 161
 162     public static ByteBuffer convertToDxt1NoTransparency(File file) throws IOException
 163     {
 164         if (file == null)
 165         {     //
 166             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 167             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 168             throw new IllegalArgumentException(message);
 169         }
 170
 171         if (!file.exists() || !file.canRead())
 172         {
 173             String message = WorldWind.retrieveErrMsg("DDSConverter.NoFileOrNoPermission");
 174             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 175             throw new IllegalArgumentException(message);
 176         }
 177
 178         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 179
 180         if (image == null)
 181         {
 182             return null; // TODO: log
 183         }
 184
 185         return convertToDxt1NoTransparency(image);
 186     }
 187
 188     public static ByteBuffer convertToDxt1NoTransparency(BufferedImage image)
 189     {
 190         if (image == null)
 191         {
 192             return null;
 193         }
 194
 195         int[] pixels = new int[16];
 196         int bufferSize = 128 + image.getWidth() * image.getHeight() / 2;
 197         ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
 198         buffer.order(ByteOrder.LITTLE_ENDIAN);
 199         buildHeaderDxt1(buffer, image.getWidth(), image.getHeight());
 200
 201         int numTilesWide = image.getWidth() / 4;
 202         int numTilesHigh = image.getHeight() / 4;
 203         for (int i = 0; i < numTilesHigh; i++)
 204         {
 205             for (int j = 0; j < numTilesWide; j++)
 206             {
 207                 java.awt.image.BufferedImage originalTile = image.getSubimage(j * 4, i * 4, 4, 4);
 208                 originalTile.getRGB(0, 0, 4, 4, pixels, 0, 4);
 209                 Color[] colors = getColors888(pixels);
 210
 211                 for (int k = 0; k < pixels.length; k++)
 212                 {
 213                     pixels[k] = getPixel565(colors[k]);
 214                     colors[k] = getColor565(pixels[k]);
 215                 }
 216
 217                 int[] extremaIndices = determineExtremeColors(colors);
 218                 if (pixels[extremaIndices[0]] < pixels[extremaIndices[1]])
 219                 {
 220                     int t = extremaIndices[0];
 221                     extremaIndices[0] = extremaIndices[1];
 222                     extremaIndices[1] = t;
 223                 }
 224
 225                 buffer.putShort((short) pixels[extremaIndices[0]]);
 226                 buffer.putShort((short) pixels[extremaIndices[1]]);
 227
 228                 long bitmask = computeBitMask(colors, extremaIndices);
 229                 buffer.putInt((int) bitmask);
 230             }
 231         }
 232
 233         return buffer;
 234     }
 235
 236     public static ByteBuffer convertToDxt3(ByteBuffer image, String mimeType)
 237         throws IOException
 238     {
 239         if (image == null)
 240         {
 241             String message = WorldWind.retrieveErrMsg("nullValue.ByteBufferIsNull");
 242             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 243             throw new IllegalArgumentException(message);
 244         }
 245
 246         if (mimeType == null)
 247         {
 248             String message = WorldWind.retrieveErrMsg("nullValue.MimeTypeIsNull");
 249             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
 250             throw new IllegalArgumentException(message);
 251         }
 252
 253         String suffix = WWIO.getSuffixForMimeType(mimeType);
 254         if (suffix == null)
 255         {
 256             String message = WorldWind.retrieveErrMsg("DDSConverter.UnsupportedMimeType") + mimeType;
 257             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 258             throw new IllegalArgumentException(message);
 259         }
 260
 261         File tempFile = WWIO.saveBufferToTempFile(image, suffix);
 262
 263         return convertToDxt3(tempFile);
 264     }
 265
 266     public static ByteBuffer convertToDxt3(File file) throws IOException
 267     {
 268         if (file == null)
 269         {
 270             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 271             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 272             throw new IllegalArgumentException(message);
 273         }
 274
 275         if (!file.exists() || !file.canRead())
 276         {
 277             String message = WorldWind.retrieveErrMsg("DDSConverter.NoFileOrNoPermission");
 278             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 279             throw new IllegalArgumentException(message);
 280         }
 281
 282         java.awt.image.BufferedImage image = javax.imageio.ImageIO.read(file);
 283         if (image == null)
 284         {
 285             return null;
 286         }
 287
 288         return convertToDxt3(image);
 289     }
 290
 291     public static ByteBuffer convertToDxt3(BufferedImage image) throws IOException
 292     {
 293         if (image == null)
 294             return null; // TODO: arg check
 295
 296         // Don't waste the space for transparency if
 297         if (!image.getColorModel().hasAlpha())
 298             return convertToDxt1NoTransparency(image);
 299
 300         int[] pixels = new int[16];
 301         int bufferSize = 128 + image.getWidth() * image.getHeight();
 302         ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
 303         buffer.order(ByteOrder.LITTLE_ENDIAN);
 304         buildHeaderDxt3(buffer, image.getWidth(), image.getHeight());
 305
 306         int numTilesWide = image.getWidth() / 4;
 307         int numTilesHigh = image.getHeight() / 4;
 308         for (int i = 0; i < numTilesHigh; i++)
 309         {
 310             for (int j = 0; j < numTilesWide; j++)
 311             {
 312                 java.awt.image.BufferedImage originalTile = image.getSubimage(j * 4, i * 4, 4, 4);
 313                 originalTile.getRGB(0, 0, 4, 4, pixels, 0, 4);
 314                 Color[] colors = getColors888(pixels);
 315
 316                 // Store the alhpa table.
 317                 for (int k = 0; k < pixels.length; k += 2)
 318                 {
 319                     buffer.put((byte) ((pixels[k] >>> 24) | (pixels[k + 1] >>> 28)));
 320                 }
 321
 322                 for (int k = 0; k < pixels.length; k++)
 323                 {
 324                     pixels[k] = getPixel565(colors[k]);
 325                     colors[k] = getColor565(pixels[k]);
 326                 }
 327
 328                 int[] extremaIndices = determineExtremeColors(colors);
 329                 if (pixels[extremaIndices[0]] < pixels[extremaIndices[1]])
 330                 {
 331                     int t = extremaIndices[0];
 332                     extremaIndices[0] = extremaIndices[1];
 333                     extremaIndices[1] = t;
 334                 }
 335
 336                 buffer.putShort((short) pixels[extremaIndices[0]]);
 337                 buffer.putShort((short) pixels[extremaIndices[1]]);
 338
 339                 long bitmask = computeBitMask(colors, extremaIndices);
 340                 buffer.putInt((int) bitmask);
 341             }
 342         }
 343
 344         return buffer;
 345     }
 346
 347     protected static void buildHeaderDxt1(ByteBuffer buffer, int width, int height)
 348     {
 349         buffer.rewind();
 350         buffer.put((byte) 'D');
 351         buffer.put((byte) 'D');
 352         buffer.put((byte) 'S');
 353         buffer.put((byte) ' ');
 354         buffer.putInt(124);
 355         int flag = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE;
 356         buffer.putInt(flag);
 357         buffer.putInt(height);
 358         buffer.putInt(width);
 359         buffer.putInt(width * height / 2);
 360         buffer.putInt(0); // depth
 361         buffer.putInt(0); // mipmap count
 362         buffer.position(buffer.position() + 44); // 11 unused double-words
 363         buffer.putInt(32); // pixel format size
 364         buffer.putInt(DDPF_FOURCC);
 365         buffer.put((byte) 'D');
 366         buffer.put((byte) 'X');
 367         buffer.put((byte) 'T');
 368         buffer.put((byte) '1');
 369         buffer.putInt(0); // bits per pixel for RGB (non-compressed) formats
 370         buffer.putInt(0); // rgb bit masks for RGB formats
 371         buffer.putInt(0); // rgb bit masks for RGB formats
 372         buffer.putInt(0); // rgb bit masks for RGB formats
 373         buffer.putInt(0); // alpha mask for RGB formats
 374         buffer.putInt(DDSCAPS_TEXTURE);
 375         buffer.putInt(0); // ddsCaps2
 376         buffer.position(buffer.position() + 12); // 3 unused double-words
 377     }
 378
 379     protected static void buildHeaderDxt3(ByteBuffer buffer, int width, int height)
 380     {
 381         buffer.rewind();
 382         buffer.put((byte) 'D');
 383         buffer.put((byte) 'D');
 384         buffer.put((byte) 'S');
 385         buffer.put((byte) ' ');
 386         buffer.putInt(124);
 387         int flag = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT | DDSD_LINEARSIZE;
 388         buffer.putInt(flag);
 389         buffer.putInt(height);
 390         buffer.putInt(width);
 391         buffer.putInt(width * height);
 392         buffer.putInt(0); // depth
 393         buffer.putInt(0); // mipmap count
 394         buffer.position(buffer.position() + 44); // 11 unused double-words
 395         buffer.putInt(32); // pixel format size
 396         buffer.putInt(DDPF_FOURCC);
 397         buffer.put((byte) 'D');
 398         buffer.put((byte) 'X');
 399         buffer.put((byte) 'T');
 400         buffer.put((byte) '3');
 401         buffer.putInt(0); // bits per pixel for RGB (non-compressed) formats
 402         buffer.putInt(0); // rgb bit masks for RGB formats
 403         buffer.putInt(0); // rgb bit masks for RGB formats
 404         buffer.putInt(0); // rgb bit masks for RGB formats
 405         buffer.putInt(0); // alpha mask for RGB formats
 406         buffer.putInt(DDSCAPS_TEXTURE);
 407         buffer.putInt(0); // ddsCaps2
 408         buffer.position(buffer.position() + 12); // 3 unused double-words
 409     }
 410
 411     protected static int[] determineExtremeColors(Color[] colors)
 412     {
 413         int farthest = Integer.MIN_VALUE;
 414         int[] ex = new int[2];
 415
 416         for (int i = 0; i < colors.length - 1; i++)
 417         {
 418             for (int j = i + 1; j < colors.length; j++)
 419             {
 420                 int d = distance(colors[i], colors[j]);
 421                 if (d > farthest)
 422                 {
 423                     farthest = d;
 424                     ex[0] = i;
 425                     ex[1] = j;
 426                 }
 427             }
 428         }
 429
 430         return ex;
 431     }
 432
 433     protected static long computeBitMask(Color[] colors, int[] extremaIndices)
 434     {
 435         Color[] colorPoints = new Color[] {null, null, new Color(), new Color()};
 436         colorPoints[0] = colors[extremaIndices[0]];
 437         colorPoints[1] = colors[extremaIndices[1]];
 438         if (colorPoints[0].equals(colorPoints[1]))
 439             return 0;
 440
 441 //        colorPoints[0].r = (colorPoints[0].r & 0xF8) | (colorPoints[0].r >> 5 );
 442 //        colorPoints[0].g = (colorPoints[0].g & 0xFC) | (colorPoints[0].g >> 6 );
 443 //        colorPoints[0].b = (colorPoints[0].b & 0xF8) | (colorPoints[0].b >> 5 );
 444 //
 445 //        colorPoints[1].r = (colorPoints[1].r & 0xF8) | (colorPoints[1].r >> 5 );
 446 //        colorPoints[1].g = (colorPoints[1].g & 0xFC) | (colorPoints[1].g >> 6 );
 447 //        colorPoints[1].b = (colorPoints[1].b & 0xF8) | (colorPoints[1].b >> 5 );
 448
 449         colorPoints[2].r = (2 * colorPoints[0].r + colorPoints[1].r + 1) / 3;
 450         colorPoints[2].g = (2 * colorPoints[0].g + colorPoints[1].g + 1) / 3;
 451         colorPoints[2].b = (2 * colorPoints[0].b + colorPoints[1].b + 1) / 3;
 452         colorPoints[3].r = (colorPoints[0].r + 2 * colorPoints[1].r + 1) / 3;
 453         colorPoints[3].g = (colorPoints[0].g + 2 * colorPoints[1].g + 1) / 3;
 454         colorPoints[3].b = (colorPoints[0].b + 2 * colorPoints[1].b + 1) / 3;
 455
 456         long bitmask = 0;
 457         for (int i = 0; i < colors.length; i++)
 458         {
 459             int closest = Integer.MAX_VALUE;
 460             int mask = 0;
 461             for (int j = 0; j < colorPoints.length; j++)
 462             {
 463                 int d = distance(colors[i], colorPoints[j]);
 464                 if (d < closest)
 465                 {
 466                     closest = d;
 467                     mask = j;
 468                 }
 469             }
 470             bitmask |= mask << i * 2;
 471         }
 472
 473         return bitmask;
 474     }
 475
 476     protected static int getPixel565(Color color)
 477     {
 478         int r = color.r >> 3;
 479         int g = color.g >> 2;
 480         int b = color.b >> 3;
 481         return r << 11 | g << 5 | b;
 482     }
 483
 484     protected static Color getColor565(int pixel)
 485     {
 486         Color color = new Color();
 487
 488         color.r = (int) (((long) pixel) & 0xf800) >> 11;
 489         color.g = (int) (((long) pixel) & 0x07e0) >> 5;
 490         color.b = (int) (((long) pixel) & 0x001f);
 491
 492         return color;
 493     }
 494
 495     protected static Color getColor888(int r8g8b8)
 496     {
 497         return new Color(
 498             (int) (((long) r8g8b8) & 0xff0000) >> 16,
 499             (int) (((long) r8g8b8) & 0x00ff00) >> 8,
 500             (int) (((long) r8g8b8) & 0x0000ff)
 501         );
 502     }
 503
 504     protected static Color[] getColors888(int[] pixels)
 505     {
 506         Color[] colors = new Color[pixels.length];
 507
 508         for (int i = 0; i < pixels.length; i++)
 509         {
 510             colors[i] = new Color();
 511             colors[i].r = (int) (((long) pixels[i]) & 0xff0000) >> 16;
 512             colors[i].g = (int) (((long) pixels[i]) & 0x00ff00) >> 8;
 513             colors[i].b = (int) (((long) pixels[i]) & 0x0000ff);
 514         }
 515
 516         return colors;
 517     }
 518
 519     protected static int distance(Color ca, Color cb)
 520     {
 521         return (cb.r - ca.r) * (cb.r - ca.r) + (cb.g - ca.g) * (cb.g - ca.g) + (cb.b - ca.b) * (cb.b - ca.b);
 522     }
 523
 524     protected static void equalTransparentCase(TransparentColor[] colors, int[] extremaIndices, short value)
 525     {
 526         // we want extremaIndices[0] to be greater than extremaIndices[1]
 527
 528         if (value == 0)
 529         {
 530             // transparent
 531             colors[extremaIndices[0]] = TransparentColor.OFF_TRANSPARENT;
 532         }
 533         /*else
 534         {
 535             // not transparent anywhere - it's all one colour, so we don't need to bother making changes
 536         }*/
 537
 538     }
 539
 540     protected static int distance(TransparentColor ca, TransparentColor cb)
 541     {
 542         return (cb.r - ca.r) * (cb.r - ca.r) + (cb.g - ca.g) * (cb.g - ca.g) + (cb.b - ca.b) * (cb.b - ca.b)
 543             + (cb.a - ca.a) * (cb.a - ca.a);
 544     }
 545
 546 //    public static void main(String[] args)
 547 //    {
 548 //        try
 549 //        {
 550 //            String fileName = "testdata/0000_0001";
 551 //            ByteBuffer buffer = convertToDxt1NoTransparency(new File(fileName + ".jpg"));
 552 //            buffer.rewind();
 553 //            FileOutputStream fos = new FileOutputStream(fileName + ".dds");
 554 //            channels.FileChannel channel = fos.getChannel();
 555 //            channel.write(buffer);
 556 //        }
 557 //        catch (IOException e)
 558 //        {
 559 //            e.printStackTrace();
 560 //        }
 561 //
 562 //        return;
 563 //    }
 564
 565     protected static long computeBitMask(TransparentColor[] colors, int[] extremaIndices)
 566     {
 567         TransparentColor[] colorPoints = {null, null, new TransparentColor(), new TransparentColor()};
 568
 569         colorPoints[0] = colors[extremaIndices[0]];
 570         colorPoints[1] = colors[extremaIndices[1]];
 571
 572         colorPoints[2].r = (colorPoints[0].r + colorPoints[1].r) / 2;
 573         colorPoints[2].g = (colorPoints[0].g + colorPoints[1].g) / 2;
 574         colorPoints[2].b = (colorPoints[0].b + colorPoints[1].b) / 2;
 575         colorPoints[2].a = 1;
 576
 577         colorPoints[3].r = 0;
 578         colorPoints[3].g = 0;
 579         colorPoints[3].b = 0;
 580         colorPoints[3].a = 0;
 581
 582         long bitmask = 0;
 583         for (int i = 0; i < colors.length; i++)
 584         {
 585             int closest = Integer.MAX_VALUE;
 586             int mask = 0;
 587             if (colors[i].a == 0)
 588             {
 589                 mask = 3;
 590             }
 591             else
 592             {
 593                 for (int j = 0; j < colorPoints.length; j++)
 594                 {
 595                     int d = distance(colors[i], colorPoints[j]);
 596                     if (d < closest)
 597                     {
 598                         closest = d;
 599                         mask = j;
 600                     }
 601                 }
 602             }
 603             bitmask |= mask << i * 2;
 604         }
 605
 606         return bitmask;
 607     }
 608
 609     protected static short getShort5551(TransparentColor color)
 610     {
 611         short s = 0;
 612         s |= ((color.r & 0x0f8) << 8) | ((color.g & 0x0f8) << 4) | ((color.b & 0x0f8) >> 3) | ((color.a & 0x0f8) >> 7);
 613 //        System.out.println(Integer.toBinaryString(s));
 614         return s;
 615     }
 616
 617     protected static int[] determineExtremeColors(TransparentColor[] colors)
 618     {
 619         int farthest = Integer.MIN_VALUE;
 620         int[] ex = {0, 0};
 621
 622         for (int i = 0; i < colors.length - 1; i++)
 623         {
 624             for (int j = i + 1; j < colors.length; j++)
 625             {
 626                 int d = distance(colors[i], colors[j]);
 627                 if (d > farthest)
 628                 {
 629                     farthest = d;
 630                     ex[0] = i;
 631                     ex[1] = j;
 632                 }
 633             }
 634         }
 635
 636         return ex;
 637     }
 638
 639     protected static TransparentColor[] getColors5551(int[] pixels)
 640     {
 641         TransparentColor colors[] = new TransparentColor[pixels.length];
 642
 643         for (int i = 0; i < pixels.length; i++)
 644         {
 645             colors[i] = generateColor5551(pixels[i]);
 646         }
 647         return colors;
 648     }
 649
 650     protected static TransparentColor generateColor5551(int pixel)
 651     {
 652         short alpha = (short) (pixel >> 24);
 653         if ((alpha & 0xf0) == 0)
 654         {
 655             return TransparentColor.TRANSPARENT;
 656         }
 657
 658         // ok, it's not transparent - that's already been ruled out.
 659
 660         TransparentColor tc = new TransparentColor();
 661         tc.a = 0x000000ff;
 662         tc.r = (pixel & 0x00ff0000) >> 16;
 663         tc.g = (pixel & 0x0000ff00) >> 8;
 664         tc.b = (pixel & 0x000000ff);
 665
 666         return tc;
 667     }
 668
 669     protected static class TransparentColor
 670     {
 671         private static final TransparentColor TRANSPARENT = new TransparentColor(0, 0, 0, 0);
 672         private static final TransparentColor OFF_TRANSPARENT = new TransparentColor(0, 0, 1, 0);
 673         private int r, g, b, a;
 674
 675         private TransparentColor()
 676         {
 677         }
 678
 679         private TransparentColor(int r, int g, int b, int a)
 680         {
 681             this.r = r;
 682             this.g = g;
 683             this.b = b;
 684             this.a = a;
 685         }
 686
 687         public boolean equals(Object o)
 688         {
 689             if (this == o)
 690                 return true;
 691             if (o == null || getClass() != o.getClass())
 692                 return false;
 693
 694             final gov.nasa.worldwind.DDSConverter.TransparentColor that =
 695                 (gov.nasa.worldwind.DDSConverter.TransparentColor) o;
 696
 697             if (a != that.a)
 698                 return false;
 699             if (b != that.b)
 700                 return false;
 701             if (g != that.g)
 702                 return false;
 703             //noinspection RedundantIfStatement
 704             if (r != that.r)
 705                 return false;
 706
 707             return true;
 708         }
 709
 710         public int hashCode()
 711         {
 712             int result;
 713             result = r;
 714             result = 29 * result + g;
 715             result = 29 * result + b;
 716             result = 29 * result + a;
 717             return result;
 718         }
 719
 720         public String toString()
 721         {
 722             return "TransColor argb: " + this.a + ", " + this.r + ", " + this.g + ", " + this.b;
 723         }
 724     }
 725 }