दिलचस्प पोस्ट
कार्रवाई और कार्रवाई के बीच मतभेद वापसी मूल्य त्रुटि को संशोधित नहीं किया जा सकता # पूर्णांक हैश फ़ंक्शन क्या अच्छा है जो कि पूर्णांक हैश कुंजी स्वीकार करता है? एंड्रॉइड में जेक्सिंग का उपयोग कैसे करें जावा धागा को दूसरे थ्रेड के आउटपुट के लिए कैसे तैयार करना है? सी में एक स्टैक ट्रेस कैसे पकड़ सकता है? "Var" या नहीं "var" जावास्क्रिप्ट के "फॉर-इन" लूप में है? टिमर्टस्क या हैंडलर एसिंक टास्क गतिविधि को नष्ट होने पर भी नहीं रोकेंगे <My code> में त्रुटि: प्रकार का 'क्लोजर' ऑब्जेक्ट सेनेटटेबल नहीं है IPhone पर HTTP कुकीज़ प्रबंधित करना सीएसएस पूर्वता जेटेबल, रोफिल्टर और रोफिल्टर.इंटर्री अजाक्स अनुरोध 200 ओके रिटर्न देता है, लेकिन सफलता के बजाय एक त्रुटि ईवेंट निकाल दिया गया है इनपुट / आउटपुट स्ट्रीम के साथ जावा प्रक्रिया

कैसे ImageView करने के लिए षट्कोण आकार देने के लिए

कैसे ImageView करने के लिए षट्कोण आकार देने के लिए क्या यह उसी तरह करना संभव है? यदि ऐसा है तो कैसे अगर यह संभव नहीं है तो यह कैसे प्राप्त किया जा सकता है?

 <shape xmlns:android="http//schemas.android.com/apk/res/android" android:shape="hexagon"> <solid android:color="#ffffffff" /> <size android:width="60dp" android:height="40dp" /> </shape> 

स्क्रीनशॉट

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

यहां मैं छवि को मास्किंग नहीं कर सकता क्योंकि मुझे पता नहीं लगा कि उस आकार के बिटमैप के लिए मुझे हेक्सागन आकार बिटमैप प्राप्त करने के लिए फसल चाहिए। इसलिए मैं जवाब देने के लिए ImageView को षट्कोण आकार देने के लिए देख रहा हूं

वेब के समाधान से एकत्रित समाधान "कैसे ImageView करने के लिए षट्कोण आकार देने के लिए"

यह दृश्य देखें आप इसे अपनी विशिष्ट ज़रूरतों के लिए समायोजित करना चाहेंगे, लेकिन यह दृश्य के शीर्ष पर एक सीमा के साथ षट्भुज मुखौटा खींचती है। पृष्ठभूमि संसाधन मुखौटा के नीचे आता है।

परिणाम:

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

कोड:

HexagonMaskView.java

 import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Path; import android.graphics.Region; import android.util.AttributeSet; import android.view.View; public class HexagonMaskView extends View { private Path hexagonPath; private Path hexagonBorderPath; private float radius; private float width, height; private int maskColor; public HexagonMaskView(Context context) { super(context); init(); } public HexagonMaskView(Context context, AttributeSet attrs) { super(context, attrs); init(); } public HexagonMaskView(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); init(); } private void init() { hexagonPath = new Path(); hexagonBorderPath = new Path(); maskColor = 0xFF01FF77; } public void setRadius(float r) { this.radius = r; calculatePath(); } public void setMaskColor(int color) { this.maskColor = color; invalidate(); } private void calculatePath() { float triangleHeight = (float) (Math.sqrt(3) * radius / 2); float centerX = width/2; float centerY = height/2; hexagonPath.moveTo(centerX, centerY + radius); hexagonPath.lineTo(centerX - triangleHeight, centerY + radius/2); hexagonPath.lineTo(centerX - triangleHeight, centerY - radius/2); hexagonPath.lineTo(centerX, centerY - radius); hexagonPath.lineTo(centerX + triangleHeight, centerY - radius/2); hexagonPath.lineTo(centerX + triangleHeight, centerY + radius/2); hexagonPath.moveTo(centerX, centerY + radius); float radiusBorder = radius - 5; float triangleBorderHeight = (float) (Math.sqrt(3) * radiusBorder / 2); hexagonBorderPath.moveTo(centerX, centerY + radiusBorder); hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY + radiusBorder/2); hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY - radiusBorder/2); hexagonBorderPath.lineTo(centerX, centerY - radiusBorder); hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY - radiusBorder/2); hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY + radiusBorder/2); hexagonBorderPath.moveTo(centerX, centerY + radiusBorder); invalidate(); } @Override public void onDraw(Canvas c){ super.onDraw(c); c.clipPath(hexagonBorderPath, Region.Op.DIFFERENCE); c.drawColor(Color.WHITE); c.save(); c.clipPath(hexagonPath, Region.Op.DIFFERENCE); c.drawColor(maskColor); c.save(); } // getting the view size and default radius @Override public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){ super.onMeasure(widthMeasureSpec, heightMeasureSpec); width = MeasureSpec.getSize(widthMeasureSpec); height = MeasureSpec.getSize(heightMeasureSpec); radius = height / 2 - 10; calculatePath(); } } 

