public void testDraw() {
    Bitmap bmp = Bitmap.createBitmap(9, 9, Config.ARGB_8888);
    Canvas c = new Canvas(bmp);

    int ocean = Color.rgb(0, 0xFF, 0x80);

    mNinePatchDrawable.setBounds(0, 0, 9, 9);
    mNinePatchDrawable.draw(c);
    assertColorFillRect(bmp, 0, 0, 4, 4, Color.RED);
    assertColorFillRect(bmp, 5, 0, 4, 4, Color.BLUE);
    assertColorFillRect(bmp, 0, 5, 4, 4, ocean);
    assertColorFillRect(bmp, 5, 5, 4, 4, Color.YELLOW);
    assertColorFillRect(bmp, 4, 0, 1, 9, Color.WHITE);
    assertColorFillRect(bmp, 0, 4, 9, 1, Color.WHITE);

    bmp.eraseColor(0xff000000);

    mNinePatchDrawable.setBounds(0, 0, 3, 3);
    mNinePatchDrawable.draw(c);
    assertColorFillRect(bmp, 0, 0, 1, 1, Color.RED);
    assertColorFillRect(bmp, 2, 0, 1, 1, Color.BLUE);
    assertColorFillRect(bmp, 0, 2, 1, 1, ocean);
    assertColorFillRect(bmp, 2, 2, 1, 1, Color.YELLOW);
    assertColorFillRect(bmp, 1, 0, 1, 3, Color.WHITE);
    assertColorFillRect(bmp, 0, 1, 3, 1, Color.WHITE);

    try {
      mNinePatchDrawable.draw(null);
      fail("The method should check whether the canvas is null.");
    } catch (NullPointerException e) {
      // expected
    }
  }
  public static Bitmap capture(
      View view, float width, float height, boolean scroll, Bitmap.Config config) {
    if (!view.isDrawingCacheEnabled()) view.setDrawingCacheEnabled(true);

    Bitmap bitmap = Bitmap.createBitmap((int) width, (int) height, config);
    bitmap.eraseColor(Color.WHITE);

    Canvas canvas = new Canvas(bitmap);
    int left = view.getLeft();
    int top = view.getTop();
    if (scroll) {
      left = view.getScrollX();
      top = view.getScrollY();
    }
    int status = canvas.save();
    canvas.translate(-left, -top);

    float scale = width / view.getWidth();
    canvas.scale(scale, scale, left, top);

    view.draw(canvas);
    canvas.restoreToCount(status);

    Paint alphaPaint = new Paint();
    alphaPaint.setColor(Color.TRANSPARENT);

    canvas.drawRect(0f, 0f, 1f, height, alphaPaint);
    canvas.drawRect(width - 1f, 0f, width, height, alphaPaint);
    canvas.drawRect(0f, 0f, width, 1f, alphaPaint);
    canvas.drawRect(0f, height - 1f, width, height, alphaPaint);
    canvas.setBitmap(null);

    return bitmap;
  }
Esempio n. 3
0
    public byte[] getTileImageData(int x, int y, int zoom) {
      mStream.reset();

      Matrix matrix = new Matrix(mBaseMatrix);
      float scale = (float) (Math.pow(2, zoom) * mScale);
      matrix.postScale(scale, scale);
      matrix.postTranslate(-x * mDimension, -y * mDimension);

      mBitmap.eraseColor(Color.TRANSPARENT);
      Canvas c = new Canvas(mBitmap);
      c.setMatrix(matrix);

      // NOTE: Picture is not thread-safe.
      synchronized (mSvgPicture) {
        mSvgPicture.draw(c);
      }

      BufferedOutputStream stream = new BufferedOutputStream(mStream);
      mBitmap.compress(Bitmap.CompressFormat.PNG, 0, stream);
      try {
        stream.close();
      } catch (IOException e) {
        Log.e(TAG, "Error while closing tile byte stream.");
        e.printStackTrace();
      }
      return mStream.toByteArray();
    }
