it-swarm.com.de

Quadratbild zuschneiden - programmgesteuert

ich suchte nach einem vergangenen Tag und war nicht erfolgreich.

ich bekomme das Bild von API und lade es mit dem folgenden Code in eine Bitmap-Datei herunter.

private Bitmap DownloadImage(String URL) 
    {
        Bitmap bitmap = null;
        InputStream in = null;
        try 
        {
            in = OpenHttpConnection(URL);
            bitmap = BitmapFactory.decodeStream(in);
            in.close();
        }
        catch (IOException e1) 
        {
            e1.printStackTrace();
        }
        return bitmap;
    }

    private InputStream OpenHttpConnection(String urlString) throws IOException 
    {
        InputStream in = null;
        int response = -1;

        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();

        if (!(conn instanceof HttpURLConnection))
            throw new IOException("Not an HTTP connection");

        try 
        {
            HttpURLConnection httpConn = (HttpURLConnection) conn;
            httpConn.setAllowUserInteraction(false);
            httpConn.setInstanceFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.connect();

            response = httpConn.getResponseCode();
            if (response == HttpURLConnection.HTTP_OK) 
            {
                in = httpConn.getInputStream();
            }
        }
        catch (Exception ex) 
        {
            throw new IOException("Error connecting");
        }
        return in;
    }

Und ich bekomme das Bild als Quadrat und ich möchte die vier Ecken beschneiden und es zu einem kreisförmigen Bild machen. Gibt es einen möglichen Weg zu erreichen?

Alle verwandten Antworten werden begrüßt. Danke im Voraus .

20
VIGNESH
public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        DrawingView dv = new DrawingView(this);
        setContentView(dv);
    }

    class DrawingView extends View {
        Bitmap bitmap;

        public DrawingView(Context context) {
            super(context);
            bitmap = BitmapFactory.decodeResource(context.getResources(),
                    R.drawable.glossy_overlay);

        }

        @Override
        public void onDraw(Canvas canvas) {
            Paint paint = new Paint();
            // Paint.setColor(Color.CYAN);
            canvas.drawBitmap(getclip(), 30, 20, Paint);
        }

        public Bitmap getclip() {
            Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
                    bitmap.getHeight(), Config.ARGB_8888);
            Canvas canvas = new Canvas(output);
            final int color = 0xff424242;
            final Paint paint = new Paint();
            final Rect rect = new Rect(0, 0, bitmap.getWidth(),
                    bitmap.getHeight());

            Paint.setAntiAlias(true);
            canvas.drawARGB(0, 0, 0, 0);
            // Paint.setColor(color);
            canvas.drawCircle(bitmap.getWidth() / 2,
                    bitmap.getHeight() / 2, bitmap.getWidth() / 2, Paint);
            Paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
            canvas.drawBitmap(bitmap, rect, rect, Paint);
            return output;
        }
    }
}
20
Raghunandan

Sobald die Bitmap abgerufen wurde, kann RoundedBitmapDrawableFactory verwendet werden, um ein RoundedBitmapDrawable aus der v4 Support Library zu erstellen. Dieses Drawable kann dann auf ein ImageView angewendet oder direkt auf ein Canvas gezogen werden.

// Create the RoundedBitmapDrawable.
RoundedBitmapDrawable roundDrawable = RoundedBitmapDrawableFactory.create(getResources(), bitmap);
roundDrawable.setCircular(true);

// Apply it to an ImageView.
ImageView imageView = (ImageView)findViewById(R.id.imageView);
imageView.setImageDrawable(roundDrawable);

// Alternatively, draw it to an canvas (e.g. in onDraw where a Canvas is available).
// setBounds since there's no View handling size and positioning.
roundDrawable.setBounds(left, top, right, bottom);
roundDrawable.draw(canvas);
17
Godfrey Duke

verwenden Sie die Funktion blow, um einen Kreis in der Bitmap zu zeichnen, und setzen Sie die eingekreiste Bitmap auf imageview

public static Bitmap getclip(Bitmap bitmap) {
    Bitmap output = Bitmap.createBitmap(bitmap.getWidth(),
            bitmap.getHeight(), Config.ARGB_8888);
    Canvas canvas = new Canvas(output);

    final Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());

    Paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    canvas.drawCircle(bitmap.getWidth() / 2, bitmap.getHeight() / 2,
            bitmap.getWidth() / 2, Paint);
    Paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
    canvas.drawBitmap(bitmap, rect, rect, Paint);
    return output;
}
14
actsai

Roman Nurik schlägt eine sehr direkte Verwendung von Shadern vor, um dies zu tun, mit einem benutzerdefinierten Zeichenelement. 