अद्यतन 29.07.2016

संपूर्ण दृश्य की पृष्ठभूमि को चित्रित किए बिना केवल स्रोत छवि को क्लिप करने का एक बेहतर तरीका स्केलटाइप से फायदा होने के लिए एक मूल वर्ग के रूप में एक छवि दृश्य पर स्विच किया गया। मैंने कुछ कोड रिफैक्टरिंग भी किया।

 import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Path; import android.graphics.PorterDuff; import android.graphics.Region; import android.util.AttributeSet; import android.widget.ImageView; public class HexagonMaskView extends ImageView { private Path hexagonPath; private Path hexagonBorderPath; private Paint mBorderPaint; public HexagonMaskView(Context context) { super(context); init(); } public HexagonMaskView(Context context, AttributeSet attrs) { super(context, attrs); init(); } public HexagonMaskView(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); init(); } private void init() { this.hexagonPath = new Path(); this.hexagonBorderPath = new Path(); this.mBorderPaint = new Paint(); this.mBorderPaint.setColor(Color.WHITE); this.mBorderPaint.setStrokeCap(Paint.Cap.ROUND); this.mBorderPaint.setStrokeWidth(50f); this.mBorderPaint.setStyle(Paint.Style.STROKE); } public void setRadius(float radius) { calculatePath(radius); } public void setBorderColor(int color) { this.mBorderPaint.setColor(color); invalidate(); } private void calculatePath(float radius) { float halfRadius = radius / 2f; float triangleHeight = (float) (Math.sqrt(3.0) * halfRadius); float centerX = getMeasuredWidth() / 2f; float centerY = getMeasuredHeight() / 2f; this.hexagonPath.reset(); this.hexagonPath.moveTo(centerX, centerY + radius); this.hexagonPath.lineTo(centerX - triangleHeight, centerY + halfRadius); this.hexagonPath.lineTo(centerX - triangleHeight, centerY - halfRadius); this.hexagonPath.lineTo(centerX, centerY - radius); this.hexagonPath.lineTo(centerX + triangleHeight, centerY - halfRadius); this.hexagonPath.lineTo(centerX + triangleHeight, centerY + halfRadius); this.hexagonPath.close(); float radiusBorder = radius - 5f; float halfRadiusBorder = radiusBorder / 2f; float triangleBorderHeight = (float) (Math.sqrt(3.0) * halfRadiusBorder); this.hexagonBorderPath.reset(); this.hexagonBorderPath.moveTo(centerX, centerY + radiusBorder); this.hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY + halfRadiusBorder); this.hexagonBorderPath.lineTo(centerX - triangleBorderHeight, centerY - halfRadiusBorder); this.hexagonBorderPath.lineTo(centerX, centerY - radiusBorder); this.hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY - halfRadiusBorder); this.hexagonBorderPath.lineTo(centerX + triangleBorderHeight, centerY + halfRadiusBorder); this.hexagonBorderPath.close(); invalidate(); } @Override public void onDraw(Canvas c) { c.drawPath(hexagonBorderPath, mBorderPaint); c.clipPath(hexagonPath, Region.Op.INTERSECT); c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR); super.onDraw(c); } @Override public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){ super.onMeasure(widthMeasureSpec, heightMeasureSpec); int width = MeasureSpec.getSize(widthMeasureSpec); int height = MeasureSpec.getSize(heightMeasureSpec); setMeasuredDimension(width, height); calculatePath(Math.min(width / 2f, height / 2f) - 10f); } } 

उदाहरण लेआउट:

 <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen/activity_vertical_margin" android:paddingLeft="@dimen/activity_horizontal_margin" android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" android:background="@android:color/holo_green_dark"> <com.scelus.hexagonmaskimproved.HexagonMaskView android:id="@+id/image" android:layout_width="match_parent" android:layout_height="match_parent" android:src="@drawable/bear" android:background="@android:color/holo_green_light"/> </RelativeLayout> 