Esempio n. 4
0
  private static android.graphics.Bitmap getTileBitmapFromReusableSet(
      int tileSize, boolean isTransparent) {
    int hash = composeHash(tileSize, isTransparent);
    Set<SoftReference<Bitmap>> subSet = reusableTileBitmaps.get(hash);

    if (subSet == null) {
      return null;
    }
    android.graphics.Bitmap bitmap = null;
    synchronized (subSet) {
      final Iterator<SoftReference<android.graphics.Bitmap>> iterator = subSet.iterator();
      android.graphics.Bitmap candidate;
      while (iterator.hasNext()) {
        candidate = iterator.next().get();
        if (null != candidate && candidate.isMutable()) {
          bitmap = candidate;
          if (isTransparent) {
            bitmap.eraseColor(android.graphics.Color.TRANSPARENT);
          }
          // Remove from reusable set so it can't be used again.
          iterator.remove();
          break;
        } else {
          // Remove from the set if the reference has been cleared.
          iterator.remove();
        }
      }
    }
    return bitmap;
  }
  @Override
  public void drawData(Canvas c) {

    int width = (int) mViewPortHandler.getChartWidth();
    int height = (int) mViewPortHandler.getChartHeight();

    if (mDrawBitmap == null
        || (mDrawBitmap.getWidth() != width)
        || (mDrawBitmap.getHeight() != height)) {

      if (width > 0 && height > 0) {

        mDrawBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_4444);
        mBitmapCanvas = new Canvas(mDrawBitmap);
      } else return;
    }

    mDrawBitmap.eraseColor(Color.TRANSPARENT);

    PieData pieData = mChart.getData();

    for (PieDataSet set : pieData.getDataSets()) {

      if (set.isVisible() && set.getEntryCount() > 0) drawDataSet(c, set);
    }
  }
 public void buildCache(int w, int h, int density, boolean checkSizeEquals) {
   boolean reuse = checkSizeEquals ? (w == width && h == height) : (w <= width && h <= height);
   if (reuse && bitmap != null && !bitmap.isRecycled()) {
     //            canvas.drawColor(Color.TRANSPARENT);
     canvas.setBitmap(null);
     bitmap.eraseColor(Color.TRANSPARENT);
     canvas.setBitmap(bitmap);
     recycleBitmapArray();
     return;
   }
   if (bitmap != null) {
     recycle();
   }
   width = w;
   height = h;
   bitmap = NativeBitmapFactory.createBitmap(w, h, Bitmap.Config.ARGB_8888);
   if (density > 0) {
     mDensity = density;
     bitmap.setDensity(density);
   }
   if (canvas == null) {
     canvas = new Canvas(bitmap);
     canvas.setDensity(density);
   } else canvas.setBitmap(bitmap);
 }
Esempio n. 7
0
 public void setForeBitmap(Bitmap forebitmap) {
   if (bitmap != null) {
     bitmap.eraseColor(0);
   }
   if (forebitmap != null) paper.drawBitmap(forebitmap, 0, 0, null);
   invalidate();
 }
Esempio n. 8
0
 private void drawIntoBitmap() {
   Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
   if (mAlpha) {
     if (!mBlur) {
       mViewBitmap.eraseColor(Color.TRANSPARENT);
     }
   }
   if (mBlur) {
     if (mAlphaMark) {
       p.setAlpha(mBlurVal);
     } else {
       mAlphaMark = true;
     }
   }
   Canvas c = new Canvas(mViewBitmap);
   c.save();
   Path path = new Path();
   path.moveTo(0, 0);
   path.arcTo(
       new RectF(-mBitmapViewWidth, -mBitmapViewWidth, mBitmapViewWidth, mBitmapViewWidth),
       0,
       mAngle);
   // path.lineTo(0, 1);
   path.close();
   c.clipPath(path);
   // c.drawRGB(0, 0, 0);
   // RectF r = new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight);
   c.drawBitmap(
       mBitmap,
       new Rect(mCurX, mCurY, mRadius + mCurX, mBitmapNewHeight + mCurY),
       new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight),
       p);
 }
Esempio n. 9
0
  private void regenInRunnable() {
    Bitmap bmp = mRegenBitmap != null ? mRegenBitmap : mCachedBitmap;
    int count = -1;
    try {
      synchronized (bmp) {
        bmp.eraseColor(mBkColor);
        count = drawShapes(new Canvas(bmp), mCanvasRegen, false);

        if (bmp == mRegenBitmap) {
          if (mCachedBitmap != null) {
            mCachedBitmap.recycle();
          }
          mCachedBitmap = mRegenBitmap;
        }
      }
      if (!mCoreView.isStopping()) {
        postInvalidate();
      }
    } catch (Exception e) {
      Log.w(TAG, "Fail to draw on the cached bitmap", e);
    }
    mRegenBitmap = null;
    mRegenning = false;
    if (count >= 0 && !mCoreView.isStopping()) {
      mViewAdapter.onFirstRegen();
    }
  }
