Android中的BufferedImage

Question

我有一个应用程序，需要一个摄像头图片并保存在SD卡上作为jpeg。我想用spherize过滤器来扭曲图片。我可以将jpeg读取到位图中，但是我发现代码是否会扭曲bufferedimage。我明白，javax.imageio不支持在Android中，但有没有办法将jpeg作为bufferedimage读入内存？

谢谢。

/* 
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

号，因为像你说的，javax.imageio中是不是在Android SDK中不能使用的BufferedImage。但是，Bitmap类支持使用getPixel()和getPixels()方法获取单个像素，因此您应该可以使用这些方法来执行任何类型的图像转换。

Answer 2

BufferedImage是AWT的一部分，它没有在Java中实现。你需要找到你想要做的事情的Android替代品。

阅读：

http://developer.android.com/guide/topics/graphics/index.html

Answer 3

您可以使用位图而不是bufferedimage，但这不会解决您的问题，因为您需要对TransformFilter进行更改，因为此代码最终会调用执行实际作业的super.filter(src, dst);。如果你唯一的目标是实现spherize过滤器，this link为spherize过滤器提供了一个直接的算法，这将更容易移植到Android。