ड्रॉप छाया के साथ कस्टम ImageView


98

ठीक है, मैं पढ़ रहा हूं और चारों ओर खोज रहा हूं, और अब मैं दीवार के खिलाफ अपना सिर पीट रहा हूं ताकि यह पता लगाने की कोशिश की जा सके। यहाँ मेरे पास अभी तक क्या है:

package com.pockdroid.sandbox;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.widget.ImageView;

public class ShadowImageView extends ImageView {

private Rect mRect;
private Paint mPaint;

public ShadowImageView(Context context)
{
    super(context);
    mRect = new Rect();
    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setShadowLayer(2f, 1f, 1f, Color.BLACK);
}

@Override
protected void onDraw(Canvas canvas) 
{
    Rect r = mRect;
    Paint paint = mPaint;

    canvas.drawRect(r, paint);
    super.onDraw(canvas);
}

@Override
protected void onMeasure(int w, int h)
{
    super.onMeasure(w,h);
    int mH, mW;
    mW = getSuggestedMinimumWidth() < getMeasuredWidth()? getMeasuredWidth() : getSuggestedMinimumWidth();
    mH = getSuggestedMinimumHeight() < getMeasuredHeight()? getMeasuredHeight() : getSuggestedMinimumHeight();
    setMeasuredDimension(mW + 5, mH + 5);
}

}

माप में "+5" वहाँ के रूप में अस्थायी हैं; मुझे जो समझ में आता है, मुझे उस आकार को निर्धारित करने के लिए कुछ गणित करने की आवश्यकता होगी जो ड्रॉप शैडो कैनवास पर जोड़ता है, है ना?

लेकिन जब मैं इसका उपयोग करता हूं:

public View getView(int position, View convertView, ViewGroup parent) {
    ShadowImageView sImageView;
    if (convertView == null) {
        sImageView = new ShadowImageView(mContext);
        GridView.LayoutParams lp = new GridView.LayoutParams(85, 85);
        sImageView.setLayoutParams(lp);

        sImageView.setScaleType(ImageView.ScaleType.CENTER);
        sImageView.setPadding(5,5,5,5);
    } else {
        sImageView = (ShadowImageView) convertView;
    }

    sImageView.setImageBitmap(bitmapList.get(position));
    return sImageView;
}

जब मैं प्रोग्राम चलाता हूं, तो मेरे ImageView में, मुझे अभी भी एक सामान्य ImageView मिलता है।

कोई विचार? धन्यवाद।

संपादित करें: तो मैंने IRain चैनल में कुछ रोमैनग्यू के साथ बात की, और मेरे पास अब नीचे दिए गए कोड के साथ सादे आयताकार चित्रों के लिए काम कर रहा है। यह अभी भी छाया को सीधे मेरे बिटमैप की पारदर्शिता की ओर आकर्षित नहीं करेगा, लेकिन मैं अभी भी उस पर काम कर रहा हूं।

@Override
protected void onDraw(Canvas canvas) 
{
    Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.omen);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    paint.setShadowLayer(5.5f, 6.0f, 6.0f, Color.BLACK);
    canvas.drawColor(Color.GRAY);
    canvas.drawRect(50, 50, 50 + bmp.getWidth(), 50 + bmp.getHeight(), paint);
    canvas.drawBitmap(bmp, 50, 50, null);       
}

"यह अब सादा आयताकार चित्रों के लिए काम कर रहा है" ... तो यह गैर-आयताकार छवियों के लिए काम नहीं करता है, और फिर मुझे लगता है कि यह 9patch-images के लिए भी काम नहीं करता है, सही है? क्या इस बीच आपको काम करने को मिला? क्योंकि रोमेन गाइ का यह दृष्टिकोण मेरे परीक्षण में अभी तक मेरे लिए काम नहीं करता है।
मथियास कॉनराड

हम्म, दिलचस्प सवाल। मुझे लगता है कि आप शायद 9-पैच का उपयोग करने वाले अपने दृश्य को ले सकते हैं, और इसे फ्रेमलेयआउट में लपेट सकते हैं, और फ़्रेमलेयआउट को ड्रॉप शैडो 9-पैच पृष्ठभूमि दे सकते हैं। लेकिन हाँ, यह केवल आयताकार छवियों के लिए काम करता है, क्योंकि इसमें 9-पैच के लिए कोई रास्ता नहीं है ताकि पारदर्शिता का पालन किया जा सके। मैं दुर्भाग्य से एक बेहतर समाधान नहीं मिला है, हालांकि, मैं वास्तव में फिर से कोशिश नहीं की है।
केविन कोपॉक

