Android changer de toile de couleur de fond, sans perdre aucune des dessins d'elle

Les réponses déjà données à votre question sont toutes orientées dans la bonne direction: vous avez besoin de séparer la couleur de fond du bloc et à l'avant-plan de votre dessin dans des calques séparés, puis les fusionner avant d'enregistrer le tout dans un .fichier png. C'est la manière dont Adobe Photoshop flux de travail est conçu aussi bien... C'est logique, si nous pensons à ce sujet: prendre par exemple un logiciel comme MsPaint: car il n'utilise pas de couches, il doit compter sur des trucs comme diffuseur des algorithmes à accomplir (quoique d'une manière incomplète) quelque chose de similaire à distance à un changement d'arrière-plan...

Une façon de mettre en œuvre une telle chose serait d'instancier 2 objets en Toile soutenu par 2 les différentes images. La première Toile-Bitmap paire devrait être utilisé pour votre dessin à l'avant-plan, et la seconde zone de dessin Bitmap paire devrait être utilisé pour votre fusionné-couches de dessin (c'est à dire de premier plan de dessin + fond de bloc de couleur). Puis la 2ème image Bitmap est ce qui va être enregistré pour un .fichier png lorsque vous en avez besoin pour être sauvé. De cette façon, notre première Toile-Bitmap paire de magasins de votre premier plan d'informations, ce qui n'est pas détruite si une couleur de fond doit être fait. Chaque fois qu'une opération est faite, les couches peuvent être fusionnés dans le 2ème Toile-Bitmap paire, alors qu'il y a toujours une image avec le bon contenu qui est prêt à être enregistré à votre gré.

Ici est une Vue personnalisée j'ai fait en sorte que pour effacer cette méthodologie. Il met en œuvre un simple point de vue utilisé pour dessiner une ligne bleue sur l'écran tactile à l'aide d'un doigt, avec un arrière-plan de changement de couleur en fonction de la X-Y de la position de ladite doigt, afin de démontrer une couleur d'arrière-plan de changement sans code inutile complexité inhérente de la mise en œuvre complète avec une roue de couleur/menus/notamment:

package com.epichorns.basicpaint;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.Paint.Style;
import android.view.View;
public class PaintView extends View{
Bitmap mMergedLayersBitmap=null; //Note: this bitmap here contains the whole of the drawing (background+foreground) to be saved.
Canvas mMergedLayersCanvas=null;
Bitmap mBitmap = null; //bitmap onto which we draw our stuff
Canvas mCanvas = null; //Main canvas. Will be linked to a .bmp file
int mBackgroundColor = 0xFF000000; //default background color
Paint mDefaultPaint = new Paint();
Paint mDrawPaint = new Paint(); //used for painting example foreground stuff... We draw line segments.
Point mDrawCoor = new Point(); //used to store last location on our PaintView that was finger-touched
//Constructor: we instantiate 2 Canvas-Bitmap pairs
public PaintView(Context context, int width, int height) {
super(context);
mMergedLayersBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); 
mMergedLayersCanvas = new Canvas(mMergedLayersBitmap);
mBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
mCanvas = new Canvas(mBitmap);
}
//Change background color
public void changeColor(int newColor){
mBackgroundColor = newColor;
invalidate(); //refresh view: this will indirectly invoke onDraw soon afterwards
}
//Called by user of PaintView in order to start a painting "stroke" (finger touching touch-screen): stores the 
//location of the finger when it first touched the screen
public void startDraw(int x, int y, int radius, int color){
mDrawPaint.setColor(color);
mDrawPaint.setStyle(Style.STROKE);
mDrawPaint.setStrokeWidth(radius);
mDrawCoor.x = x;
mDrawCoor.y = y;        
}
//Called by user of PaintView when finger touching touch-screen is moving (must be called after a startDraw, 
//as the latter initializes a couple of necessary things)
public void continueDraw(int x, int y){
mCanvas.drawLine(mDrawCoor.x, mDrawCoor.y, x, y, mDrawPaint);
mDrawCoor.x = x;
mDrawCoor.y = y;
invalidate(); //refresh view: this will indirectly invoke onDraw soon afterwards
}
//Merge the foreground Canvas-Bitmap with a solid background color, then stores this in the 2nd Canvas-Bitmap pair.
private void mergeLayers(){
mMergedLayersCanvas.drawColor(mBackgroundColor);
mMergedLayersCanvas.drawBitmap(mBitmap, 0, 0, mDefaultPaint);
}
@Override
public void onDraw(Canvas canvas){
mergeLayers();
canvas.drawBitmap(mMergedLayersBitmap, 0, 0, mDefaultPaint);
}
}

Afin de tester ce point de vue, voici un test de l'Activité qui utilise le PaintView classe. Ces deux fichiers sont auto-suffisantes dans un projet Android, de sorte que vous pouvez tester sur votre périphérique réel sans tracas:

