@Override
  public Image newImage(String fileName, ImageFormat format) {
    Config config = null;
    if (format == ImageFormat.RGB565) config = Config.RGB_565;
    else if (format == ImageFormat.ARGB4444) config = Config.ARGB_4444;
    else config = Config.ARGB_8888;

    Options options = new Options();
    options.inPreferredConfig = config;

    InputStream in = null;
    Bitmap bitmap = null;
    try {
      in = assets.open(fileName);
      bitmap = BitmapFactory.decodeStream(in, null, options);
      if (bitmap == null)
        throw new RuntimeException("Couldn't load bitmap from asset '" + fileName + "'");
    } catch (IOException e) {
      throw new RuntimeException("Couldn't load bitmap from asset '" + fileName + "'");
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
        }
      }
    }

    if (bitmap.getConfig() == Config.RGB_565) format = ImageFormat.RGB565;
    else if (bitmap.getConfig() == Config.ARGB_4444) format = ImageFormat.ARGB4444;
    else format = ImageFormat.ARGB8888;

    return new AndroidImage(bitmap, format);
  }
Example #2
0
  @Override
  public Pixmap newPixmap(String fileName, PixmapFormat format) {
    Config config = null;
    if (format == PixmapFormat.RGB565) config = Config.RGB_565;
    else if (format == PixmapFormat.ARGB4444) config = Config.ARGB_4444;
    else config = Config.ARGB_8888;

    Options options = new Options();
    options.inPreferredConfig = config;

    InputStream in = null;
    Bitmap bitmap = null;
    try {
      in = assets.open(fileName);
      bitmap = BitmapFactory.decodeStream(in);
      if (bitmap == null)
        throw new RuntimeException("No se ha podido cargar bitmap desde asset '" + fileName + "'");
    } catch (IOException e) {
      throw new RuntimeException("No se ha podido cargar bitmap desde asset '" + fileName + "'");
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
        }
      }
    }

    if (bitmap.getConfig() == Config.RGB_565) format = PixmapFormat.RGB565;
    else if (bitmap.getConfig() == Config.ARGB_4444) format = PixmapFormat.ARGB4444;
    else format = PixmapFormat.ARGB8888;

    return new AndroidPixmap(bitmap, format);
  }
 public boolean prepareRenderscriptAllocations(Bitmap bitmap) {
   RenderScript RS = getRenderScriptContext();
   boolean needsUpdate = false;
   if (mOutPixelsAllocation == null
       || mInPixelsAllocation == null
       || bitmap.getWidth() != mWidth
       || bitmap.getHeight() != mHeight) {
     destroyPixelAllocations();
     Bitmap bitmapBuffer = bitmap;
     if (bitmap.getConfig() == null || bitmap.getConfig() != BITMAP_CONFIG) {
       bitmapBuffer = bitmap.copy(BITMAP_CONFIG, true);
     }
     mOutPixelsAllocation =
         Allocation.createFromBitmap(
             RS, bitmapBuffer, Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
     mInPixelsAllocation = Allocation.createTyped(RS, mOutPixelsAllocation.getType());
     needsUpdate = true;
   }
   if (RS != null) {
     mInPixelsAllocation.copyFrom(bitmap);
   }
   if (bitmap.getWidth() != mWidth || bitmap.getHeight() != mHeight) {
     mWidth = bitmap.getWidth();
     mHeight = bitmap.getHeight();
     needsUpdate = true;
   }
   if (DEBUG) {
     Log.v(LOGTAG, "prepareRenderscriptAllocations: " + needsUpdate + " in " + getName());
   }
   return needsUpdate;
 }
Example #4
0
  /**
   * Assert that two bitmaps are equal.
   *
   * @param Bitmap b1 the first bitmap which needs to compare.
   * @param Bitmap b2 the second bitmap which needs to compare.
   */
  public static void assertEquals(Bitmap b1, Bitmap b2) {
    if (b1 == b2) {
      return;
    }

    if (b1 == null || b2 == null) {
      Assert.fail("the bitmaps are not equal");
    }

    // b1 and b2 are all not null.
    if (b1.getWidth() != b2.getWidth()
        || b1.getHeight() != b2.getHeight()
        || b1.getConfig() != b2.getConfig()) {
      Assert.fail("the bitmaps are not equal");
    }

    int w = b1.getWidth();
    int h = b1.getHeight();
    int s = w * h;
    int[] pixels1 = new int[s];
    int[] pixels2 = new int[s];

    b1.getPixels(pixels1, 0, w, 0, 0, w, h);
    b2.getPixels(pixels2, 0, w, 0, 0, w, h);

    for (int i = 0; i < s; i++) {
      if (pixels1[i] != pixels2[i]) {
        Assert.fail("the bitmaps are not equal");
      }
    }
  }
Example #5
0
  @Override
  public Bitmap transform(Bitmap source) {
    int size = Math.min(source.getWidth(), source.getHeight());

    int x = (source.getWidth() - size) / 2;
    int y = (source.getHeight() - size) / 2;

    Bitmap squaredBitmap = Bitmap.createBitmap(source, x, y, size, size);
    if (squaredBitmap != source) {
      source.recycle();
    }
    if (source.getConfig() == null) {
      return source;
    }

    Bitmap bitmap = Bitmap.createBitmap(size, size, source.getConfig());

    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    BitmapShader shader =
        new BitmapShader(squaredBitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
    paint.setShader(shader);
    paint.setAntiAlias(true);

    float r = size / 2f;
    canvas.drawCircle(r, r, r, paint);

    squaredBitmap.recycle();
    return bitmap;
  }
  @Override
  public Resource<Bitmap> transform(Resource<Bitmap> resource, int outWidth, int outHeight) {
    Bitmap source = resource.get();

    int width = source.getWidth();
    int height = source.getHeight();

    Bitmap.Config config =
        source.getConfig() != null ? source.getConfig() : Bitmap.Config.ARGB_8888;
    Bitmap bitmap = mBitmapPool.get(width, height, config);
    if (bitmap == null) {
      bitmap = Bitmap.createBitmap(width, height, config);
    }

    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShader(new BitmapShader(source, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP));
    canvas.drawRoundRect(
        new RectF(margin, margin, width - margin, height - margin), radius, radius, paint);

    source.recycle();

    return BitmapResource.obtain(bitmap, mBitmapPool);
  }
Example #7
0
 public void loadFromCroppedColorArray(int x, int y, int width, int height) {
   int[] pixels = new int[width * height];
   mOriginalBitmap.getPixels(pixels, 0, width, x, y, width, height);
   CloseableReference<Bitmap> bitmapRef =
       mBitmapFactory.createBitmap(pixels, width, height, mOriginalBitmap.getConfig());
   setImageBitmap(bitmapRef);
   checkValid(bitmapRef, Bitmap.createBitmap(pixels, width, height, mOriginalBitmap.getConfig()));
 }
  @Override
  public void put(Bitmap bitmap) {
    int size = Util.getBitmapByteSize(bitmap);
    Key key = keyPool.get(size, bitmap.getConfig());

    groupedMap.put(key, bitmap);

    NavigableMap<Integer, Integer> sizes = getSizesForConfig(bitmap.getConfig());
    Integer current = sizes.get(key.size);
    sizes.put(key.size, current == null ? 1 : current + 1);
  }
Example #9
0
 public void loadFromColorArray() {
   int[] pixels = new int[mOriginalWidth * mOriginalHeight];
   mOriginalBitmap.getPixels(pixels, 0, mOriginalWidth, 0, 0, mOriginalWidth, mOriginalHeight);
   CloseableReference<Bitmap> bitmapRef =
       mBitmapFactory.createBitmap(
           pixels, mOriginalWidth, mOriginalHeight, mOriginalBitmap.getConfig());
   setImageBitmap(bitmapRef);
   checkValid(
       bitmapRef,
       Bitmap.createBitmap(pixels, mOriginalWidth, mOriginalHeight, mOriginalBitmap.getConfig()));
 }
  @Override
  @Nullable
  public Bitmap get(int width, int height, Bitmap.Config config) {
    int size = Util.getBitmapByteSize(width, height, config);
    Key bestKey = findBestKey(size, config);

    Bitmap result = groupedMap.get(bestKey);
    if (result != null) {
      // Decrement must be called before reconfigure.
      decrementBitmapOfSize(bestKey.size, result);
      result.reconfigure(
          width, height, result.getConfig() != null ? result.getConfig() : Bitmap.Config.ARGB_8888);
    }
    return result;
  }
 @Test
 public void testFitCenterHandlesBitmapsWithNullConfigs() {
   Bitmap toFit = Bitmap.createBitmap(100, 100, Bitmap.Config.RGB_565);
   Shadows.shadowOf(toFit).setConfig(null);
   Bitmap transformed = TransformationUtils.fitCenter(bitmapPool, toFit, 50, 50);
   assertEquals(Bitmap.Config.ARGB_8888, transformed.getConfig());
 }
Example #12
0
  @Override
  public Bitmap filter(Bitmap bitmap) {
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();

    Logger.v(name + ", multiplier: " + multiplier + ", divider: " + divider + ", bias: " + bias);

    if (bitmap == null || divider == 0 || (multiplier == 1 && divider == 1 && bias == 0)) {
      Logger.e("parameter error (bitmap null, divider is zero, or given filter has no effect)");
      return null;
    }

    int[] bitmapBytes = new int[width * height];
    bitmap.getPixels(bitmapBytes, 0, width, 0, 0, width, height);

    int color;
    for (int i = 0; i < bitmapBytes.length; i++) {
      color = bitmapBytes[i];

      bitmapBytes[i] =
          Color.rgb(
              forcepin(0, r(color) * multiplier / divider + bias, 255),
              forcepin(0, g(color) * multiplier / divider + bias, 255),
              forcepin(0, b(color) * multiplier / divider + bias, 255));
    }

    return Bitmap.createBitmap(bitmapBytes, width, height, bitmap.getConfig());
  }
 public static void getAvatarForFancyQrCode(GetAvatarListener getAvatarListener) {
   Paint paint = new Paint();
   paint.setAntiAlias(true);
   Resources res = BitherApplication.mContext.getResources();
   Bitmap shape = BitmapFactory.decodeResource(res, R.drawable.avatar_for_fancy_qr_code_shape);
   Bitmap result = Bitmap.createBitmap(shape.getWidth(), shape.getHeight(), shape.getConfig());
   Canvas c = new Canvas(result);
   c.drawBitmap(shape, 0, 0, paint);
   Paint avatarPaint = new Paint();
   avatarPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
   avatarPaint.setAntiAlias(true);
   Bitmap avatarBit = getAvatarBit();
   if (avatarBit == null) {
     if (getAvatarListener != null) {
       getAvatarListener.fileNoExist();
     }
     return;
   }
   c.drawBitmap(
       avatarBit, null, new Rect(0, 0, result.getWidth(), result.getHeight()), avatarPaint);
   Bitmap overlay = BitmapFactory.decodeResource(res, R.drawable.avatar_for_fancy_qr_code_overlay);
   c.drawBitmap(overlay, null, new Rect(0, 0, result.getWidth(), result.getHeight()), paint);
   if (result != null) {
     if (getAvatarListener != null) {
       getAvatarListener.success(result);
     }
   }
 }
Example #14
0
 public void writeToParcel(Parcel paramParcel, int paramInt) {
   Bitmap localBitmap;
   Object localObject;
   byte[] arrayOfByte;
   if (zzDy == null) {
     localBitmap = zzaiT;
     localObject = ByteBuffer.allocate(localBitmap.getRowBytes() * localBitmap.getHeight());
     localBitmap.copyPixelsToBuffer((Buffer) localObject);
     arrayOfByte = ((ByteBuffer) localObject).array();
     localObject = new DataOutputStream(zzpf());
   }
   try {
     ((DataOutputStream) localObject).writeInt(arrayOfByte.length);
     ((DataOutputStream) localObject).writeInt(localBitmap.getWidth());
     ((DataOutputStream) localObject).writeInt(localBitmap.getHeight());
     ((DataOutputStream) localObject).writeUTF(localBitmap.getConfig().toString());
     ((DataOutputStream) localObject).write(arrayOfByte);
     zza((Closeable) localObject);
     zza.zza(this, paramParcel, paramInt | 0x1);
     zzDy = null;
     return;
   } catch (IOException paramParcel) {
     throw new IllegalStateException("Could not write into unlinked file", paramParcel);
   } finally {
     zza((Closeable) localObject);
   }
   throw paramParcel;
 }
Example #15
0
  @Override
  public Bitmap transform(Bitmap source) {
    int size = Math.min(source.getWidth(), source.getHeight());

    int x = (source.getWidth() - size) / 2;
    int y = (source.getHeight() - size) / 2;

    Bitmap squaredBitmap = Bitmap.createBitmap(source, x, y, size, size);
    if (squaredBitmap != source) {
      source.recycle();
    }

    Bitmap bitmap = Bitmap.createBitmap(size, size, source.getConfig());

    Canvas canvas = new Canvas(bitmap);

    Paint avatarPaint = new Paint();
    BitmapShader shader =
        new BitmapShader(squaredBitmap, BitmapShader.TileMode.CLAMP, BitmapShader.TileMode.CLAMP);
    avatarPaint.setShader(shader);

    Paint outlinePaint = new Paint();
    outlinePaint.setColor(Color.WHITE);
    outlinePaint.setStyle(Paint.Style.STROKE);
    outlinePaint.setStrokeWidth(STROKE_WIDTH);
    outlinePaint.setAntiAlias(true);

    float r = size / 2f;
    canvas.drawCircle(r, r, r, avatarPaint);
    canvas.drawCircle(r, r, r - STROKE_WIDTH / 2, outlinePaint);

    squaredBitmap.recycle();
    return bitmap;
  }
  @Override
  public void onResult(Bitmap bitmap) {

    int[][] se =
        new int[][] {
          {1, 1},
          {1, 1}
        };

    Bitmap bmFinal = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());

    BitmapUtils.erosion(bitmap, se);
    int m = BitmapUtils.dilate(bitmap, bmFinal, se);
    // int m = BitmapUtils.countSE(bitmap, se);

    int c = BitmapUtils.getPixelsCount(bmFinal);
    int pc = BitmapUtils.getContactCount(bmFinal);

    ImageView iv = ((ImageView) getView().findViewById(R.id.image2));
    iv.setImageBitmap(bmFinal);
    iv.invalidate();

    int r = c + m - pc;

    ((TextView) getView().findViewById(R.id.textView1))
        .setText("Segments: " + r + " = " + c + " + " + m + " - " + pc);
  }
Example #17
0
  private Bitmap FrameProcessingBitmap() {
    Bitmap bm1 = null;
    Bitmap newBitmap = null;

    try {
      bm1 = BitmapFactory.decodeStream(context.getContentResolver().openInputStream(path));

      int w = bm1.getWidth();
      int h = bm1.getHeight();

      Bitmap.Config config = bm1.getConfig();
      if (config == null) {
        config = Bitmap.Config.ARGB_8888;
      }

      newBitmap = Bitmap.createBitmap(w, h, config);
      Canvas newCanvas = new Canvas(newBitmap);
      newCanvas.drawColor(Color.WHITE);

      Paint paint = new Paint();
      paint.setColor(Color.BLACK);
      Rect frame = new Rect((int) (w * 0.05), (int) (w * 0.05), (int) (w * 0.95), (int) (h * 0.95));
      RectF frameF = new RectF(frame);
      newCanvas.drawRoundRect(frameF, (float) (w * 0.05), (float) (h * 0.05), paint);

      paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SCREEN));
      newCanvas.drawBitmap(bm1, 0, 0, paint);

    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    return newBitmap;
  }
  /**
   * Blurs the given Bitmap using RenderScript.
   *
   * @param context
   * @param bitmap
   * @return
   */
  @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
  private static Bitmap blurUsingRenderScript(final Context context, final Bitmap bitmap) {
    // Create another bitmap that will hold the results of the filter.
    Bitmap blurredBitmap = bitmap.copy(bitmap.getConfig(), true);

    if (blurredBitmap != null) {
      // Create the Renderscript instance that will do the work.
      RenderScript rs = RenderScript.create(context);

      // Allocate memory for Renderscript to work with
      Allocation input =
          Allocation.createFromBitmap(
              rs, blurredBitmap, Allocation.MipmapControl.MIPMAP_FULL, Allocation.USAGE_SCRIPT);
      Allocation output = Allocation.createTyped(rs, input.getType());

      // Load up an instance of the specific script that we want to use.
      ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
      script.setInput(input);
      script.setRadius(4); // Set the blur radius
      script.forEach(output); // Start the ScriptIntrinisicBlur
      output.copyTo(blurredBitmap); // Copy the output to the blurred bitmap
    }

    return blurredBitmap;
  }
  @Override
  protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    super.onActivityResult(requestCode, resultCode, intent);

    if (resultCode == RESULT_OK) {
      Uri imageFileUri = intent.getData();
      try {
        BitmapFactory.Options bmpFactoryOptions = new BitmapFactory.Options();
        bmpFactoryOptions.inJustDecodeBounds = true;
        bmp =
            BitmapFactory.decodeStream(
                getContentResolver().openInputStream(imageFileUri), null, bmpFactoryOptions);

        bmpFactoryOptions.inJustDecodeBounds = false;
        bmp =
            BitmapFactory.decodeStream(
                getContentResolver().openInputStream(imageFileUri), null, bmpFactoryOptions);

        alteredBitmap =
            Bitmap.createBitmap(drawingArea.getWidth(), drawingArea.getHeight(), bmp.getConfig());

        canvas = new Canvas(alteredBitmap);
        paint = new Paint();
        paint.setColor(Color.GREEN);
        paint.setStrokeWidth(5);
        matrix = new Matrix();
        canvas.drawBitmap(bmp, matrix, paint);

        drawingArea.cache = alteredBitmap;

      } catch (Exception e) {
        Log.v("ERROR", e.toString());
      }
    }
  }
