web-dev-qa-db-fra.com

Bitmap de tuile Android

J'essaie de charger une image bitmap dans Android que je veux utiliser en mosaïque. J'utilise actuellement les éléments suivants dans mon affichage pour afficher un bitmap:

canvas.drawBitmap(bitmap, srcRect, destRect, null)

Je souhaite essentiellement utiliser ce bitmap en tant qu'image d'arrière-plan dans mon application et je souhaite répéter le bitmap dans les deux directions X et Y.

J'ai vu la constante TileMode.REPEAT pour la classe BitmapShader mais je ne suis pas sûr si cela doit être utilisé pour répéter le bitmap réel ou pour appliquer un filtre au bitmap.

androidbitmap
45
Rich Lawrence

Vous feriez cela dans le XML au lieu du code Java. Je n'ai pas essayé moi-même mais j'ai trouvé cet exemple.

<xml version="1.0" encoding="utf-8"?>
<LinearLayout
Android:id="@+id/MainLayout"
xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
Android:orientation="vertical"
Android:background="@drawable/backrepeat"
>

puis dans un fichier XML appelé backrepeat.xml

<bitmap xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:src="@drawable/back" 
    Android:tileMode="repeat" />

référence

125
branchgabriel

Compris la version du code:

  BitmapDrawable TileMe = new BitmapDrawable(MyBitmap);
  TileMe.setTileModeX(Shader.TileMode.REPEAT);
  TileMe.setTileModeY(Shader.TileMode.REPEAT);

  ImageView Item = new ImageView(this);
  Item.setBackgroundDrawable(TileMe);

Ensuite, si vous avez une mosaïque à dessiner, vous pouvez utiliser cette option pour rendre BitmapDrawable:

  BitmapDrawable TileMe = new BitmapDrawable(BitmapFactory.decodeResource(getResources(), R.drawable.tile));
36
Izkata

Le backrepeat.xml ci-dessus est bogué

<bitmap
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:src="@drawable/tile"
    Android:tileMode="repeat"
    Android:dither="true" />
16
Bo.

Il semble que certaines personnes s'intéressent à cela dans une vue, à la méthode onDraw Le code suivant a fonctionné pour moi:

bgTile = BitmapFactory.decodeResource(context.getResources(), R.drawable.bg_tile);

float left = 0, top = 0;
float bgTileWidth = bgTile.getWidth();
float bgTileHeight = bgTile.getHeight();

while (left < screenWidth) {
    while (top < screenHeight) {
        canvas.drawBitmap(bgTile, left, top, null);
        top += bgTileHeight;
    }
    left += bgTileWidth;
    top = 0;
}
6
kgiannakakis
<xml version="1.0" encoding="utf-8"?>
<LinearLayout
    Android:id="@+id/MainLayout"
    xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="fill_parent"
    Android:layout_height="fill_parent"
    Android:orientation="vertical"
    Android:background="@drawable/back"
    Android:tileMode="repeat"
>

CA marchait bien pour moi. Je n'ai pas eu à créer le bitmap séparément. J'ai utilisé l'attribut tileMode dans la mise en page.

4
navi

Il suffit de mettre cette ligne de codes dans le onCreate (): -

 final Bitmap bmp = BitmapFactory.decodeResource(getResources(),R.drawable.actionbar_bg);
 final BitmapDrawable bitmapDrawable = new BitmapDrawable(bmp);
 bitmapDrawable.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
 final ActionBar bar = getSupportActionBar();
 bar.setBackgroundDrawable(bitmapDrawable);
1
Amit Jayaswal
/* Tiled Layer Bitmap*/


public class TiledLayer {
private int cellWidth;
private int cellHeight;
private int yPosition = 0, xPosition = 0;
private int[][] grid;
private Image image;
private int[] tileXPositions;
private int[] tileYPositions;
private ArrayList animatedTiles;
private int numberOfTiles;
private int numberOfColumns;
private int numberOfRows;
private int gridColumns;
private int gridRows, width, height;

public TiledLayer(Image image, int columns, int rows, int tileWidth,
        int tileHeight, int width, int height) {
    this.grid = new int[columns][rows];
    this.gridColumns = columns;
    this.gridRows = rows;
    this.width = columns * tileWidth;
    this.height = rows * tileHeight;
    this.animatedTiles = new ArrayList();
    setStaticTileSet(image, tileWidth, tileHeight);
}

public void setStaticTileSet(Image image, int tileWidth, int tileHeight) {
    this.image = image;
    this.cellWidth = tileWidth;
    this.cellHeight = tileHeight;
    int columns = 64;//image.getWidth() / tileWidth;
    int rows =40;// image.getHeight() / tileHeight;
    this.tileXPositions = new int[columns];
    int pos = 0;
    for (int i = 0; i < columns; i++) {
        this.tileXPositions[i] = pos;
        pos += tileWidth;
    }
    this.tileYPositions = new int[rows];
    pos = 0;
    for (int i = 0; i < rows; i++) {
        this.tileYPositions[i] = pos;
        pos += tileHeight;
    }

    if (columns * rows < this.numberOfTiles) {
        // clear the grid, when there are not as many tiles as in the
        // previous set:
        for (int i = 0; i < this.grid.length; i++) {
            for (int j = 0; j < this.grid[i].length; j++) {
                this.grid[i][j] = 0;
            }
        }
    }
    this.numberOfTiles = columns * rows;
    this.numberOfColumns = columns;
    this.numberOfRows = rows;
}

public int createAnimatedTile(int staticTileIndex) {
    if (staticTileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + staticTileIndex + " (there are only ["
                + this.numberOfTiles + "] tiles available.");

    }
    this.animatedTiles.add(new Integer(staticTileIndex));
    return -1 * (this.animatedTiles.size() - 1);
}

