Wie kann man nur einen Teil einer Bitmap anzeigen?

Question

Ich versuche, einen sich bewegenden Hintergrund zu schaffen. Mein Ziel ist es, eine riesige Bitmap Scrollen von selbst machen es scheinen, als ob seine Bewegung. aber zuerst muss ich herausfinden, wie zeigen nur einen Teil der Bitmap. Ive versucht, diesen Code, aber haben erfolglos gewesen. Ist die Teilmenge, was im suchen in dieser Situation? canvas.drawBitmap(bitmap, """subset"""src, dst, paint)

Dies ist die Erklärung der Methode bitmap Das zu zeichnende Bitmap ====== src Kann null sein. Die Teilmenge des zu zeichnenden Bitmaps ======= dst Das Rechteck, in das das Bitmap skaliert/verschoben werden soll

Answer 1

Canvas.drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint);

Sie ermöglicht es uns, Folgendes festzulegen ein Teil der zu zeichnenden Bitmap über den zweiten Parameter. Die Klasse Rect enthält die obere linke und untere rechte Ecke Koordinaten eines Rechtecks. Wenn wir einen Teil der Bitmap über den src-Parameter angeben, tun wir dies im Koordinatensystem der Bitmap. Wenn wir null angeben, wird die gesamte Bitmap verwendet. Der dritte Parameter legt fest, wohin der Teil der Bitmap gezeichnet werden soll, wiederum in Form einer Rect-Instanz. Diesmal werden die Eckkoordinaten allerdings im Koordinatensystem des Ziels des Canvas angegeben (entweder eine Ansicht oder eine andere Bitmap). Die große Überraschung ist, dass die beiden Rechtecke nicht die gleiche Größe haben müssen. Wenn wir angeben das Zielrechteck kleiner ist als das Ausgangsrechteck, dann wird das Canvas automatisch für uns skaliert. Das Gleiche gilt für die Angabe eines größeren Zielrechtecks Rechteck.

Rect dst = new Rect();
dst.set(50, 50, 350, 350);
canvas.drawBitmap(bmp, null, dst, null);

Hier ist bmp eine Bitmap mit einer Originalgröße von 160*183 Pixeln. Sie wird mit Rect auf 250*250 Pixel skaliert.

Answer 2

Und eine andere Möglichkeit, dies zu tun, indem man das Bild zuschneidet

public class CropImageManipulator
{

    public CropImageManipulator()
    {
    }

    private string _fileNameWithoutExtension;
    private string _fileExtension;
    private string _fileDirectory;

    public void Cropping(string inputImgPath, int cropWidth, int cropHeight)
    {
        this._fileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(inputImgPath);
        this._fileExtension = System.IO.Path.GetExtension(inputImgPath);
        this._fileDirectory = System.IO.Path.GetDirectoryName(inputImgPath);

        //Load the image divided
         Image inputImg = Image.FromFile(inputImgPath);
        int imgWidth = inputImg.Width;
        int imgHeight = inputImg.Height;

        //Divide how many small blocks
        int widthCount = (int)Math.Ceiling((imgWidth * 1.00) / (cropWidth * 1.00));
        int heightCount = (int)Math.Ceiling((imgHeight * 1.00) / (cropHeight * 1.00));
        ArrayList areaList = new ArrayList();

        int i = 0;
        for (int iHeight = 0; iHeight < heightCount ; iHeight ++)
        {
            for (int iWidth = 0; iWidth < widthCount ; iWidth ++)
            {
                int pointX = iWidth * cropWidth;
                int pointY = iHeight * cropHeight;
                int areaWidth = ((pointX + cropWidth) > imgWidth) ? (imgWidth - pointX) : cropWidth;
                int areaHeight = ((pointY + cropHeight) > imgHeight) ? (imgHeight - pointY) : cropHeight;
                string s = string.Format("{0};{1};{2};{3}",pointX,pointY,areaWidth,areaHeight);

                Rectangle rect = new Rectangle(pointX,pointY,areaWidth,areaHeight);
                areaList.Add(rect);
                i ++;
            }
        }

        for (int iLoop = 0 ; iLoop < areaList.Count ; iLoop ++)
        {
            Rectangle rect = (Rectangle)areaList[iLoop];
            string fileName = this._fileDirectory + "\\" + this._fileNameWithoutExtension + "_" + iLoop.ToString() + this._fileExtension;
            Bitmap newBmp = new Bitmap(rect.Width,rect.Height,PixelFormat.Format24bppRgb);
            Graphics newBmpGraphics = Graphics.FromImage(newBmp);
            newBmpGraphics.DrawImage(inputImg,new Rectangle(0,0,rect.Width,rect.Height),rect,GraphicsUnit.Pixel);
            newBmpGraphics.Save();
            switch (this._fileExtension.ToLower())
            {
                case ".jpg":
                case ".jpeg":
                    newBmp.Save(fileName,ImageFormat.Jpeg);
                    break;
                case "gif":
                    newBmp.Save(fileName,ImageFormat.Gif);
                    break;
            }
        }
        inputImg.Dispose();
    }
}

Answer 3

Sie könnten eine ImageView unterklassifizieren und die Funktion getImageMatrix() verwenden, um das Matrix-Objekt zu erhalten, das mit dieser ImageView verknüpft ist, und dann der Matrix mitteilen, dass sie sich über das Bild bewegen und/oder zoomen soll, indem Sie matrix.preTranslate() und matrix.preScale() verwenden, um auf effiziente Weise einen Bildlaufeffekt zu erzeugen. Und wenn Sie fertig sind, können Sie imageView.setImageMatrix(matrix) aufrufen, gefolgt von imageView.invalidate(), um den Inhalt des ImageViews zu aktualisieren.

Answer 4

Die Quelle sourceBitmap sollte ordnungsgemäß vorbereitet sein, d.h. gefiltert und skaliert werden, z.B. mit einer geeigneten Dichte usw. Dann muss man ein Rechteck definieren, das einen Teil abgreift. Sprich :

int desiredX0Lcl=50,
    desiredY0Lcl=70,
    desiredX1Lcl=400,
    desiredY1Lcl=500;   
Rect sourceRectLcl= new Rect();
sourceRectLcl.set(desiredX0Lcl,desiredY0Lcl,desiredX1Lcl,desiredY1Lcl);

Erstellen Sie nun ein Zielrechteck, dessen Begrenzungen dem gewünschten Teil der sourceBitmap entsprechen:

Rect destinationRectLcl=new Rect(); int widthLcl=desiredX1Lcl-desiredX0Lcl; int heightLcl=desiredY1Lcl-desiredY0Lcl; destinationRectLcl.set(0,0,widthLcl,heightLcl);

ZielLeinwand erstellen:

Bitmap baseCanvasBitmapLcl = Bitmap.createBitmap(widthLcl,heightLcl ,Bitmap.Config.ARGB_8888); Canvas destCanvasLcl = new Canvas(baseCanvasBitmapLcl);

Und zeichnen Sie den gewünschten Teil der sourceBitmap ein:

destCanvasLcl.drawBitmap(sourceBitmap,sourceRectLcl,destinationRectLcl,null); //sourceBitmap.recycle;