Example #20
0
  public static Bitmap drawTextToBitmap(Context mContext, Bitmap bitmap, Location location) {
    Resources resources = mContext.getResources();
    float scale = resources.getDisplayMetrics().density;
    Bitmap.Config bitmapConfig = bitmap.getConfig();
    if (bitmapConfig == null) {
      bitmapConfig = Bitmap.Config.ARGB_8888;
    }
    bitmap = bitmap.copy(bitmapConfig, true);

    Canvas canvas = new Canvas(bitmap);
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint.setColor(mContext.getResources().getColor(R.color.white));
    paint.setTextSize((int) 13);
    paint.setStyle(Paint.Style.FILL_AND_STROKE);

    Paint paint1 = new Paint(Paint.ANTI_ALIAS_FLAG);
    paint1.setColor(mContext.getResources().getColor(R.color.green));

    String text = getText(location);
    Paint.FontMetrics fm = new Paint.FontMetrics();
    paint1.setTextAlign(Paint.Align.CENTER);
    paint1.getFontMetrics(fm);
    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    if (height > width) {
      canvas.drawRect(0, height - 40, height - 40, height, paint1);
      canvas.drawText(text, 5, height - 10, paint);
    } else {
      canvas.drawRect(0, 0, width, 40, paint1);
      canvas.drawText(text, 5, 25, paint);
    }
    Log.i(LOGTAG, "Check: Text drawn on bitmap");
    return bitmap;
  }
