配列

色

RGB

16進

 色

0

白

R:255, G:255, B:255

0xffffff

 ■

1

：

R:212, G:212, B:212

0xd4d4d4

 ■

2

：

R:170, G:170, B:170

0xaaaaaa

 ■

3

灰色

R:128, G:128, B:128

0x808080

 ■

4

：

R:85, G:85, B:85

0x555555

 ■

5

：

R:43, G:43, B:43

0x2b2b2b

 ■

6

黒

R:0, G:0, B:0

0x000000

 ■

配列

色

RGB

16進

 色

0

赤

R:255, G:0, B:0

0xff0000

 ■

1

橙

R:255, G:128, B:0

0xff8000

 ■

2

黄

R:255, G:255, B:0

0xffff00

 ■

3

緑

R:0, G:255, B:0

0x00ff00

 ■

4

シアン

R:0, G:255, B:255

0x00ffff

 ■

5

青

R:0, G:0, B:255

0x0000ff

 ■

6

紫

R:255, G:0, B:255

0xff00ff

 ■

 /**
 * マスク用イメージフィルタ
 */
public class MaskFilter extends RGBImageFilter {
  // パレット（派生先で配列を指定します）
  protected int[][] m_palette;
  // マスクカラー（RGB）
  public int m_mask = 0xff00ff00;
  // 透明レベル（0 ～ 255）
  public int m_transparent = 0xffffffff;
  // 輝度モード
  public boolean m_brightMode = false;
  // 輝度レベル（0 ～ 255）
  public int m_bright = 0;

  /**
   * コンストラクタ
   */
  MaskFilter() {
    canFilterIndexColorModel = true;
  }

  /**
   * コンストラクタ
   * @param  mask  マスク値（RGB）
   * @param  transparent  透過レベル（0 ～ 255）
   */
  public MaskFilter(int mask, int transparent) {
    canFilterIndexColorModel = true;
    m_mask = mask;
    m_transparent = (transparent << 24) | 0x00ffffff;
  }

  /**
   * ピクセルフィルターコールバック<br>
   * 詳細は JDK ImageFilter クラスを参照
   * @param  x    ピクセル X 座標
   * @param  y    ピクセル Y 座標
   * @param  rgb    RGB 値
   */
  public int filterRGB(int x, int y, int rgb) {
    // マスクチェック
    if(rgb == m_mask) {
      return 0;
    }

    // パレットが無い場合は明るさのみをフィルタリング
    if(m_palette == null) {
      // 輝度モードの場合は 1 ピクセルごとに輝度を設定します
      if(m_brightMode == true) {
        int r = (((0x00ff0000 & rgb) >> 16) + m_bright);
        if(r > 256) {r = 255;}
        if(r < 0) {r = 0;}
        r &= 0x000000ff;
        int g = (((0x0000ff00 & rgb) >> 8) + m_bright);
        if(g > 256) {g = 255;}
        if(g < 0) {g = 0;}
        g &= 0x000000ff;
        int b = ((0x000000ff & rgb) + m_bright);
        if(b > 256) {b = 255;}
        if(b < 0) {b = 0;}
        b &= 0x000000ff;
        rgb = (rgb & 0xff000000) | ((r << 16) | (g << 8) | b);
      }
      // 明るさを考慮して配色を
      return (rgb & m_transparent);
    }

    // 一致したパレットを置き換えます
    int count = m_palette.length;
    for(int i = 0; i < count; i++) {
      if((m_palette[i][0] & 0x00ffffff) == (rgb & 0x00ffffff)) {
        rgb = m_palette[i][1];
        break;
      }
    }

    // 輝度モードの場合は 1 ピクセルごとに輝度を設定します
    if(m_brightMode == true) {
      int r = (((0x00ff0000 & rgb) >> 16) + m_bright);
      if(r > 256) {r = 255;}
      r &= 0x000000ff;
      int g = (((0x0000ff00 & rgb) >> 8) + m_bright);
      if(g > 256) {g = 255;}
      g &= 0x000000ff;
      int b = ((0x000000ff & rgb) + m_bright);
      if(b > 256) {b = 255;}
      b &= 0x000000ff;
      rgb = (rgb & 0x00ffffff) | ((r << 16) | (g << 8) | b);
    }
    // 明るさを考慮して配色を
    return (rgb & m_transparent);
  }
}

/**
 * 虹パレット
 */
public class RainbowPalette extends MaskFilter {
  // パレット（ベース配色→変換色）
  protected int[][] palette = {
    { 0xffffffff, 0xfff00000 },  // 0 白→赤
    { 0xffd4d4d4, 0xffff8000 },  // 1 ：→橙
    { 0xffaaaaaa, 0xffffff00 },  // 2 ：→黄
    { 0xff808080, 0xff00ff00 },  // 3 灰色→緑
    { 0xff555555, 0xff00ffff },  // 4 ：→シアン
    { 0xff2b2b2b, 0xff0000ff },  // 5 ：→青
    { 0xff000000, 0xffff00ff },  // 6 黒→紫
  };