नया परिणाम

इसके लिए मेरा काम कोड है, इसमें छाया का समर्थन करता है:

 import android.annotation.SuppressLint; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapShader; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.graphics.Path; import android.graphics.PorterDuff; import android.graphics.Shader; import android.graphics.drawable.BitmapDrawable; import android.util.AttributeSet; import android.widget.ImageView; public class HexagonImageView extends ImageView { private Path hexagonPath; private Path hexagonBorderPath; private float radius; private Bitmap image; private int viewWidth; private int viewHeight; private Paint paint; private BitmapShader shader; private Paint paintBorder; private int borderWidth = 4; public HexagonImageView(Context context) { super(context); setup(); } public HexagonImageView(Context context, AttributeSet attrs) { super(context, attrs); setup(); } public HexagonImageView(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); setup(); } private void setup() { paint = new Paint(); paint.setAntiAlias(true); paintBorder = new Paint(); setBorderColor(Color.WHITE); paintBorder.setAntiAlias(true); this.setLayerType(LAYER_TYPE_SOFTWARE, paintBorder); paintBorder.setShadowLayer(4.0f, 1.0f, 1.0f, Color.BLACK); hexagonPath = new Path(); hexagonBorderPath = new Path(); } public void setRadius(float r) { this.radius = r; calculatePath(); } public void setBorderWidth(int borderWidth) { this.borderWidth = borderWidth; this.invalidate(); } public void setBorderColor(int borderColor) { if (paintBorder != null) paintBorder.setColor(borderColor); this.invalidate(); } private void calculatePath() { float triangleHeight = (float) (Math.sqrt(3) * radius / 2); float centerX = viewWidth/2; float centerY = viewHeight/2; hexagonBorderPath.moveTo(centerX, centerY + radius); hexagonBorderPath.lineTo(centerX - triangleHeight, centerY + radius/2); hexagonBorderPath.lineTo(centerX - triangleHeight, centerY - radius/2); hexagonBorderPath.lineTo(centerX, centerY - radius); hexagonBorderPath.lineTo(centerX + triangleHeight, centerY - radius/2); hexagonBorderPath.lineTo(centerX + triangleHeight, centerY + radius/2); hexagonBorderPath.moveTo(centerX, centerY + radius); float radiusBorder = radius - borderWidth; float triangleBorderHeight = (float) (Math.sqrt(3) * radiusBorder / 2); hexagonPath.moveTo(centerX, centerY + radiusBorder); hexagonPath.lineTo(centerX - triangleBorderHeight, centerY + radiusBorder/2); hexagonPath.lineTo(centerX - triangleBorderHeight, centerY - radiusBorder/2); hexagonPath.lineTo(centerX, centerY - radiusBorder); hexagonPath.lineTo(centerX + triangleBorderHeight, centerY - radiusBorder/2); hexagonPath.lineTo(centerX + triangleBorderHeight, centerY + radiusBorder/2); hexagonPath.moveTo(centerX, centerY + radiusBorder); invalidate(); } private void loadBitmap() { BitmapDrawable bitmapDrawable = (BitmapDrawable) this.getDrawable(); if (bitmapDrawable != null) image = bitmapDrawable.getBitmap(); } @SuppressLint("DrawAllocation") @Override public void onDraw(Canvas canvas){ super.onDraw(canvas); loadBitmap(); // init shader if (image != null) { canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR); shader = new BitmapShader(Bitmap.createScaledBitmap(image, canvas.getWidth(), canvas.getHeight(), false), Shader.TileMode.CLAMP, Shader.TileMode.CLAMP); paint.setShader(shader); canvas.drawPath(hexagonBorderPath, paintBorder); canvas.drawPath(hexagonPath, paint); } } @Override public void onMeasure(int widthMeasureSpec, int heightMeasureSpec){ super.onMeasure(widthMeasureSpec, heightMeasureSpec); int width = measureWidth(widthMeasureSpec); int height = measureHeight(heightMeasureSpec, widthMeasureSpec); viewWidth = width - (borderWidth * 2); viewHeight = height - (borderWidth * 2); radius = height / 2 - borderWidth; calculatePath(); setMeasuredDimension(width, height); } private int measureWidth(int measureSpec) { int result = 0; int specMode = MeasureSpec.getMode(measureSpec); int specSize = MeasureSpec.getSize(measureSpec); if (specMode == MeasureSpec.EXACTLY) { result = specSize; } else { result = viewWidth; } return result; } private int measureHeight(int measureSpecHeight, int measureSpecWidth) { int result = 0; int specMode = MeasureSpec.getMode(measureSpecHeight); int specSize = MeasureSpec.getSize(measureSpecHeight); if (specMode == MeasureSpec.EXACTLY) { result = specSize; } else { result = viewHeight; } return (result + 2); } } 

कुछ चीजें हैं जो आप कोशिश कर सकते हैं:

  • आप अपनी छवि के शीर्ष पर 9 पैच को खींचने का प्रयास कर सकते हैं

  • रोमैन गाइ ने भी इस छोटी टाटू की है: http://www.curious-creature.org/2012/12/11/android-recipe-1-image-with-rounded-corners/

     BitmapShader shader; shader = new BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP); Paint paint = new Paint(); paint.setAntiAlias(true); paint.setShader(shader); RectF rect = new RectF(0.0f, 0.0f, width, height); // rect contains the bounds of the shape // radius is the radius in pixels of the rounded corners // paint contains the shader that will texture the shape canvas.drawRoundRect(rect, radius, radius, paint); 

    कैनवास के drawRoundRect() विधि का उपयोग करने के बजाय, आप इच्छित आकार प्राप्त करने के लिए drawPath() का उपयोग करने का प्रयास कर सकते हैं।

    आशा है कि यह आपको सही दिशा में डालता है