Example #21
0
  /**
   * Returns a Texture2D object given an CGImageRef image If the image was not previously loaded, it
   * will create a new CCTexture2D object and it will return it. Otherwise it will return a
   * reference of a previously loaded image The "key" parameter will be used as the "key" for the
   * cache. If "key" is nil, then a new texture will be created each time.
   *
   * <p>BE AWARE OF the fact that copy of image is stored in memory, use assets method if you can.
   *
   * @since v0.8
   */
  public CCTexture2D addImage(Bitmap image, String key) {
    assert (image != null) : "TextureCache: image must not be null";
    CCTexture2D tex = null;

    if (key != null && (tex = textures.get(key)) != null) {
      return tex;
    }

    final Bitmap copy = image.copy(image.getConfig(), false);

    if (copy != null) {
      final CCTexture2D texNew = new CCTexture2D();
      texNew.setLoader(
          new GLResourceHelper.GLResourceLoader() {
            @Override
            public void load() {
              Bitmap initImage = copy.copy(copy.getConfig(), false);
              texNew.initWithImage(initImage);
            }
          });
      if (key != null) {
        textures.put(key, texNew);
      }

      return texNew;
    } else {
      ccMacros.CCLOG("cocos2d", "Couldn't add Bitmap in CCTextureCache");
      return null;
    }
  }