जवाबों:


122

ठीक है, मैं इस पर किसी भी अधिक जवाब की उम्मीद नहीं करता हूं, इसलिए मैंने जो अभी के लिए समाप्त किया है वह सिर्फ आयताकार छवियों के लिए एक समाधान है। मैंने निम्न NinePatch का उपयोग किया है:

वैकल्पिक शब्द

XML में उपयुक्त पैडिंग के साथ:

<ImageView
        android:id="@+id/image_test"
        android:background="@drawable/drop_shadow"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:paddingLeft="6px"
        android:paddingTop="4px"
        android:paddingRight="8px"
        android:paddingBottom="9px"
        android:src="@drawable/pic1"
        />

एक अच्छा परिणाम प्राप्त करने के लिए:

वैकल्पिक शब्द

आदर्श नहीं है, लेकिन यह करूँगा।


17
Png को drop_shadow.9.png के रूप में सहेजना न भूलें।
एनपीके

1
वाह, मैंने कोड में ऐसा करने की कोशिश में बहुत समय बिताया। बहुत अधिक सुरुचिपूर्ण समाधान!
निक रीमन

उन छवियों के बारे में जो दृश्य सीमा को समायोजित करने की आवश्यकता है?
StackOverflowed 11

अगर आप इसे सही तरीके से बनाते हैं तो आपको draw9patch टूल का उपयोग करने की कोई आवश्यकता नहीं है।
केविन कोप्पॉक

2
कुछ और स्टेप ट्यूटोरियल स्टेप ट्यूटोरियल यहां देखे
बार्ट बर्ग

105

यह रोमेन गाइ की Devoxx की प्रस्तुति से लिया गया है, पीडीएफ यहां पाया गया है

Paint mShadow = new Paint(); 
// radius=10, y-offset=2, color=black 
mShadow.setShadowLayer(10.0f, 0.0f, 2.0f, 0xFF000000); 
// in onDraw(Canvas) 
canvas.drawBitmap(bitmap, 0.0f, 0.0f, mShadow);

उम्मीद है की यह मदद करेगा।

टिप्पणियाँ

  1. छत्ते के लिए मत भूलना और ऊपर आपको आह्वान करने की आवश्यकता है setLayerType(LAYER_TYPE_SOFTWARE, mShadow), अन्यथा आप अपनी छाया नहीं देखेंगे! (@Dmitriy_Boichenko)
  2. SetShadowLayerहार्डवेयर त्वरण के साथ काम नहीं करता है दुर्भाग्य से इसलिए यह प्रदर्शन को कम करता है (@Matt Wear) [1] [2]

मैं बाद में यह कोशिश जरूर करूंगा! पीडीएफ के लिए भी धन्यवाद, दिलचस्प सामान की तरह दिखता है। क्या यह प्रस्तुति वीडियो ऑनलाइन देखने के लिए उपलब्ध है?
केविन कोपॉक

14
हनीकॉम्ब और उससे ऊपर के इनवोक सेटलेयरटेप (LAYER_TYPE_SOFTWARE, mShadow) को न भूलें। अगर नहीं तो आपको अपनी परछाई नहीं दिखेगी।
दिमित्रो बोइचेंको 17

5
setShadowLayer दुर्भाग्य से हार्डवेयर त्वरण के साथ काम नहीं करता है।
मैट वियर

आप आकृतियों पर भी एक पेंट लागू करते हैं, इसलिए छाया परत उनके लिए काम करती है। हालाँकि, इसे एक आकार में आंतरिक 'छेद' पर लागू नहीं किया जाएगा।
आवारा

5
Devoxx लिंक मृत है
joao2fast4u

14