Esempio n. 10
0
  private void updateHUD() {
    // TODO Line wrap!

    HUD.eraseColor(Color.TRANSPARENT);
    float textHeight = paint.getFontSpacing();
    int rowsOnScreen = (int) (hudHeight / textHeight);
    float baseLine = hudHeight - Math.max(0, rowsOnScreen - lines.size()) * textHeight;
    log(
        "updateHUD",
        "textHeight = %.2f, rowsOnScreen = %d, lines.size() = %d, baseLine = %.2f",
        textHeight,
        rowsOnScreen,
        lines.size(),
        baseLine);
    int written = 0;
    for (String line : lines) {
      canvas.drawText(line, textXOffset, baseLine - textHeight + textYOffset, paint);
      written += 1;
      baseLine -= textHeight;
      if (baseLine < textHeight) {
        break;
      }
    }
    for (int index = lines.size() - 1; index > written; --index) {
      lines.remove(index);
    }

    setMainTexture();
  }
  private Bitmap drawTextToBitmap(String gText) {
    Bitmap bitmap = Bitmap.createBitmap(500, 500, Bitmap.Config.ARGB_8888);
    bitmap.eraseColor(Color.TRANSPARENT);
    bitmap.setHasAlpha(true);

    //        bitmap.setHasAlpha(true);
    Canvas canvas = new Canvas(bitmap);
    canvas.drawColor(Color.TRANSPARENT);

    TextPaint textPaint = new TextPaint();
    textPaint.setColor(Color.GREEN);
    textPaint.setTextSize(35);
    RectF rect = new RectF(0, 0, 300, 300);
    StaticLayout sl =
        new StaticLayout(
            gText, textPaint, (int) rect.width(), Layout.Alignment.ALIGN_NORMAL, 1, 1, false);
    canvas.save();
    sl.draw(canvas);
    canvas.restore();

    // Flip the image.
    Matrix m = new Matrix();
    m.preScale(-1, 1);
    Bitmap output =
        Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), m, false);
    output.setDensity(DisplayMetrics.DENSITY_DEFAULT);

    return output;
  }
Esempio n. 12
0
  private void drawBlurBackground(Canvas canvas) {
    if (mBlurredView != null) {
      if (prepare()) {
        if (mBlurredBackgroundColor != 0) {
          mBitmapToBlur.eraseColor(mBlurredBackgroundColor);
        }
        mBlurredView.draw(mBlurringCanvas);
        blur();

        NiceTabLayout tabLayout = (NiceTabLayout) getParent();

        if (tabLayout != null) {
          final int pPaddingLeft = tabLayout.getPaddingLeft();
          final int pPaddingRight = tabLayout.getPaddingRight();

          canvas.save();

          if (tabLayout.getPaddingLeft() != 0 || tabLayout.getPaddingRight() != 0) {
            // allow drawing out of bounds
            Rect clipBounds = canvas.getClipBounds();
            clipBounds.inset(-(pPaddingLeft + pPaddingRight), 0);
            canvas.clipRect(clipBounds, Region.Op.REPLACE);
          }

          canvas.translate(
              mBlurredView.getLeft() - getLeft() + tabLayout.getScrollX(),
              mBlurredView.getTop() - getTop());
          canvas.scale(mDownSampleFactor, mDownSampleFactor);
          canvas.drawBitmap(mBlurredBitmap, 0, 0, null);
          canvas.drawColor(mOverlayColor);
          canvas.restore();
        }
      }
    }
  }
Esempio n. 13
0
 private void init(Context mContext) {
   if (arrowResource != 0) {
     arrowBitmap = BitmapFactory.decodeResource(mContext.getResources(), arrowResource);
     canvasBitmap = arrowBitmap.copy(Bitmap.Config.ARGB_4444, true);
     canvasBitmap.eraseColor(0x00000000);
     paint = new Paint();
   }
 }