Example #22
0
  private void createSingleImageFromMultipleImages(Bitmap bitmap, int mCounter) {
    if (mCounter == 0) {
      try {
        this.mManyBitmapSuperposition =
            Bitmap.createBitmap(
                DeviceInfo.mScreenWidthForPortrait,
                DeviceInfo.mScreenHeightForPortrait,
                bitmap.getConfig());
        this.mCanvas = new Canvas(this.mManyBitmapSuperposition);
      } catch (OutOfMemoryError error) {
        error.printStackTrace();
        System.gc();
      } finally {

      }
    }
    if (this.mCanvas != null) {
      int number = DeviceInfo.mScreenHeightForPortrait / 64;
      if (mCounter >= (mCounter / number) * number
          && mCounter < ((mCounter / number) + SNOW_BLOCK) * number) {
        this.mCanvas.drawBitmap(
            bitmap, (float) ((mCounter / number) * 64), (float) ((mCounter % number) * 64), null);
      }
    }
  }
Example #23
0
  public static LayerDrawable GetLayeredImg(
      Context c, String rid1, String product, String url, boolean spotters) {

    Bitmap bitmap;
    String cod_url;
    final String scale_type = "cod";

    if (url.equals("")) {
      cod_url = GetCOD(rid1, product);
      bitmap = UtilityDownload.getBitmapFromURL(cod_url);
    } else {
      bitmap = UtilityDownload.getBitmapFromURL(url);
    }

    if (!MyApplication.black_bg) {
      bitmap = UtilityImg.BM_BlackToWhite(bitmap);
    }

    if ((!product.equals("OHA")) && (!product.equals("NVW"))) {
      android.graphics.Bitmap.Config bitmapConfig = bitmap.getConfig();
      if (bitmapConfig == null) {
        bitmapConfig = android.graphics.Bitmap.Config.ARGB_8888;
      }
      bitmap = bitmap.copy(bitmapConfig, true);
      UtilityCanvasMain.AddCanvasItems(bitmap, scale_type, rid1, 0, spotters, false, 22);
    }

    return UtilityImg.BitmapToLayerDrawable(c, bitmap);
  }