मेरा मानना ​​है कि यह उत्तर यूफ्यूल से है

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

     <!-- Drop Shadow Stack -->
     <item>
        <shape>
            <padding android:top="1dp" android:right="1dp" android:bottom="1dp" android:left="1dp" />
            <solid android:color="#00CCCCCC" />
        </shape>
    </item>
     <item>
        <shape>
            <padding android:top="1dp" android:right="1dp" android:bottom="1dp" android:left="1dp" />
            <solid android:color="#10CCCCCC" />
        </shape>
    </item>
     <item>
        <shape>
            <padding android:top="1dp" android:right="1dp" android:bottom="1dp" android:left="1dp" />
            <solid android:color="#20CCCCCC" />
        </shape>
    </item>
     <item>
        <shape>
            <padding android:top="1dp" android:right="1dp" android:bottom="1dp" android:left="1dp" />
            <solid android:color="#30CCCCCC" />
        </shape>
    </item>
    <item>
        <shape>
            <padding android:top="1dp" android:right="1dp" android:bottom="1dp" android:left="1dp" />
            <solid android:color="#50CCCCCC" />
        </shape>
    </item>

    <!-- Background -->
    <item>
    <shape>
            <solid android:color="@color/white" />
        <corners android:radius="3dp" />
    </shape>
    </item>
</layer-list>

12

मेरा गंदा समाधान:

private static Bitmap getDropShadow3(Bitmap bitmap) {

    if (bitmap==null) return null;
    int think = 6;
    int w = bitmap.getWidth();
    int h = bitmap.getHeight();

    int newW = w - (think);
    int newH = h - (think);

    Bitmap.Config conf = Bitmap.Config.ARGB_8888;
    Bitmap bmp = Bitmap.createBitmap(w, h, conf);
    Bitmap sbmp = Bitmap.createScaledBitmap(bitmap, newW, newH, false);

    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    Canvas c = new Canvas(bmp);

    // Right
    Shader rshader = new LinearGradient(newW, 0, w, 0, Color.GRAY, Color.LTGRAY, Shader.TileMode.CLAMP);
    paint.setShader(rshader);
    c.drawRect(newW, think, w, newH, paint);

    // Bottom
    Shader bshader = new LinearGradient(0, newH, 0, h, Color.GRAY, Color.LTGRAY, Shader.TileMode.CLAMP);
    paint.setShader(bshader);
    c.drawRect(think, newH, newW  , h, paint);

    //Corner
    Shader cchader = new LinearGradient(0, newH, 0, h, Color.LTGRAY, Color.LTGRAY, Shader.TileMode.CLAMP);
    paint.setShader(cchader);
    c.drawRect(newW, newH, w  , h, paint);


    c.drawBitmap(sbmp, 0, 0, null);

    return bmp;
}

परिणाम: यहां छवि विवरण दर्ज करें


यह हमेशा नीली छाया देता है!
अनिमेष मंगला

8

आप यहाँ हैं। छवि का स्रोत स्थिर रूप से xml में या कोड में गतिशील रूप से सेट करें।

छाया यहां सफेद है।

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="wrap_content" android:layout_height="wrap_content">

    <View android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:background="@android:color/white" android:layout_alignLeft="@+id/image"
        android:layout_alignRight="@id/image" android:layout_alignTop="@id/image"
        android:layout_alignBottom="@id/image" android:layout_marginLeft="10dp"
        android:layout_marginBottom="10dp" />

    <ImageView android:id="@id/image" android:layout_width="wrap_content"
        android:layout_height="wrap_content" android:src="..."
        android:padding="5dp" />

</RelativeLayout>

निश्चित रूप से नहीं कि मैं क्या देख रहा हूँ। मैं एक वास्तविक प्रदान की गई ड्रॉप छाया चाहता हूँ जो पारदर्शी हो; वह बस मुझे मेरी छवि के पीछे एक सफेद बॉक्स देगा।
केविन कोपॉक

9
@kcoppock - इस उत्तर को अस्वीकार करने की कोई आवश्यकता नहीं है - यह वास्तव में इतना बुरा नहीं था।
कैस्पर हैमर

4

मैं इस कोड का उपयोग करके ढाल सीमा लागू करने का प्रबंधन करता हूं।