यह उदाहरण देखें जो त्रिभुज बना रहा है ताकि आप इसे से तर्क प्राप्त कर सकें 🙂

http://looksok.wordpress.com/2013/08/24/android-triangle-arrow-defined-as-an-xml-shape/

मैंने एक और समाधान पाया, लेकिन जांच नहीं की, इसलिए इसे भी प्रयास करें

 @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); TextView tv = (TextView) findViewById(R.id.text); Path path = new Path(); float stdW = 100; float stdH = 100; float w3 = stdW / 3; float h2 = stdH / 2; path.moveTo(0, h2); h2 -= 6 / 2; path.rLineTo(w3, -h2); path.rLineTo(w3, 0); path.rLineTo(w3, h2); path.rLineTo(-w3, h2); path.rLineTo(-w3, 0); path.rLineTo(-w3, -h2); Shape s = new PathShape(path, stdW, stdH); ShapeDrawable d = new ShapeDrawable(s); Paint p = d.getPaint(); p.setColor(0xffeeeeee); p.setStyle(Style.STROKE); p.setStrokeWidth(6); tv.setBackgroundDrawable(d); } 

स्रोत: Google समूह

तीसरा समाधान – यह उपयोगी लाइब्रेरी हो सकता है

PathDrawable एक Drawable है जो पथ ऑब्जेक्ट का उपयोग करके सरल आकार खींचता है।