  /**
   * コンストラクタ
   */
  public RainbowPalette() {
    super();

    // パレットをアタッチします
    m_palette = palette;
  }

  /**
   * コンストラクタ
   * @param  mask  マスク値（RGB）
   * @param  transparent  透過レベル（0 ～ 255）
   */
  public RainbowPalette(int mask, int transparent) {
    super(mask, transparent);

    // パレットをアタッチします
    m_palette = palette;
  }
}

/**
 * システムを管理するクラス
 * システム唯一の情報などを管理します
 */
public class Global {
  // 描画コンポーネント
  public static JPanel m_component;
  // ルートパス(ClassLoader)
  public static Class m_rootPath;
  // 透過用のイメージフィルタ
  public static MaskFilter m_maskFilter;

  /**
   * コンストラクタ
   */
  Global() {
    // ルートパスを設定します
    m_rootPath = getClass().getClassLoader().getClass();
    // マスク用のイメージフィルタを作成します
    m_maskFilter = new MaskFilter();
  }

  /**
   * 指定のファイルから URL を取得します
   * @param  filename ファイル名
   * @return URL
   */
  public static URL getURL(String filename) {
    return m_rootPath.getResource(filename);
  }
}

/**
 * 画像ツール
 */
public class ImageTool {
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   * @param imageFilter イメージフィルター
   * @param component コンポーネント
   */
  public static Image loadImage(
    String fileName,
    ImageFilter imageFilter,
    Component component) {
    // イメージを読み込みます
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Image srcImage = null;
    URL url = Global.getURL(fileName);
    if(url != null) {
      srcImage = toolkit.getImage(url);
    }
    if(srcImage == null) {
      return null;
    }
 
    MediaTracker mt = new MediaTracker(component);
    mt.addImage(srcImage, 0);
    try {
      mt.waitForID(0);
    } catch(Exception e) {}
 
    // ImageFilter を用いてフィルター処理イメージを作成します
    Image destImage = component.createImage(
      new FilteredImageSource(
      srcImage.getSource(), imageFilter));
      if(destImage == null) {
        return null;
    }

    mt.addImage(destImage, 1);
    try {
      mt.waitForID(1);
    } catch(Exception e) {}

    return destImage;
  }
 
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   */
  public static Image loadImage(String fileName) {
    return loadImage(fileName, Global.m_maskFilter, Global.m_component);
  }

  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   * @param imageFilter イメージフィルター
   */
  public static Image loadImage(String fileName, MaskFilter imageFilter) {
    return loadImage(fileName, imageFilter, Global.m_component);
  }
}

// グレースケールのビットマップの読み込み
Image grayImage = ImageTool("gray.png");

// 虹色のビットマップの読み込み
Image rainbowImage = ImageTool("gray.png", new RainbowPalette());

// 虹色を少し暗い色に
RainbowPalette palette = new RaindowPalette();
palette.m_brightMode = true;
palette.m_bright = -50;
Image grayImage = ImageTool("gray.png", palette);

// 更に半透明に
palette.m_transparent = 128;
Image rainbowImage = ImageTool("gray.png", palette);

/**
 * マスク用イメージフィルタ
 */
public class MaskFilter extends RGBImageFilter {
  // パレット（派生先で配列を指定します）
  protected int[][] m_palette;
  // マスクカラー（RGB）
  public int m_mask = 0xff00ff00;
  // 透明レベル（0 ～ 255）
  public int m_transparent = 0xffffffff;
  // 輝度モード
  public boolean m_brightMode = false;
  // 輝度レベル（0 ～ 255）
  public int m_bright = 0;

  /**
   * コンストラクタ
   */
  MaskFilter() {
    canFilterIndexColorModel = true;
  }

  /**
   * コンストラクタ
   * @param  mask  マスク値（RGB）
   * @param  transparent  透過レベル（0 ～ 255）
   */
  public MaskFilter(int mask, int transparent) {
    canFilterIndexColorModel = true;
    m_mask = mask;
    m_transparent = (transparent << 24) | 0x00ffffff;
  }