public void setAnimatedTile(int animatedTileIndex, int staticTileIndex) {
    if (staticTileIndex >= this.numberOfTiles) {

    }
    int animatedIndex = (-1 * animatedTileIndex) - 1;
    this.animatedTiles.set(animatedIndex, new Integer(staticTileIndex));
 }

 public int getAnimatedTile(int animatedTileIndex) {
    int animatedIndex = (-1 * animatedTileIndex) - 1;
    Integer animatedTile = (Integer) this.animatedTiles.get(animatedIndex);
    return animatedTile.intValue();
 }
 public void setCell(int col, int row, int tileIndex) {
    if (tileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + tileIndex + " (there are only [" + this.numberOfTiles
                + "] tiles available.");

    }
    this.grid[col][row] = tileIndex;
}

 public int getCell(int col, int row) {
    return this.grid[col][row];
 }

 public void fillCells(int col, int row, int numCols, int numRows,
        int tileIndex) {
    if (tileIndex >= this.numberOfTiles) {

        throw new IllegalArgumentException("invalid static tile index: "
                + tileIndex + " (there are only [" + this.numberOfTiles
                + "] tiles available.");

    }
    int endCols = col + numCols;
    int endRows = row + numRows;
    for (int i = col; i < endCols; i++) {
        for (int j = row; j < endRows; j++) {
            this.grid[i][j] = tileIndex;
        }
    }
 }

    public final int getCellWidth() {
    return this.cellWidth;
 }

    public final int getCellHeight() {
    return this.cellHeight;
 }

 public final int getColumns() {
    return this.gridColumns;
 }

public final int getRows() {
    return this.gridRows;
}

public final void Paint(Graphics g) {
    int clipX = 0;// g.getClipX();
    int clipY = 0;// g.getClipY();
    int clipWidth = width;// g.getClipWidth();
    int clipHeight = height;// g.getClipHeight();

    // jmt restore clip to previous state

    int x = this.xPosition;
    int y = this.yPosition;
    int[][] gridTable = this.grid;
    for (int i = 0; i < this.gridColumns; i++) {
        int[] gridRow = gridTable[i];
        for (int j = 0; j < gridRow.length; j++) {
            int cellIndex = gridRow[j];
            if (cellIndex != 0) {
                // okay this cell needs to be rendered:
                int tileIndex;
                if (cellIndex < 0) {
                    Integer tile = (Integer) this.animatedTiles
                            .get((-1 * cellIndex) - 1);
                    tileIndex = tile.intValue() - 1;
                } else {
                    tileIndex = cellIndex - 1;
                }
                // now draw the tile:
                g.save(Canvas.CLIP_SAVE_FLAG);
                // jmt: clear the screen
                Rect r = new Rect(0, 0, cellWidth, cellHeight);
                g.clipRect(r);
                g.setClip(x, y, this.cellWidth, this.cellHeight);
                int column = tileIndex % this.numberOfColumns;
                int row = tileIndex / this.numberOfColumns;
                int tileX = x - this.tileXPositions[column];
                int tileY = y - this.tileYPositions[row];

                g.drawImage(this.image, tileX, tileY);
                g.restore();
            }
            y += this.cellHeight;
        } // for each row
        y = this.yPosition;
        x += this.cellWidth;
    } // for each column

        // reset original clip:
        g.setClip(clipX, clipY, clipWidth, clipHeight);
     }
}
0
KuldeeP ChoudharY

Si vous souhaitez répéter l'arrière-plan uniquement verticalement, vous pouvez définir la largeur de votre présentation sur "wrap_content", tandis que si vous souhaitez définir l'arrière-plan pour une répétition horizontale, définissez la hauteur sur "wrap_content". Si la hauteur et la largeur sont définies sur "fill_parent", les carreaux seront placés dans les directions X et Y.

Par exemple, le code suivant répétera votre arrière-plan verticalement:

<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:layout_width="wrap_content"
    Android:layout_height="fill_parent"
    Android:background="@drawable/news_detail_activity_bg">
</LinearLayout>
0
David Argyle Thacker