Example #24
0
 @Test
 public void decodeResource_shouldSetDefaultBitmapConfig() throws Exception {
   Bitmap bitmap =
       BitmapFactory.decodeResource(Robolectric.application.getResources(), R.drawable.an_image);
   assertThat(bitmap.getConfig()).isEqualTo(Bitmap.Config.ARGB_8888);
   assertThat(bitmap.getRowBytes()).isNotZero();
 }
  /**
   * Get the white icon corresponding to a poiType.
   *
   * @param poiType the PoiType or null for notes.
   * @return The white icon.
   */
  public Drawable getIconWhite(PoiType poiType) {
    Bitmap myBitmap =
        BitmapFactory.decodeResource(
            context.getResources(),
            poiType == null ? R.drawable.open_book : getIconDrawableId(poiType));
    myBitmap = myBitmap.copy(myBitmap.getConfig(), true);

    int[] allpixels = new int[myBitmap.getHeight() * myBitmap.getWidth()];

    myBitmap.getPixels(
        allpixels, 0, myBitmap.getWidth(), 0, 0, myBitmap.getWidth(), myBitmap.getHeight());

    for (int i = 0; i < myBitmap.getHeight() * myBitmap.getWidth(); i++) {
      if (allpixels[i] != 0) {
        int A = Color.alpha(allpixels[i]);
        // inverting byte for each R/G/B channel
        int R = 255 - Color.red(allpixels[i]);
        int G = 255 - Color.green(allpixels[i]);
        int B = 255 - Color.blue(allpixels[i]);
        // set newly-inverted pixel to output image
        allpixels[i] = Color.argb(A, R, G, B);
      }
    }

    myBitmap.setPixels(
        allpixels, 0, myBitmap.getWidth(), 0, 0, myBitmap.getWidth(), myBitmap.getHeight());

    return new BitmapDrawable(context.getResources(), myBitmap);
  }