Ich ändere den Code ein wenig, um ein ovales Bild zu erstellen und habe mich selbst getestet. Die Wirkung und Leistung sind wirklich gut:

public  class StreamDrawable extends Drawable {
private static final boolean USE_VIGNETTE = true;

private final RectF mRect = new RectF();
private final BitmapShader mBitmapShader;
private final Paint mPaint;
private final int mMargin;

public StreamDrawable(Bitmap bitmap, int margin) {

    mBitmapShader = new BitmapShader(bitmap,
            Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);

    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setShader(mBitmapShader);

    mMargin = margin;
}

@Override
protected void onBoundsChange(Rect bounds) {
    super.onBoundsChange(bounds);
    mRect.set(mMargin, mMargin, bounds.width() - mMargin, bounds.height() - mMargin);

    if (USE_VIGNETTE) {
        RadialGradient vignette = new RadialGradient(
                mRect.centerX(), mRect.centerY() * 1.0f / 0.7f, mRect.centerX() * 1.3f,
                new int[] { 0, 0, 0x7f000000 }, new float[] { 0.0f, 0.7f, 1.0f },
                Shader.TileMode.CLAMP);

        Matrix oval = new Matrix();
        oval.setScale(1.0f, 0.7f);
        vignette.setLocalMatrix(oval);

        mPaint.setShader(
                new ComposeShader(mBitmapShader, vignette, PorterDuff.Mode.SRC_OVER));
    }
}

@Override
public void draw(Canvas canvas) {
    canvas.drawOval(mRect, mPaint);
}

@Override
public int getOpacity() {
    return PixelFormat.TRANSLUCENT;
}

@Override
public void setAlpha(int alpha) {
    mPaint.setAlpha(alpha);
}

@Override
public void setColorFilter(ColorFilter cf) {
    mPaint.setColorFilter(cf);
}
}
2
Renascienza

Dies kann einfach in XML durchgeführt werden. Bitte sehen Sie meine Antwort hier: https://stackoverflow.com/a/18287979/665930

<RelativeLayout
            Android:id="@+id/icon_layout"
            Android:layout_width="@dimen/icon_mask"
            Android:layout_height="@dimen/icon_mask"
            Android:layout_alignParentLeft="true"
            Android:layout_alignParentTop="true" >

            <ImageView
                Android:id="@+id/icon"
                Android:layout_width="@dimen/icon"
                Android:layout_height="@dimen/icon"
                Android:layout_centerInParent="true"
                Android:scaleType="fitXY" >
            </ImageView>

            <ImageView
                Android:id="@+id/icon_mask"
                Android:layout_width="@dimen/icon_mask"
                Android:layout_height="@dimen/icon_mask"
                Android:layout_centerInParent="true"
                Android:background="@drawable/circle"
                Android:scaleType="fitXY" >
            </ImageView>


 </RelativeLayout>


<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:Android="http://schemas.Android.com/apk/res/Android" Android:shape="oval" >
    <gradient Android:startColor="#00FFFFFF" Android:endColor="#00FFFFFF"
        Android:angle="270"/>
     <stroke Android:width="10dp" Android:color="#FFAAAAAA"/>
0
Ash

Ich habe die oben genannten Lösungen ausprobiert, aber keine hat für mich gut funktioniert. Dies ist darauf zurückzuführen, dass meine Handykamera keine quadratischen Bilder, sondern nur rechteckige Bilder macht. Also habe ich einige Änderungen in der @actsai-Lösung vorgenommen, um immer die kleinere Dimension zu übernehmen und das Bild dann in einem Kreis zu schneiden:

public static Bitmap getBitmapClip(Bitmap bitmap) {
    int maxLenth = bitmap.getWidth() <= bitmap.getHeight() ? bitmap.getWidth() : bitmap.getHeight();
    Bitmap output = Bitmap.createBitmap(maxLenth,
            maxLenth, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(output);

    final Paint paint = new Paint();
    final Rect rect = new Rect(0, 0, maxLenth, maxLenth);

    Paint.setAntiAlias(true);
    canvas.drawARGB(0, 0, 0, 0);
    canvas.drawCircle(maxLenth / 2, maxLenth / 2,
            maxLenth / 2, Paint);
    Paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    canvas.drawBitmap(bitmap, rect, rect, Paint);
    return output;
}

Ich habe die folgende Skaleneigenschaft verwendet, um meine ImageView mit der neuen Bitmap zu füllen:

<ImageView
    Android:id="@+id/iv_photo"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:layout_gravity="center"
    Android:scaleType="fitXY" />
0
Ângelo Polotto