Android 中的缓冲图像

Question

我有一个应用程序可以拍摄相机照片并将其以 jpeg 格式保存在 SD 卡上。我想用球形滤镜扭曲图片。我可以将 jpeg 读取为位图，但我发现的代码是否会扭曲缓冲图像。我知道 android 不支持 javax.imageio 但有没有办法将 jpeg 作为缓冲图像读入内存？

谢谢垫子。

/*
Copyright 2006 Jerry Huxtable

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package com.jhlabs.image;

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;

/**
 * A filter which simulates a lens placed over an image.
 */
public class SphereFilter extends TransformFilter {

    private float a = 0;
    private float b = 0;
    private float a2 = 0;
    private float b2 = 0;
    private float centreX = 0.5f;
    private float centreY = 0.5f;
    private float refractionIndex = 1.5f;

    private float icentreX;
    private float icentreY;

    public SphereFilter() {
        setEdgeAction( CLAMP );
        setRadius( 100.0f );
    }

    /**
     * Set the index of refaction.
     * @param refractionIndex the index of refaction
     * @see #getRefractionIndex
     */
    public void setRefractionIndex(float refractionIndex) {
        this.refractionIndex = refractionIndex;
    }

    /**
     * Get the index of refaction.
     * @return the index of refaction
     * @see #setRefractionIndex
     */
    public float getRefractionIndex() {
        return refractionIndex;
    }

    /**
     * Set the radius of the effect.
     * @param r the radius
     * @min-value 0
     * @see #getRadius
     */
    public void setRadius(float r) {
        this.a = r;
        this.b = r;
    }

    /**
     * Get the radius of the effect.
     * @return the radius
     * @see #setRadius
     */
    public float getRadius() {
        return a;
    }

    /**
     * Set the centre of the effect in the X direction as a proportion of the image size.
     * @param centreX the center
     * @see #getCentreX
     */
    public void setCentreX( float centreX ) {
        this.centreX = centreX;
    }

    public float getCentreX() {
        return centreX;
    }

    /**
     * Set the centre of the effect in the Y direction as a proportion of the image size.
     * @param centreY the center
     * @see #getCentreY
     */
    public void setCentreY( float centreY ) {
        this.centreY = centreY;
    }

    /**
     * Get the centre of the effect in the Y direction as a proportion of the image size.
     * @return the center
     * @see #setCentreY
     */
    public float getCentreY() {
        return centreY;
    }

    /**
     * Set the centre of the effect as a proportion of the image size.
     * @param centre the center
     * @see #getCentre
     */
    public void setCentre( Point2D centre ) {
        this.centreX = (float)centre.getX();
        this.centreY = (float)centre.getY();
    }

    /**
     * Get the centre of the effect as a proportion of the image size.
     * @return the center
     * @see #setCentre
     */
    public Point2D getCentre() {
        return new Point2D.Float( centreX, centreY );
    }

    public BufferedImage filter( BufferedImage src, BufferedImage dst ) {
        int width = src.getWidth();
        int height = src.getHeight();
        icentreX = width * centreX;
        icentreY = height * centreY;
        if (a == 0)
            a = width/2;
        if (b == 0)
            b = height/2;
        a2 = a*a;
        b2 = b*b;
        return super.filter( src, dst );
    }

    protected void transformInverse(int x, int y, float[] out) {
        float dx = x-icentreX;
        float dy = y-icentreY;
        float x2 = dx*dx;
        float y2 = dy*dy;
        if (y2 >= (b2 - (b2*x2)/a2)) {
            out[0] = x;
            out[1] = y;
        } else {
            float rRefraction = 1.0f / refractionIndex;

            float z = (float)Math.sqrt((1.0f - x2/a2 - y2/b2) * (a*b));
            float z2 = z*z;

            float xAngle = (float)Math.acos(dx / Math.sqrt(x2+z2));
            float angle1 = ImageMath.HALF_PI - xAngle;
            float angle2 = (float)Math.asin(Math.sin(angle1)*rRefraction);
            angle2 = ImageMath.HALF_PI - xAngle - angle2;
            out[0] = x - (float)Math.tan(angle2)*z;

            float yAngle = (float)Math.acos(dy / Math.sqrt(y2+z2));
            angle1 = ImageMath.HALF_PI - yAngle;
            angle2 = (float)Math.asin(Math.sin(angle1)*rRefraction);
            angle2 = ImageMath.HALF_PI - yAngle - angle2;
            out[1] = y - (float)Math.tan(angle2)*z;
        }
    }

    public String toString() {
        return "Distort/Sphere...";
    }

}

Answer 1

不可以。您不能使用 BufferedImage，因为正如您所说，javax.imageio 不在 Android SDK 中。但是，Bitmap 类确实支持使用 getPixel() 和 getPixels() 方法您应该能够使用它们来执行您想要执行的任何类型的图像转换。

Answer 2

BufferedImage 是 AWT 的一部分，未在 Java 中实现。您需要为您想要做的事情找到 Android 替代品。

阅读此内容：

http://developer.android.com/guide/topics/graphics/索引.html

Answer 3

您可以使用 Bitmap 而不是 bufferedimage，但这不会解决您的问题，因为您需要对 TransformFilter 进行更改，因为此代码最终会调用 super.filter( src, dst ); 来完成实际工作。如果您的唯一目标是实现球形过滤器，此链接提供了直接球形过滤器的算法，更容易移植到 Android。