  /**
   * ピクセルフィルターコールバック<br>
   * 詳細は JDK ImageFilter クラスを参照
   * @param  x    ピクセル X 座標
   * @param  y    ピクセル Y 座標
   * @param  rgb    RGB 値
   */
  public int filterRGB(int x, int y, int rgb) {
    // マスクチェック
    if(rgb == m_mask) {
      return 0;
    }

    // パレットが無い場合は明るさのみをフィルタリング
    if(m_palette == null) {
      // 輝度モードの場合は 1 ピクセルごとに輝度を設定します
      if(m_brightMode == true) {
        int r = (((0x00ff0000 & rgb) >> 16) + m_bright);
        if(r > 256) {r = 255;}
        if(r < 0) {r = 0;}
        r &= 0x000000ff;
        int g = (((0x0000ff00 & rgb) >> 8) + m_bright);
        if(g > 256) {g = 255;}
        if(g < 0) {g = 0;}
        g &= 0x000000ff;
        int b = ((0x000000ff & rgb) + m_bright);
        if(b > 256) {b = 255;}
        if(b < 0) {b = 0;}
        b &= 0x000000ff;
        rgb = (rgb & 0xff000000) | ((r << 16) | (g << 8) | b);
      }
      // 明るさを考慮して配色を
      return (rgb & m_transparent);
    }

    // 一致したパレットを置き換えます
    int count = m_palette.length;
    for(int i = 0; i < count; i++) {
      if((m_palette[i][0] & 0x00ffffff) == (rgb & 0x00ffffff)) {
        rgb = m_palette[i][1];
        break;
      }
    }

    // 輝度モードの場合は 1 ピクセルごとに輝度を設定します
    if(m_brightMode == true) {
      int r = (((0x00ff0000 & rgb) >> 16) + m_bright);
      if(r > 256) {r = 255;}
      r &= 0x000000ff;
      int g = (((0x0000ff00 & rgb) >> 8) + m_bright);
      if(g > 256) {g = 255;}
      g &= 0x000000ff;
      int b = ((0x000000ff & rgb) + m_bright);
      if(b > 256) {b = 255;}
      b &= 0x000000ff;
      rgb = (rgb & 0x00ffffff) | ((r << 16) | (g << 8) | b);
    }
    // 明るさを考慮して配色を
    return (rgb & m_transparent);
  }
}

/**
 * システムを管理するクラス
 * システム唯一の情報などを管理します
 */
public class Global {
  // 描画コンポーネント
  public static JPanel m_component;
  // ルートパス(ClassLoader)
  public static Class m_rootPath;
  // 透過用のイメージフィルタ
  public static MaskFilter m_maskFilter;

  /**
   * コンストラクタ
   */
  Global() {
    // ルートパスを設定します
    m_rootPath = getClass().getClassLoader().getClass();
    // マスク用のイメージフィルタを作成します
    m_maskFilter = new MaskFilter();
  }

  /**
   * 指定のファイルから URL を取得します
   * @param  filename ファイル名
   * @return URL
   */
  public static URL getURL(String filename) {
    return m_rootPath.getResource(filename);
  }
}

/**
 * 画像ツール
 */
public class ImageTool {
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   * @param imageFilter イメージフィルター
   * @param component コンポーネント
   */
  public static Image loadImage(
    String fileName,
    ImageFilter imageFilter,
    Component component) {
    // イメージを読み込みます
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Image srcImage = null;
    URL url = Global.getURL(fileName);
    if(url != null) {
      srcImage = toolkit.getImage(url);
    }
    if(srcImage == null) {
      return null;
    }
 
    MediaTracker mt = new MediaTracker(component);
    mt.addImage(srcImage, 0);
    try {
      mt.waitForID(0);
    } catch(Exception e) {}
 
    // ImageFilter を用いてフィルター処理イメージを作成します
    Image destImage = component.createImage(
      new FilteredImageSource(
      srcImage.getSource(), imageFilter));
      if(destImage == null) {
        return null;
    }

    mt.addImage(destImage, 1);
    try {
      mt.waitForID(1);
    } catch(Exception e) {}

    return destImage;
  }
  
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   */
  public static Image loadImage(String fileName) {
    return loadImage(fileName, Global.m_maskFilter, Global.m_component);
  }
}

  public int filterRGB(int x, int y, int rgb) {
    // マスクチェック
    if(rgb == m_mask) {
      return 0;
    }

　　　　：

/**
 * システムを管理するクラス
 * システム唯一の情報などを管理します
 */
public class Global {
  // 描画コンポーネント
  public static JPanel m_component;
  // ルートパス(ClassLoader)
  public static Class m_rootPath;

  /**
   * コンストラクタ
   */
  Global() {
    // ルートパスを設定します
    m_rootPath = getClass().getClassLoader().getClass();
  }

  /**
   * 指定のファイルから URL を取得します
   * @param  filename ファイル名
   * @return URL
   */
  public static URL getURL(String filename) {
    return m_rootPath.getResource(filename);
  }
}

/**
 * 画像ツール
 */
public class ImageTool {
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   * @param component コンポーネント
   */
  public static Image loadImage(String fileName, Component component) {
    // イメージを読み込みます
    Toolkit toolkit = Toolkit.getDefaultToolkit();
    Image srcImage = null;
    URL url = Global.getURL(fileName);
    if(url != null) {
      srcImage = toolkit.getImage(url);
    }
    if(srcImage == null) {
      return null;
    }
 
    MediaTracker mt = new MediaTracker(component);
    mt.addImage(srcImage, 0);
    try {
      mt.waitForID(0);
    } catch(Exception e) {}
   
    return srcImage;
  }
   
  /**
   * イメージを取得します
   * @param fileName 画像ファイル名
   */
  public static Image loadImage(String fileName) {
    return loadImage(fileName, Global.m_component);
  }
}