Example #26
0
  public static Bitmap doColorFilter(Bitmap src, double red, double green, double blue) {
    // image size
    int width = src.getWidth();
    int height = src.getHeight();
    // create output bitmap
    Bitmap bmOut = Bitmap.createBitmap(width, height, src.getConfig());
    // color information
    int A, R, G, B;
    int pixel;

    // scan through all pixels
    for (int x = 0; x < width; ++x) {
      for (int y = 0; y < height; ++y) {
        // get pixel color
        pixel = src.getPixel(x, y);
        // apply filtering on each channel R, G, B
        A = Color.alpha(pixel);
        R = (int) (Color.red(pixel) * red);
        G = (int) (Color.green(pixel) * green);
        B = (int) (Color.blue(pixel) * blue);
        // set new color pixel to output bitmap
        bmOut.setPixel(x, y, Color.argb(A, R, G, B));
      }
    }

    // return final image
    return bmOut;
  }
 public void writeToParcel(Parcel parcel, int i)
 {
     Object obj;
     Bitmap bitmap;
     byte abyte0[];
     if (zzEo != null)
     {
         break MISSING_BLOCK_LABEL_100;
     }
     bitmap = zzaba;
     obj = ByteBuffer.allocate(bitmap.getRowBytes() * bitmap.getHeight());
     bitmap.copyPixelsToBuffer(((java.nio.Buffer) (obj)));
     abyte0 = ((ByteBuffer) (obj)).array();
     obj = new DataOutputStream(zznR());
     ((DataOutputStream) (obj)).writeInt(abyte0.length);
     ((DataOutputStream) (obj)).writeInt(bitmap.getWidth());
     ((DataOutputStream) (obj)).writeInt(bitmap.getHeight());
     ((DataOutputStream) (obj)).writeUTF(bitmap.getConfig().toString());
     ((DataOutputStream) (obj)).write(abyte0);
     zza(((Closeable) (obj)));
     com.google.android.gms.common.data.zza.zza(this, parcel, i | 1);
     zzEo = null;
     return;
     parcel;
     throw new IllegalStateException("Could not write into unlinked file", parcel);
     parcel;
     zza(((Closeable) (obj)));
     throw parcel;
 }
