Create Image with Reflection

1. /** 
2.      * This code is courtesy of Neil Davies at http://www.inter-fuser.com 
3.      * @param context the current context 
4.      * @param originalImage The original Bitmap image used to create the reflection 
5.      * @return the bitmap with a reflection 
6.      */  
7.     public static Bitmap createReflectedImage(Context context, Bitmap originalImage) {  
8.           //The gap we want between the reflection and the original image  
9.           final int reflectionGap = 4;  
10.             
11.                int width = originalImage.getWidth();  
12.                int height = originalImage.getHeight();  
13.                   
14.             
15.                //This will not scale but will flip on the Y axis  
16.                Matrix matrix = new Matrix();  
17.                matrix.preScale(1, -1);  
18.                   
19.                //Create a Bitmap with the flip matrix applied to it.  
20.                //We only want the bottom half of the image  
21.                Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0, height/2, width, height/2, matrix, false);  
22.                   
23.                       
24.                //Create a new bitmap with same width but taller to fit reflection  
25.                Bitmap bitmapWithReflection = Bitmap.createBitmap(width  
26.                  , (height + height/2), Config.ARGB_8888);  
27.                 
28.               //Create a new Canvas with the bitmap that's big enough for  
29.               //the image plus gap plus reflection  
30.               Canvas canvas = new Canvas(bitmapWithReflection);  
31.               //Draw in the original image  
32.               canvas.drawBitmap(originalImage, 0, 0, null);  
33.               //Draw in the gap  
34.               Paint defaultPaint = new Paint();  
35.               canvas.drawRect(0, height, width, height + reflectionGap, defaultPaint);  
36.               //Draw in the reflection  
37.               canvas.drawBitmap(reflectionImage,0, height + reflectionGap, null);  
38.                  
39.               //Create a shader that is a linear gradient that covers the reflection  
40.               Paint paint = new Paint();  
41.               LinearGradient shader = new LinearGradient(0, originalImage.getHeight(), 0,  
42.                 bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff,  
43.                 TileMode.CLAMP);  
44.              //Set the paint to use this shader (linear gradient)  
45.               paint.setShader(shader);  
46.               //Set the Transfer mode to be porter duff and destination in  
47.               paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));  
48.               //Draw a rectangle using the paint with our linear gradient  
49.               canvas.drawRect(0, height, width,  
50.                 bitmapWithReflection.getHeight() + reflectionGap, paint);  
51.                 
52.           return bitmapWithReflection;