java - Javaビットマップフォント：1ビット画像をさまざまな色でブリットする

Question

JavaAWTベースのアプリケーションで単純なビットマップフォントの描画を実装したいと思います。アプリケーションはGraphics、単純なアルゴリズムを実装したいオブジェクトを描画します。

1）ファイルをロードします（おそらくを使用してImageIO.read(new File(fileName))）。これは、次のような1ビットのPNGです。

8*8ビットマップフォント

つまり、8*8文字の16*16（Unicodeをサポートしたい場合は16 *多く）のマトリックスです。黒は背景色に対応し、白は前景色に対応します。

2）文字列を文字ごとに描画し、このビットマップの関連部分をターゲットにブリットしますGraphics。これまでのところ、私はそのようなものでしか成功していません：

    int posX = ch % 16;
    int posY = ch / 16;

    int fontX = posX * CHAR_WIDTH;
    int fontY = posY * CHAR_HEIGHT;

    g.drawImage(
            font,
            dx, dy, dx + CHAR_WIDTH, dy + CHAR_HEIGHT,
            fontX, fontY, fontX + CHAR_WIDTH, fontY + CHAR_HEIGHT,
            null
    );

それは機能しますが、残念ながら、テキストをそのままブリットします。つまり、白黒を希望の前景色と背景色に置き換えることはできず、背景を透明にすることさえできません。

したがって、問題は次のとおりです。Javaには、1ビットビットビットの一部を別のビットビットにブリットし、ブリッティングの過程で色付けする（つまり、すべての0ピクセルを1つの特定の色とすべての1ピクセルに置き換える）簡単な（そして高速な）方法がありますか？他のと）？

私はいくつかの解決策を研究しましたが、それらはすべて私には最適ではないように見えます：

このソリューションで概説されているように、カスタムカラー化BufferedImageOpを使用すると、機能するはずですが、すべてのブリット操作の前にビットマップを再カラー化することは非常に非効率的であるようです。
複数の32ビットRGBAPNGを使用し、アルファチャネルを黒ピクセルの場合は0に、前景の場合は最大に設定します。必要なすべての前景色は、独自の事前レンダリングされたビットマップを取得する必要があります。このようにして、背景を透明にし、ブリットする前に長方形として個別に描画し、フォントで1つのビットマップを選択し、目的の色で事前に色付けして、その長方形の上にその一部を描画できます。私には大きなやり過ぎのように思えます-そしてこのオプションをさらに悪化させるのは-それは前景色の数を比較的少量に制限します（つまり、数百万ではなく数百または数千のビットマップのように現実的にロードして保持できます）
このソリューションで概説されているように、カスタムフォントのバンドルとロードは機能しますが、 Font＃createFontのドキュメントで確認できる限り、AWTFontはベクターベースのフォントでのみ機能し、ビットマップベースでは機能しないようです。

そのような機能を実装するライブラリはすでにあるのでしょうか？または、 lwjglのようなより高度なグラフィックライブラリに切り替える時が来ましたか？

ベンチマーク結果

簡単なテストでいくつかのアルゴリズムをテストしました。2つの文字列（それぞれ71文字）があり、同じ場所に次々と連続して描画します。

    for (int i = 0; i < N; i++) {
        cv.putString(5, 5, STR, Color.RED, Color.BLUE);
        cv.putString(5, 5, STR2, Color.RED, Color.BLUE);
    }

次に、かかった時間を測定し、速度を計算します。1秒あたりの文字数と1秒あたりの文字数です。これまでにテストしたさまざまな実装により、次の結果が得られます。

ビットマップフォント、16 * 16文字ビットマップ：10991文字列/秒、780391文字/秒
ビットマップフォント、分割前の画像：11048文字列/秒、784443文字/秒
g.drawString（）：8952文字列/秒、635631文字/秒
LookupOpおよびByteLookupTableを使用して色付けされた色付きビットマップフォント：404文字列/秒、28741文字/秒

score 3 · Accepted Answer

各ビットマップをShape（またはそれらの多く）に変換して、を描画することができShapeます。を取得するプロセスについては、ギザギザのパスのスムージングを参照してくださいShape。

例えば

500以上のFPS？！？

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import java.util.Random;

/* Gain the outline of an image for further processing. */
class ImageShape {

    private BufferedImage image;

    private BufferedImage ImageShape;
    private Area areaOutline = null;
    private JLabel labelOutline;

    private JLabel output;
    private BufferedImage anim;
    private Random random = new Random();
    private int count = 0;
    private long time = System.currentTimeMillis();
    private String rate = "";

    public ImageShape(BufferedImage image) {
        this.image = image;
    }

    public void drawOutline() {
        if (areaOutline!=null) {
            Graphics2D g = ImageShape.createGraphics();
            g.setColor(Color.WHITE);
            g.fillRect(0,0,ImageShape.getWidth(),ImageShape.getHeight());

            g.setColor(Color.RED);
            g.setClip(areaOutline);
            g.fillRect(0,0,ImageShape.getWidth(),ImageShape.getHeight());
            g.setColor(Color.BLACK);
            g.setClip(null);
            g.draw(areaOutline);

            g.dispose();
        }
    }