Example #28
0
 private static Config getConfig(Bitmap bitmap) {
   Config config = bitmap.getConfig();
   if (config == null) {
     config = Config.ARGB_8888;
   }
   return config;
 }
Example #29
0
 /** Returns the in memory size of the given {@link Bitmap} in bytes. */
 @TargetApi(Build.VERSION_CODES.KITKAT)
 public static int getBitmapByteSize(Bitmap bitmap) {
   // The return value of getAllocationByteCount silently changes for recycled bitmaps from the
   // internal buffer size to row bytes * height. To avoid random inconsistencies in caches, we
   // instead assert here.
   if (bitmap.isRecycled()) {
     throw new IllegalStateException(
         "Cannot obtain size for recycled Bitmap: "
             + bitmap
             + "["
             + bitmap.getWidth()
             + "x"
             + bitmap.getHeight()
             + "] "
             + bitmap.getConfig());
   }
   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
     // Workaround for KitKat initial release NPE in Bitmap, fixed in MR1. See issue #148.
     try {
       return bitmap.getAllocationByteCount();
     } catch (NullPointerException e) {
       // Do nothing.
     }
   }
   return bitmap.getHeight() * bitmap.getRowBytes();
 }
Example #30
0
  public static Bitmap drawTextToBitmap(Context context, int resId, String text) {
    Resources resources = context.getResources();

    Bitmap bitmap = BitmapFactory.decodeResource(resources, resId);

    Bitmap.Config bitmapConfig = bitmap.getConfig();
    // set default bitmap config if none
    if (bitmapConfig == null) {
      bitmapConfig = android.graphics.Bitmap.Config.ARGB_8888;
    }
    // resource bitmaps are immutable,
    // so we need to convert it to mutable one
    bitmap = bitmap.copy(bitmapConfig, true);

    // new antialised Paint
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    // text color
    paint.setColor(colors900[random.nextInt(colors900.length)]);
    // text size in pixels
    paint.setTextSize((int) (30 * resources.getDisplayMetrics().density));
    // text shadow
    paint.setShadowLayer(1f, 0f, 1f, Color.WHITE);

    // draw text to the Canvas center
    Rect bounds = new Rect();
    paint.getTextBounds(text, 0, text.length(), bounds);
    int x = (bitmap.getWidth() - bounds.width()) / 2;
    int y = (bitmap.getHeight() + bounds.height()) / 2;

    new Canvas(bitmap).drawText(text, x, y, paint);

    return bitmap;
  }