Esempio n. 14
0
File: eri.java Progetto: exe44/eri
  static int CreateTxtTexture(
      String txt, Typeface typeface, float font_size, boolean align_center) {

    Paint textPaint = new Paint();
    textPaint.setTypeface(typeface);
    textPaint.setTextSize(font_size);
    textPaint.setTextAlign(align_center ? Paint.Align.CENTER : Paint.Align.LEFT);
    textPaint.setAntiAlias(true);
    textPaint.setARGB(0xff, 0xFF, 0xFF, 0xFF);

    int width = 0;
    int height = 0;

    int line_height = (int) Math.ceil(-textPaint.ascent() + textPaint.descent());

    String[] lines = txt.split("\n");

    for (String line : lines) {
      int line_width = (int) Math.ceil(textPaint.measureText(line));
      if (line_width > width) width = line_width;

      height += line_height;
    }

    int power2_width = Integer.highestOneBit(width);
    if (power2_width < width) power2_width = power2_width << 1;
    int power2_height = Integer.highestOneBit(height);
    if (power2_height < height) power2_height = power2_height << 1;

    // Log.i(TAG, "CreateTxtTexture calculate w " + width + " h " + height +
    // " power2 w " + power2_width + " h " + power2_height);

    if (0 == power2_width || 0 == power2_height) return 0;

    Bitmap bitmap = Bitmap.createBitmap(power2_width, power2_height, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    bitmap.eraseColor(0);

    float origin_x = align_center ? (width / 2) : 0;
    float origin_y = -textPaint.ascent();

    for (String line : lines) {
      canvas.drawText(line, origin_x, origin_y, textPaint);
      origin_y += line_height;
    }

    // canvas.setBitmap(null);

    // Log.i(TAG, "CreateTxtTexture " + txt + " use " + font_name + " " + font_size);

    // Use the Android GLUtils to specify a two-dimensional texture image
    // from our bitmap
    GLUtils.texImage2D(GL11.GL_TEXTURE_2D, 0, bitmap, 0);

    // bitmap.recycle();

    return width + (height << 16);
  }
 @Override
 public void drawGhost(Canvas canvas) {
   if (ghostBitmap != null) {
     ghostBitmap.eraseColor(indexColor);
     canvas.drawBitmap(ghostBitmap, drawingMatrix, null);
   } else {
     canvas.drawPath(ghostPath, ghostPaint);
   }
 }
Esempio n. 16
0
 public void clearCanvas() {
   if (bitmap != null) {
     bitmap.recycle();
     bitmap = null;
     bitmap = Bitmap.createBitmap(PAPER_WIDTH, PAPER_HEIGHT, Bitmap.Config.ARGB_4444);
     bitmap.eraseColor(0);
     paper = new Canvas(bitmap);
   }
   invalidate();
 }
Esempio n. 17
0
    @Override
    public void onCreate(SurfaceHolder holder) {
      super.onCreate(holder);

      mBackgroundBitmap = Bitmap.createBitmap(320, 320, Bitmap.Config.RGB_565);
      mBackgroundBitmap.eraseColor(Color.BLACK);

      mPaint.setTypeface(Typeface.create(Typeface.SANS_SERIF, Typeface.BOLD));
      mPaint.setTextSize(20f);
      mPaint.setColor(Color.BLUE);
    }
Esempio n. 18
0
  @Override
  public Bitmap snapshot(int doc, int gs, boolean transparent) {
    final Bitmap bitmap = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
    final CanvasAdapter canvasAdapter = new CanvasAdapter(this, mImageCache);
    final Longs docs = new Longs(doc, 0);

    bitmap.eraseColor(transparent ? Color.TRANSPARENT : mBkColor);
    int n = drawShapes(docs, gs, null, new Canvas(bitmap), canvasAdapter, false);
    Log.d(TAG, "snapshot(doc): " + n);
    canvasAdapter.delete();

    return bitmap;
  }
  @Override
  protected void onDraw(Canvas canvas) {
    //        if (y > -50) {
    //            y--;
    //        }
    // 采用三阶贝塞尔   不停地改变X 模拟水波效果
    if (x > 50) {
      isLeft = true;
    } else if (x < 0) {
      isLeft = false;
    }

    if (isLeft) {
      x = x - 1;
    } else {
      x = x + 1;
    }
    mPath.reset();
    y = (int) ((1 - mPercent / 100f) * mHeight);
    // 设置起点
    mPath.moveTo(0, y);
    // 画二阶贝塞尔曲线,前两个为辅助坐标点   第三个点为终点
    mPath.cubicTo(100 + x * 2, 50 + y, 100 + x * 2, y - 50, mWidth, y);
    mPath.lineTo(mWidth, mHeight); // 充满整个画布
    mPath.lineTo(0, mHeight); // 充满整个画布
    mPath.close();

    // 清除掉图像 不然path会重叠
    mBitmap.eraseColor(Color.parseColor("#00000000"));
    // dst
    //        mCanvas.drawBitmap(bgBitmap,0,0,null);
    //        mSRCPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_OVER));

    mCanvas.drawCircle(mWidth / 2, mHeight / 2, mWidth / 2, mSRCPaint);

    mWavePaint.setXfermode(mMode);
    // src
    mCanvas.drawPath(mPath, mWavePaint);
    mWavePaint.setXfermode(null);
    // 清空mBitmap,不然path会重叠
    canvas.drawBitmap(mBitmap, 0, 0, null);
    String str = mPercent + "";
    mTextPaint.setTextSize(80);
    float txtLength = mTextPaint.measureText(str);
    canvas.drawText(str, mWidth / 2 - txtLength / 2, mHeight / 2 + 15, mTextPaint);
    mTextPaint.setTextSize(40);
    canvas.drawText("%", mWidth / 2 + 50, mHeight / 2 - 20, mTextPaint);

    postInvalidateDelayed(10);
  }
Esempio n. 20
0
  @Override
  public synchronized Bitmap get(int width, int height, Bitmap.Config config) {
    Bitmap result = getDirty(width, height, config);
    if (result != null) {
      // Bitmaps in the pool contain random data that in some cases must be cleared for an image to
      // be rendered
      // correctly. we shouldn't force all consumers to independently erase the contents
      // individually, so we do so
      // here. See issue #131.
      result.eraseColor(Color.TRANSPARENT);
    }

    return result;
  }
Esempio n. 21
0
  public HandDraw(View v) {
    view = v;
    try {
      bitmapSrc =
          Bitmap.createBitmap(
              GlobalVariables.screenWidth, GlobalVariables.canvasHeigh, Bitmap.Config.ARGB_4444);
      bitmapSrc.eraseColor(0x0);
      canvasSrc = new Canvas(bitmapSrc);
      bitmapDst =
          Bitmap.createBitmap(
              GlobalVariables.screenWidth, GlobalVariables.canvasHeigh, Bitmap.Config.ARGB_4444);

      bitmapDst.eraseColor(0x0);
      canvasDst = new Canvas(bitmapDst);
      DrawingFactory factory = new DrawingFactory();
      pathDrawing = (PathLine) factory.createDrawing(DrawingId.DRAWING_PATHLINE, null);
      Paint paint = new Paint();
      paint = Brush.getPen();
      pathDrawing.setPen(paint);
      canvasSrc.setDrawFilter(new PaintFlagsDrawFilter(0x0, 0x3));
    } catch (OutOfMemoryError e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    // 笔迹颜色
    path = new Path();

    int colll = Brush.getPen().getColor();
    thinPen.setColor(colll);
    thinPen.setStrokeWidth(1.5f);
    thinPen.setAntiAlias(true);
    thinPen.setDither(true);
    thinPen.setStyle(Paint.Style.STROKE);
    thinPen.setStrokeJoin(Paint.Join.ROUND);
    thinPen.setStrokeCap(Paint.Cap.ROUND);
  }
Esempio n. 22
0
  /**
   * Snapshot a view into a Bitmap with the indicated background color.
   *
   * @param view The target {@link android.view.View}.
   * @param backgroundColor The background color of the Bitmap. If the view has transparency areas,
   *     these areas will be erased using this color.
   * @return Returns a Bitmap containing the view content, or {@code null} if any error occurs. Make
   *     sure to call {@link android.graphics.Bitmap#recycle()} as soon as possible, once its
   *     content is not needed anymore.
   */
  public Bitmap snapshotView(View view, int backgroundColor) {
    if (view == null) {
      return null;
    }

    int viewWidth = view.getRight() - view.getLeft();
    int viewHeight = view.getBottom() - view.getTop();

    int sampleWidth = viewWidth / mSampleSize;
    int sampleHeight = viewHeight / mSampleSize;
    float canvasScale = 1.f / mSampleSize;

    sampleWidth = sampleWidth > 0 ? sampleWidth : 1;
    sampleHeight = sampleHeight > 0 ? sampleHeight : 1;

    performanceTickBegin(
        "snapshotView "
            + view
            + " sampleSize = "
            + mSampleSize
            + " ("
            + sampleWidth
            + ", "
            + sampleHeight
            + "): ");

    Bitmap bitmap = Bitmap.createBitmap(sampleWidth, sampleHeight, Bitmap.Config.ARGB_8888);
    if (bitmap == null) {
      throw new OutOfMemoryError();
    }
    if ((backgroundColor & 0xff000000) != 0) {
      bitmap.eraseColor(backgroundColor);
    }

    bitmap.setDensity(mDisplayMetrics.densityDpi);

    Canvas canvas = new Canvas(bitmap);
    canvas.scale(view.getScaleX() * canvasScale, view.getScaleY() * canvasScale);
    canvas.translate(-view.getScrollX(), -view.getScrollY());

    view.computeScroll();
    view.draw(canvas);

    canvas.setBitmap(null);

    performanceTickEnd();

    return bitmap;
  }
Esempio n. 23
0
    private Bitmap loadBitmap(int width, int height, int index) {

      Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_4444);
      bitmap.eraseColor(0xFF00FFFF);
      Canvas canvas = new Canvas(bitmap);

      Paint p = new Paint();
      p.setColor(0xFF000000);
      p.setTextSize(200.0f);

      canvas.drawText(Integer.valueOf(index).toString(), 400, 400, p);
      canvas.drawRect(10, 10, 300, 300, p);

      return bitmap;
    }
Esempio n. 24
0
  private void createText(List<Ball> ballsArrayList, String text) {
    int w = (width / step) * step;
    int h = (height / step) * step;

    bitmap = Bitmap.createBitmap(w, h, Config.ARGB_8888);
    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setColor(Color.WHITE);
    paint.setTextSize((int) (h * 0.5));
    paint.setFakeBoldText(true);
    paint.setAntiAlias(true);
    paint.setTextAlign(Paint.Align.CENTER);
    bitmap.eraseColor(Color.BLACK);
    canvas.drawText(text, w / 2, (int) (h * 0.6), paint);

    int pix[] = new int[w * h];
    bitmap.getPixels(pix, 0, w, 0, 0, w, h);

    float s = 1.2f;
    float[] hsv = new float[3];

    int midx = w / 2, midy = h / 2;

    for (int y = 0; y < h; y += step) {
      for (int x = 0; x < w; x += step) {
        int offset = x + y * w;
        long sum = 0;
        for (int dy = 0; dy < step; dy++) {
          for (int dx = 0; dx < step; dx++) {
            sum += (pix[offset + dx + dy * w] & 0xff);
          }
        }

        sum = sum / (step * step);
        int radius = (int) (step * sum / 255);
        if (radius > 1) {
          hsv[0] = 360 * x / width;
          hsv[1] = 1;
          hsv[2] = 1;

          ballsArrayList.add(
              new Ball(
                  s * (x - midx) + midx, s * (y - midy) + midy, 0, radius, Color.HSVToColor(hsv)));
        }
      }
    }
    bitmap = null;
  }
  public void updateBackground() {
    if (getWidth() == 0 || getHeight() == 0) {
      return;
    }
    Bitmap background = Bitmap.createBitmap(getWidth(), getHeight(), Config.ARGB_8888);
    background.eraseColor(ColorPickerDialog.mNewColor);
    Canvas checkerdBackgroundCanvas = new Canvas(background);

    Rect colorRect = new Rect(0, 0, getWidth(), getHeight());
    if (ColorPickerDialog.mBackgroundPaint != null) {
      checkerdBackgroundCanvas.drawRect(colorRect, ColorPickerDialog.mBackgroundPaint);
    }
    mColorPaint.setColor(ColorPickerDialog.mNewColor);
    checkerdBackgroundCanvas.drawPaint(mColorPaint);
    setBackgroundDrawable(new BitmapDrawable(background));
  }
Esempio n. 26
0
 protected void draw_mode(int mode) {
   Log.e("navit", "draw_mode " + mode);
   if (mode == 2 && parent_graphics == null) {
     view.draw(draw_canvas);
     view.invalidate();
     view.requestRender();
   }
   if (mode == 1 || (mode == 0 && parent_graphics != null)) {
     if (renderer != null) {
       renderer.flb_len = 0;
     }
     draw_bitmap.eraseColor(0);
   }
   if (mode == 0 && renderer != null) {
     renderer.flb_len = 0;
   }
 }
Esempio n. 27
0
  @Override
  public Bitmap snapshot(boolean transparent) {
    if (mCachedBitmap != null && transparent == (mBkColor == Color.TRANSPARENT)) {
      synchronized (mCachedBitmap) {
        return mCachedBitmap.copy(Config.ARGB_8888, false);
      }
    }

    final Bitmap bitmap = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
    final CanvasAdapter canvasAdapter = new CanvasAdapter(this, mImageCache);

    bitmap.eraseColor(transparent ? Color.TRANSPARENT : mBkColor);
    int n = drawShapes(new Canvas(bitmap), canvasAdapter, false);
    Log.d(TAG, "snapshot: " + n);
    canvasAdapter.delete();

    return bitmap;
  }
  public static SmartTexture createSolid(int color) {
    String key = "1x1:" + color;

    if (all.containsKey(key)) {

      return all.get(key);

    } else {

      Bitmap bmp = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
      bmp.eraseColor(color);

      SmartTexture tx = new SmartTexture(bmp);
      all.put(key, tx);

      return tx;
    }
  }
Esempio n. 29
0
    private void interestingThumbnail(Bitmap image) {
      // image into OpenCV
      Mat imageMat = new Mat();
      bitmapToMat(image, imageMat);

      // find slice of interest
      /*Mat rowSums = new Mat(imageMat.height(), 1, CvType.CV_16U);
      for(int y = (int)(0.1*image.getHeight()); y < image.getHeight(); y++) {
          Mat row = new Mat(imageMat, new Rect(0, 0, imageMat.width(), imageMat.height()));
          rowSums.put(y, 1, (int)Core.sumElems(row).val[0]);
      }

      final int binSize = 32;
      double current = 0;
      int startPos = 0;
      for(int y = 0; y < rowSums.cols() - binSize; y++) {
          Mat binned = new Mat(rowSums, new Rect(y, 0, binSize, 1));
          double average = Core.sumElems(binned).val[0] / binSize;

          if(average > current)
              startPos = y;
          current = average;
      }

      // ensure not out of bounds
      if(startPos > imageMat.height() - binSize) startPos = imageMat.height() - binSize;

      // get slice of interest
      Rect roi = new Rect(0, startPos, imageMat.width(), binSize);
      Mat croppedRef = new Mat(imageMat, roi);
      Mat croppedMat = new Mat(croppedRef.width(), croppedRef.height(), croppedRef.type());
      croppedRef.copyTo(croppedMat);*/

      // image out of OpenCV
      // thumbnail = Bitmap.createBitmap(roi.width, roi.height, image.getConfig());
      thumbnail = Bitmap.createBitmap(imageMat.width(), 64, image.getConfig());
      thumbnail.eraseColor(
          Color.argb(
              255,
              (int) (Math.random() * 255),
              (int) (Math.random() * 255),
              (int) (Math.random() * 255)));
      // matToBitmap(croppedRef, thumbnail);
    }
Esempio n. 30
0
  public BitmapDrawable rotateDrawable(float angle) {
    Bitmap arrowBitmap =
        BitmapFactory.decodeResource(context.getResources(), R.drawable.location_arrow);
    // Create blank bitmap of equal size
    Bitmap canvasBitmap = arrowBitmap.copy(Bitmap.Config.ARGB_8888, true);
    canvasBitmap.eraseColor(0x00000000);

    // Create canvas
    Canvas canvas = new Canvas(canvasBitmap);

    // Create rotation matrix
    Matrix rotateMatrix = new Matrix();
    rotateMatrix.setRotate(angle, canvas.getWidth() / 2, canvas.getHeight() / 2);

    // Draw bitmap onto canvas using matrix
    canvas.drawBitmap(arrowBitmap, rotateMatrix, null);

    return new BitmapDrawable(canvasBitmap);
  }