इसके लायक से भयावह .. लेकिन आशा है कि यह किसी को मदद करेगा …

  public Bitmap getHexagonShape(Bitmap scaleBitmapImage) { // TODO Auto-generated method stub int targetWidth = 200; int targetHeight =200; Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, targetHeight,Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(targetBitmap); Path path = new Path(); float stdW = 200; float stdH = 200; float w3 =stdW / 2; float h2 = stdH / 2; float radius=stdH/2-10; float triangleHeight = (float) (Math.sqrt(3) * radius / 2); float centerX = stdW/2; float centerY = stdH/2; path.moveTo(centerX, centerY + radius); path.lineTo(centerX - triangleHeight, centerY + radius/2); path.lineTo(centerX - triangleHeight, centerY - radius/2); path.lineTo(centerX, centerY - radius); path.lineTo(centerX + triangleHeight, centerY - radius/2); path.lineTo(centerX + triangleHeight, centerY + radius/2); path.moveTo(centerX, centerY + radius); canvas.clipPath(path); Bitmap sourceBitmap = scaleBitmapImage; canvas.drawBitmap(sourceBitmap, new Rect(0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight()), new Rect(0, 0, targetWidth, targetHeight), null); return targetBitmap; } public static Bitmap drawableToBitmap (Drawable drawable) { if (drawable instanceof BitmapDrawable) { return ((BitmapDrawable)drawable).getBitmap(); } Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Config.ARGB_8888); Canvas canvas = new Canvas(bitmap); drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight()); drawable.draw(canvas); return bitmap; } 

इसे कॉल करें जहां आप उपयोग करना चाहते हैं

  Drawable drawable = getResources().getDrawable( R.drawable.placeholder ); Bitmap b=getHexagonShape(drawableToBitmap(drawable)); img=(ImageView)findViewById(R.id.imageView); img.setImageBitmap(b); 

नीचे दिए गए फ़ंक्शन आपकी छवि को इनपुट बिटमैप के रूप में पढ़ता है और बिटमैप देता है जो आकार में हेक्सागोन है

 public Bitmap getHexagonShape(Bitmap scaleBitmapImage) { // TODO Auto-generated method stub int targetWidth = 600; int targetHeight = 600; Bitmap targetBitmap = Bitmap.createBitmap(targetWidth, targetHeight,Bitmap.Config.ARGB_8888); Canvas canvas = new Canvas(targetBitmap); Path path = new Path(); float stdW = 300; float stdH = 300; float w3 =stdW / 2; float h2 = stdH / 2; path.moveTo(0, (float) (h2*Math.sqrt(3)/2)); path.rLineTo(w3/2, -(float) (h2*Math.sqrt(3)/2)); path.rLineTo(w3, 0); path.rLineTo(w3/2, (float) (h2*Math.sqrt(3)/2)); path.rLineTo(-w3/2, (float) (h2*Math.sqrt(3)/2)); path.rLineTo(-w3, 0); path.rLineTo(-w3/2, -(float) (h2*Math.sqrt(3)/2)); canvas.clipPath(path); Bitmap sourceBitmap = scaleBitmapImage; canvas.drawBitmap(sourceBitmap, new Rect(0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight()), new Rect(0, 0, targetWidth, targetHeight), null); return targetBitmap; } 

मुझे नहीं पता कि ओपी को वह जवाब मिल गया है, लेकिन वह यहाँ जाता है।

मैंने एक कस्टम व्यू बनाया है, जो कि ImageView तक फैली हुई है, जो आपके लिए थोड़ी बेहतर काम करेगा यहां उत्तर यहां इमेज्यूव्यू के अंदर एक मेक बनाता है और पृष्ठभूमि को चित्र के रूप में सेट करने के लिए मजबूर करता है

मेरा दृश्य आपको छवि को मानक बिटमैप की तरह सेट करने देता है, यह केंद्र के केंद्र और छवि के स्केलिंग को संभालता है। यह वास्तव में इसके बजाय मुखौटा सेट करता है, और उसी सीमा से अधिक ड्रॉप छाया के साथ।

और अगर यह पर्याप्त नहीं है, तो आप आसानी से रेंडरशैप-क्लास को विस्तारित करने के लिए कस्टम आकृति बना सकते हैं। (4 आकार पुस्तकालय में शामिल हैं: सर्कल, त्रिकोण, षट्भुज और अष्टकोना)

मेरे गिथूब को देखो

चियर्स

मैंने इसे इस कोड का उपयोग कर हल किया है:

  private Bitmap getHexagoneCroppedBitmap(Bitmap bitmap, int radius) { Bitmap finalBitmap; if (bitmap.getWidth() != radius || bitmap.getHeight() != radius) finalBitmap = Bitmap.createScaledBitmap(bitmap, radius, radius, false); else finalBitmap = bitmap; Bitmap output = Bitmap.createBitmap(finalBitmap.getWidth(), finalBitmap.getHeight(), Config.ARGB_8888); Canvas canvas = new Canvas(output); Paint paint = new Paint(); final Rect rect = new Rect(0, 0, finalBitmap.getWidth(), finalBitmap.getHeight()); Point point1_draw = new Point(75, 0); Point point2_draw = new Point(0, 50); Point point3_draw = new Point(0, 100); Point point4_draw = new Point(75, 150); Point point5_draw = new Point(150, 100); Point point6_draw = new Point(150, 50); Path path = new Path(); path.moveTo(point1_draw.x, point1_draw.y); path.lineTo(point2_draw.x, point2_draw.y); path.lineTo(point3_draw.x, point3_draw.y); path.lineTo(point4_draw.x, point4_draw.y); path.lineTo(point5_draw.x, point5_draw.y); path.lineTo(point6_draw.x, point6_draw.y); path.close(); canvas.drawARGB(0, 0, 0, 0); paint.setColor(Color.parseColor("#BAB399")); canvas.drawPath(path, paint); paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); canvas.drawBitmap(finalBitmap, rect, rect, paint); return output; } 

आप एंड्रॉइड आकार इमेज विज़ का उपयोग सियामड में कर सकते हैं।

https://github.com/siyamed/android-shape-imageview

 <com.github.siyamed.shapeimageview.HexagonImageView android:layout_width="match_parent" android:layout_height="match_parent" android:layout_margin="8dp" android:src="@drawable/neo" app:siBorderWidth="8dp" app:siBorderColor="@color/darkgray"/> 

कृपया गिटूब पर प्रलेखन पढ़ें, बहुत सारे विकल्प उपलब्ध हैं।