¿Cómo dibujar una ruta con un mapa de bits?

Question

Tengo una pequeña aplicación de dibujo y quiero usar formas "complejas" como pinceles, es decir, una estrella. Dibujo con un simple cepillo ya trabaja con este código:

remotePath.reset(); 
remotePath.moveTo(start_x, start_y); 

float dx = Math.abs(end_x - start_x); 
float dy = Math.abs(end_y - start_y); 
if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) { 
     remotePath.quadTo(start_x, start_y, (end_x + start_x)/2, (end_y + start_y)/2); 
} 

remotePath.lineTo(end_x, end_y); 
// commit the path to our offscreen 
mCanvas.drawPath(remotePath, remotePaint); 
// kill this so we don't double draw 
remotePath.reset(); 
invalidate(); 

Quiero básicamente la misma funcionalidad utilizando este mapa de bits:

Bitmap myBitmap = BitmapFactory.decodeResource(getResources(), R.drawable.brush_star); 

Mi solución actualmente está utilizando una lista de puntos (coordenadas) para dibujar el mapa de bits El problema con esa solución es que solo dibuja mapas de bits en los puntos dados, lo que da como resultado espacios entre cada mapa de bits dibujado. Prefiero obtener una línea suave al dibujar como con un simple pincel sin espacios intermedios.

código actual para el dibujo de mapa de bits:

 protected void onDraw(Canvas canvas) { 

     // Make canvas white 
     canvas.drawColor(Color.WHITE); 

     // Paintable area 
     canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint); 

     canvas.drawPath(mPath, mPaint); 

     for (Point point : points) { 
      canvas.drawBitmap(complexBrush, point.x, point.y, p); 
     } 
    } 

¿Cuál es la mejor manera de hacerlo? ¡Gracias por cualquier ayuda!

Answer 1

utilizo clase este de Punto:

public class Point implements Serializable { 
float x, y; 
float dx, dy; 
} 

objeto pintura:

Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); 
paint.setStyle(Paint.Style.STROKE); 
paint.setStrokeWidth(5); 
paint.setColor(Color.RED); 
paint.setAntiAlias(true); 

empate sobre lienzo:

private void drawCanvas(Canvas canvas, List<Point> pts){ 
    if (pts.size() > 1){ 
     Path path = new Path(); 
     final int SMOOTH_VAL = 6; 
     for(int i = pts.size() - 2; i < pts.size(); i++){ 
      if(i >= 0){ 
       Point point = pts.get(i); 

       if(i == 0){ 
        Point next = pts.get(i + 1); 
        point.dx = ((next.x - point.x)/SMOOTH_VAL); 
        point.dy = ((next.y - point.y)/SMOOTH_VAL); 
       } 
       else if(i == pts.size() - 1){ 
        Point prev = pts.get(i - 1); 
        point.dx = ((point.x - prev.x)/SMOOTH_VAL); 
        point.dy = ((point.y - prev.y)/SMOOTH_VAL); 
       } 
       else{ 
        Point next = pts.get(i + 1); 
        Point prev = pts.get(i - 1); 
        point.dx = ((next.x - prev.x)/SMOOTH_VAL); 
        point.dy = ((next.y - prev.y)/SMOOTH_VAL); 
       } 
      } 
     } 

     boolean first = true; 
     for(int i = 0; i < pts.size(); i++){ 
      Point point = pts.get(i); 
      if(first){ 
       first = false; 
       path.moveTo(point.x, point.y); 
      } 
      else{ 
       Point prev = pts.get(i - 1); 
       path.cubicTo(prev.x + prev.dx, prev.y + prev.dy, point.x - point.dx, point.y - point.dy, point.x, point.y); 
      } 
     } 
     canvas.drawPath(path, paint); 
    } else { 
     if (pts.size() == 1) { 
      Point point = pts.get(0); 
      canvas.drawCircle(point.x, point.y, 2, paint); 
     } 
    } 
} 

Dibujar sobre lienzo de mapa de bits:

private void drawBitmap(Bitmap bmp, List<Point> pts) { 
    Canvas c = new Canvas(bmp); 
    drawCanvas(c, pts); 
}