package com.epichorns.basicpaint;
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.View;
import android.widget.LinearLayout;
import com.epichorns.basicpaint.PaintView;
public class BasicPaintActivity extends Activity {
PaintView mPaintView=null;
LinearLayout mL = null;
boolean mIsDrawing=false;
int mBackgroundColor = 0xFF000000;
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Display display = getWindowManager().getDefaultDisplay();       
final float dispWidth = (float)display.getWidth();
final float dispHeight = (float)display.getHeight();
mPaintView = new PaintView(this, display.getWidth(), display.getHeight());    
mPaintView.changeColor(mBackgroundColor);
mPaintView.setOnTouchListener(new View.OnTouchListener(){
public boolean onTouch(View v, MotionEvent event) {
if(event.getAction()==MotionEvent.ACTION_DOWN){
mPaintView.startDraw((int)event.getX(), (int)event.getY(), 6, 0x806060FF);              
mIsDrawing=true;
return true;
}
else if(event.getAction()==MotionEvent.ACTION_UP){
mIsDrawing=false;
return true;
}
else if(event.getAction()==MotionEvent.ACTION_MOVE){
if(mIsDrawing){
//To demonstrate background change, change background color depending on X-Y position
int r = (int)(255f*event.getX()/dispWidth);
int g = (int)(255f*event.getY()/dispHeight);
mBackgroundColor = Color.argb(0xFF, r,g, 0x00);
Log.d("DEBUG1", "Color channels: (r, g) = ("+String.valueOf(r)+", "+String.valueOf(g)+")");
mPaintView.changeColor(mBackgroundColor);
//now, draw stuff where finger was dragging...
mPaintView.continueDraw((int)event.getX(), (int)event.getY());
return true;
}
else{
return false;
}
}
return false;
}
});
setContentView(mPaintView);
}
}

OriginalL'auteur epichorns

Coup d'oeil si vous voulez changer dans la toile, alors vous devez appeler invalider d'appliquer ces modifications de votre écran.Et si vous appelez d'invalider alors votre onDraw() méthode appelle.

Si vous souhaitez modifier uniquement la couleur d'arrière-plan de toile de sélecteur de couleur puis enregistrer la couleur de la valeur dans une variable et de l'appel d'invalider juste après l'enregistrement de la variable.Maintenant, votre onDraw() vais appeler.Maintenant modifier l'arrière-plan de toile en appelant setBackgroundColor(color variable) dans onDraw() et dessiner tout ce que vous voulez

OriginalL'auteur Tofeeq

Tant que votre arrière-plan est et sera dans une autre couleur, vous pouvez le faire:

for (x...)
for (y...)
if (bitmap.getPixel(x,y) == oldBackgroundColor)
bitmap.setPixel(x,y,newBackgroundColor)

Ou, vous pouvez dessiner votre contenu sur un écran bitmap, et de dessiner l'arrière-plan, puis l'écran de la bitmap réelle. De cette façon, vous pouvez modifier la backgroundcolor qui sera utilisé lors de la prochaine étape de deux-dessin va se passer.

OriginalL'auteur Bondax

Peut-être que c'est une vieille question, mais j'ai envie de contribuer à cette solution, Dans le cas où vous prenez le bitmap à partir d'une source, et ensuite de faire une dessinés avec de la toile, peut-être que cela peut s'adapter à u:

@Override
public Bitmap transform(final Bitmap source) {
//Background for transparent images
Bitmap backg = Bitmap.createBitmap(source.getWidth(), source.getHeight(), Bitmap.Config.ARGB_8888);
backg.eraseColor(Color.WHITE); //Any color you want...
Paint back = new Paint();
BitmapShader backshader = new BitmapShader(backg,
BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
back.setShader(backshader);
back.setAntiAlias(true);
//Image for the draw
final Paint paint = new Paint();
paint.setAntiAlias(true);
paint.setShader(new BitmapShader(source, Shader.TileMode.CLAMP,
Shader.TileMode.CLAMP));
Bitmap output = Bitmap.createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
Canvas canvas = new Canvas(output);
//IMPORTANT THING
canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
- margin, source.getHeight() - margin), radius, radius, back); //Draw the background first...
canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
- margin, source.getHeight() - margin), radius, radius, paint); //And then Draw the image, so it draws on top of the background
if (source != output) {
source.recycle();
}
//This is for if i want to put a border in the drawable, its optional
Paint paint1 = new Paint();      
paint1.setColor(Color.parseColor("#CC6C7B8B"));
paint1.setStyle(Style.STROKE);
paint1.setAntiAlias(true);
paint1.setStrokeWidth(2);
canvas.drawRoundRect(new RectF(margin, margin, source.getWidth()
- margin, source.getHeight() - margin), radius, radius, paint1);
//and then, return the final drawable...
return output;
}

Espère que ça aide...

OriginalL'auteur JCarangoH