    public Area getOutline(Color target, BufferedImage bi) {
        // construct the GeneralPath
        GeneralPath gp = new GeneralPath();

        boolean cont = false;
        int targetRGB = target.getRGB();
        for (int xx=0; xx<bi.getWidth(); xx++) {
            for (int yy=0; yy<bi.getHeight(); yy++) {
                if (bi.getRGB(xx,yy)==targetRGB) {
                    if (cont) {
                        gp.lineTo(xx,yy);
                        gp.lineTo(xx,yy+1);
                        gp.lineTo(xx+1,yy+1);
                        gp.lineTo(xx+1,yy);
                        gp.lineTo(xx,yy);
                    } else {
                        gp.moveTo(xx,yy);
                    }
                    cont = true;
                } else {
                    cont = false;
                }
            }
            cont = false;
        }
        gp.closePath();

        // construct the Area from the GP & return it
        return new Area(gp);
    }

    public JPanel getGui() {
        JPanel images = new JPanel(new GridLayout(1,2,2,2));
        JPanel  gui = new JPanel(new BorderLayout(3,3));

        JPanel originalImage =  new JPanel(new BorderLayout(2,2));
        final JLabel originalLabel = new JLabel(new ImageIcon(image));

        originalImage.add(originalLabel);


        images.add(originalImage);

        ImageShape = new BufferedImage(
            image.getWidth(),
            image.getHeight(),
            BufferedImage.TYPE_INT_RGB
            );

        labelOutline = new JLabel(new ImageIcon(ImageShape));
        images.add(labelOutline);

        anim = new BufferedImage(
            image.getWidth()*2,
            image.getHeight()*2,
            BufferedImage.TYPE_INT_RGB);
        output = new JLabel(new ImageIcon(anim));
        gui.add(output, BorderLayout.CENTER);

        updateImages();

        gui.add(images, BorderLayout.NORTH);

        animate();

        ActionListener al = new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                animate();
            }
        };
        Timer timer = new Timer(1,al);
        timer.start();

        return gui;
    }

    private void updateImages() {
        areaOutline = getOutline(Color.BLACK, image);

        drawOutline();
    }

    private void animate() {
        Graphics2D gr = anim.createGraphics();
        gr.setColor(Color.BLUE);
        gr.fillRect(0,0,anim.getWidth(),anim.getHeight());

        count++;
        if (count%100==0) {
            long now = System.currentTimeMillis();
            long duration = now-time;
            double fraction = (double)duration/1000;
            rate = "" + (double)100/fraction;
            time  = now;
        }
        gr.setColor(Color.WHITE);
        gr.translate(0,0);
        gr.drawString(rate, 20, 20);

        int x = random.nextInt(image.getWidth());
        int y = random.nextInt(image.getHeight());
        gr.translate(x,y);

        int r = 128+random.nextInt(127);
        int g = 128+random.nextInt(127);
        int b = 128+random.nextInt(127);
        gr.setColor(new Color(r,g,b));

        gr.draw(areaOutline);

        gr.dispose();
        output.repaint();
    }

    public static void main(String[] args) throws Exception {
        int size = 150;
        final BufferedImage outline = javax.imageio.ImageIO.read(new java.io.File("img.gif"));

        ImageShape io = new ImageShape(outline);

        JFrame f = new JFrame("Image Outline");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(io.getGui());
        f.pack();
        f.setResizable(false);
        f.setLocationByPlatform(true);
        f.setVisible(true);
    }
}

ただし、青い画像の左上にあるFPSカウントには10倍の誤差があることを理解する必要があります。50 FPS信じられましたが、500FPSは間違っているようです。

score 1 · Accepted Answer

さて、私は最良の解決策を見つけたようです。成功の秘訣は、基盤となるAWT構造の生のピクセル配列にアクセスすることでした。初期化は次のようになります。

public class ConsoleCanvas extends Canvas {
    protected BufferedImage buffer;
    protected int w;
    protected int h;
    protected int[] data;

    public ConsoleCanvas(int w, int h) {
        super();
        this.w = w;
        this.h = h;
    }

    public void initialize() {
        data = new int[h * w];

        // Fill data array with pure solid black
        Arrays.fill(data, 0xff000000);

        // Java's endless black magic to get it working
        DataBufferInt db = new DataBufferInt(data, h * w);
        ColorModel cm = ColorModel.getRGBdefault();
        SampleModel sm = cm.createCompatibleSampleModel(w, h);
        WritableRaster wr = Raster.createWritableRaster(sm, db, null);
        buffer = new BufferedImage(cm, wr, false, null);
    }

    @Override
    public void paint(Graphics g) {
        update(g);
    }

    @Override
    public void update(Graphics g) {
        g.drawImage(buffer, 0, 0, null);
    }
}

bufferこの後、キャンバスの更新でブリットできるものと、ARGB4バイトintの基礎となる配列の両方があります- data。

単一の文字は次のように描くことができます：

private void putChar(int dx, int dy, char ch, int fore, int back) {
    int charIdx = 0;
    int canvasIdx = dy * canvas.w + dx;
    for (int i = 0; i < CHAR_HEIGHT; i++) {
        for (int j = 0; j < CHAR_WIDTH; j++) {
            canvas.data[canvasIdx] = font[ch][charIdx] ? fore : back;
            charIdx++;
            canvasIdx++;
        }
        canvasIdx += canvas.w - CHAR_WIDTH;
    }
}

これは単純なboolean[][]配列を使用しており、最初のインデックスは文字を選択し、2番目のインデックスは生の1ビット文字のピクセルデータを反復処理します（true =>前景、false =>背景）。

すぐに、Javaターミナルエミュレーションクラスセットの一部として完全なソリューションを公開しようと思います。

このソリューションは、印象的な26007文字列/秒または1846553文字/秒のベンチマークです。これは、以前の最高の非カラー化の2.3倍の速度ですdrawImage()。

java - Javaビットマップフォント：1ビット画像をさまざまな色でブリットする

ベンチマーク結果

2 に答える 2

例えば

Related

Reference