public static Bitmap drawShadow(Bitmap bitmap, int leftRightThk, int bottomThk, int padTop) {
    int w = bitmap.getWidth();
    int h = bitmap.getHeight();

    int newW = w - (leftRightThk * 2);
    int newH = h - (bottomThk + padTop);

    Bitmap.Config conf = Bitmap.Config.ARGB_8888;
    Bitmap bmp = Bitmap.createBitmap(w, h, conf);
    Bitmap sbmp = Bitmap.createScaledBitmap(bitmap, newW, newH, false);

    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    Canvas c = new Canvas(bmp);

    // Left
    int leftMargin = (leftRightThk + 7)/2;
    Shader lshader = new LinearGradient(0, 0, leftMargin, 0, Color.TRANSPARENT, Color.BLACK, TileMode.CLAMP);
    paint.setShader(lshader);
    c.drawRect(0, padTop, leftMargin, newH, paint); 

    // Right
    Shader rshader = new LinearGradient(w - leftMargin, 0, w, 0, Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
    paint.setShader(rshader);
    c.drawRect(newW, padTop, w, newH, paint);

    // Bottom
    Shader bshader = new LinearGradient(0, newH, 0, bitmap.getHeight(), Color.BLACK, Color.TRANSPARENT, TileMode.CLAMP);
    paint.setShader(bshader);
    c.drawRect(leftMargin -3, newH, newW + leftMargin + 3, bitmap.getHeight(), paint);
    c.drawBitmap(sbmp, leftRightThk, 0, null);

    return bmp;
}

उम्मीद है की यह मदद करेगा !


2

यह मेरे लिए काम करता है ...

public class ShadowImage extends Drawable {

Bitmap bm;

@Override
public void draw(Canvas canvas) {

    Paint mShadow = new Paint();
    Rect rect = new Rect(0,0,bm.getWidth(), bm.getHeight());

    mShadow.setAntiAlias(true);
    mShadow.setShadowLayer(5.5f, 4.0f, 4.0f, Color.BLACK);

    canvas.drawRect(rect, mShadow);
    canvas.drawBitmap(bm, 0.0f, 0.0f, null);

}

public ShadowImage(Bitmap bitmap) {
    super();
    this.bm = bitmap;
} ... }

2

यहाँ पॉल बर्क के जवाब का कार्यान्वयन :

public class ShadowImageView extends ImageView {

    public ShadowImageView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public ShadowImageView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public ShadowImageView(Context context) {
        super(context);
    }

    private Paint createShadow() {
        Paint mShadow = new Paint();

        float radius = 10.0f;
        float xOffset = 0.0f;
        float yOffset = 2.0f;

        // color=black
        int color = 0xFF000000;
        mShadow.setShadowLayer(radius, xOffset, yOffset, color);


        return mShadow;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        Paint mShadow = createShadow();
        Drawable d = getDrawable();
        if (d != null){
            setLayerType(LAYER_TYPE_SOFTWARE, mShadow);
            Bitmap bitmap = ((BitmapDrawable) getDrawable()).getBitmap();
            canvas.drawBitmap(bitmap, 0.0f, 0.0f, mShadow);
        } else {
            super.onDraw(canvas);
        }

    };

}

TODO: setLayerType(LAYER_TYPE_SOFTWARE, mShadow);केवल तभी निष्पादित करें जब API स्तर> 10 हो


माफी, अनंत लूप को एक दायरे वर्ग द्वारा बुलाया गया था
रनऑलॉप

जब तक प्रश्न संपादित नहीं किया जाता है, तब तक मैं कैंट नहीं कर सकता। बस कोई भी छोटा सा बदलाव करें, मुझे बताएं और फिर मैं फिर से उत्थान करूंगा।
रनऑलॉप

0

मैंने ऊपर दिए गए उत्तर पर - https://stackoverflow.com/a/11155031/2060486 - का निर्माण किया है।

 private static final int GRAY_COLOR_FOR_SHADE = Color.argb(50, 79, 79, 79);

// this method takes a bitmap and draws around it 4 rectangles with gradient to create a
// shadow effect.
public static Bitmap addShadowToBitmap(Bitmap origBitmap) {
    int shadowThickness = 13; // can be adjusted as needed
    int bmpOriginalWidth = origBitmap.getWidth();
    int bmpOriginalHeight = origBitmap.getHeight();
    int bigW = bmpOriginalWidth + shadowThickness * 2; // getting dimensions for a bigger bitmap with margins
    int bigH = bmpOriginalHeight + shadowThickness * 2;
    Bitmap containerBitmap = Bitmap.createBitmap(bigW, bigH, Bitmap.Config.ARGB_8888);
    Bitmap copyOfOrigBitmap = Bitmap.createScaledBitmap(origBitmap, bmpOriginalWidth, bmpOriginalHeight, false);
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    Canvas canvas = new Canvas(containerBitmap); // drawing the shades on the bigger bitmap
    //right shade - direction of gradient is positive x (width)
    Shader rightShader = new LinearGradient(bmpOriginalWidth, 0, bigW, 0, GRAY_COLOR_FOR_SHADE,
            Color.TRANSPARENT, Shader.TileMode.CLAMP);
    paint.setShader(rightShader);
    canvas.drawRect(bigW - shadowThickness, shadowThickness, bigW, bigH - shadowThickness, paint);
    //bottom shade - direction is positive y (height)
    Shader bottomShader = new LinearGradient(0, bmpOriginalHeight, 0, bigH, GRAY_COLOR_FOR_SHADE,
            Color.TRANSPARENT, Shader.TileMode.CLAMP);
    paint.setShader(bottomShader);
    canvas.drawRect(shadowThickness, bigH - shadowThickness, bigW - shadowThickness, bigH, paint);
    //left shade - direction is negative x
    Shader leftShader = new LinearGradient(shadowThickness, 0, 0, 0, GRAY_COLOR_FOR_SHADE,
            Color.TRANSPARENT, Shader.TileMode.CLAMP);
    paint.setShader(leftShader);
    canvas.drawRect(0, shadowThickness, shadowThickness, bigH - shadowThickness, paint);
    //top shade - direction is negative y
    Shader topShader = new LinearGradient(0, shadowThickness, 0, 0, GRAY_COLOR_FOR_SHADE,
            Color.TRANSPARENT, Shader.TileMode.CLAMP);
    paint.setShader(topShader);
    canvas.drawRect(shadowThickness, 0, bigW - shadowThickness, shadowThickness, paint);
    // starting to draw bitmap not from 0,0 to get margins for shade rectangles
    canvas.drawBitmap(copyOfOrigBitmap, shadowThickness, shadowThickness, null);
    return containerBitmap;
}

जैसा कि आप फिट देखते हैं, रंग में रंग बदलें।


0

बिटमैप पर छाया खींचने के लिए इस वर्ग का उपयोग करें

public class ShadowGenerator {

    // Percent of actual icon size
    private static final float HALF_DISTANCE = 0.5f;
    public static final float BLUR_FACTOR = 0.5f/48;

    // Percent of actual icon size
    private static final float KEY_SHADOW_DISTANCE = 1f/48;
    public static final int KEY_SHADOW_ALPHA = 61;

    public static final int AMBIENT_SHADOW_ALPHA = 30;

    private static final Object LOCK = new Object();
    // Singleton object guarded by {@link #LOCK}
    private static ShadowGenerator sShadowGenerator;

    private  int mIconSize;

    private final Canvas mCanvas;
    private final Paint mBlurPaint;
    private final Paint mDrawPaint;
    private final Context mContext;

    private ShadowGenerator(Context context) {
        mContext = context;
        mIconSize = Utils.convertDpToPixel(context,63);
        mCanvas = new Canvas();
        mBlurPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
        mBlurPaint.setMaskFilter(new BlurMaskFilter(mIconSize * BLUR_FACTOR, Blur.NORMAL));
        mDrawPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
    }

    public synchronized Bitmap recreateIcon(Bitmap icon) {
        mIconSize = Utils.convertDpToPixel(mContext,3)+icon.getWidth();
        int[] offset = new int[2];
        Bitmap shadow = icon.extractAlpha(mBlurPaint, offset);
        Bitmap result = Bitmap.createBitmap(mIconSize, mIconSize, Config.ARGB_8888);
        mCanvas.setBitmap(result);

        // Draw ambient shadow
        mDrawPaint.setAlpha(AMBIENT_SHADOW_ALPHA);
        mCanvas.drawBitmap(shadow, offset[0], offset[1], mDrawPaint);

        // Draw key shadow
        mDrawPaint.setAlpha(KEY_SHADOW_ALPHA);
        mCanvas.drawBitmap(shadow, offset[0], offset[1] + KEY_SHADOW_DISTANCE * mIconSize, mDrawPaint);

        // Draw the icon
        mDrawPaint.setAlpha(255);
        mCanvas.drawBitmap(icon, 0, 0, mDrawPaint);

        mCanvas.setBitmap(null);
        return result;
    }



    public static ShadowGenerator getInstance(Context context) {

        synchronized (LOCK) {
            if (sShadowGenerator == null) {
                sShadowGenerator = new ShadowGenerator(context);
            }
        }
        return sShadowGenerator;
    }

}

-1

यदि आप कस्टम छवि दृश्य का उपयोग करना चाहते हैं, तो मेरा सुझाव है कि आप इसे उपयोग करें

पूर्ण रूप से देखें और किसी भी नौ पथ चित्र का उपयोग न करें

यहां छवि विवरण दर्ज करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.