मास्क का उपयोग किए बिना जिग्स पहेली टुकड़े कैसे बनाएं?

Question

मैं एक जिग्स पहेली गेम बनाने की कोशिश कर रहा हूं, और मैं मास्क का उपयोग किए बिना पहेली टुकड़े बनाने के वैकल्पिक तरीकों के बारे में जानना चाहता हूं। वर्तमान में मेरे पास एक पूर्ण छवि लेकर जिग्स टुकड़े हैं, उस छवि को चार टुकड़ों में तोड़ना (मान लें कि पहेली 2x2 है) और उसके बाद प्रत्येक टुकड़े को एक मुखौटा संग्रहित करना और लागू करना। यह नीचे की तरह लग रहा

// create standard puzzle pieces 
    arryPieceEndPos = new int[mCols][mRows]; 
    arryPieceImg = new Bitmap[mCols * mRows]; 
    arryIsPieceLocked = new boolean[mCols * mRows]; 

    int pos = 0; 
    for (int c = 0; c < mCols; c++) { 
     for (int r = 0; r < mRows; r++) { 
      arryPieceImg[pos] = Bitmap.createBitmap(mBitmap, 
      c * mPieceWidth, r * mPieceHeight, 
      mPieceWidth, mPieceHeight); 

      arryIsPieceLocked[pos] = false; 
      arryPieceEndPos[c][r] = pos; 
      pos++; 
     } 
    } 

मैं तो एक सहायक विधि का उपयोग प्रत्येक टुकड़ा

private Bitmap maskMethod(Bitmap bmpOriginal, Bitmap bmpMask) { 

    // adjust mask bitmap if size is not the size of the puzzle piece 
    if (bmpMask.getHeight() != mPieceHeight || 
     bmpMask.getWidth() != mPieceWidth) { 
     Log.e("TEST", "Resize Error :: H (mask): " + bmpMask.getHeight() + " // W (mask): " + 
      bmpMask.getWidth()); 
     Log.d("TEST", "Resize Error :: H (norm): " + mPieceHeight + " // W (norm): " + 
      mPieceWidth); 

    } 

    Canvas canvas = new Canvas(); 
    Bitmap combine = Bitmap.createBitmap(bmpOriginal.getWidth(), bmpOriginal.getHeight(), Bitmap.Config.ARGB_8888); 
    canvas.setBitmap(combine); 
    Paint paint = new Paint(); 
    paint.setFilterBitmap(false); 

    canvas.drawBitmap(bmpOriginal, 0, 0, paint); 
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); 
    canvas.drawBitmap(bmpMask, 0, 0, paint); 
    paint.setXfermode(null); 

    return combine; 
} 

मैं टुकड़ों को एक साथ जोड़ने के लिए इस पोस्ट>http://java.dzone.com/news/connect-pictures-android देखा करने के लिए एक मुखौटा लागू करने के लिए, हालांकि, इस से अधिक नहीं करता है मास्क के बिना प्रोग्रामेटिक रूप से टुकड़े पैदा करना। क्या कोई कोड उदाहरण प्रदान कर सकता है कि यह कैसे पूरा किया जा सकता है? मेरे पास एकमात्र सुराग है कि मुझे पथ का उपयोग करना चाहिए, हालांकि, मुझे अभी भी यकीन नहीं है कि कैसे। अग्रिम में धन्यवाद!

Answer 1

एक पहेली टुकड़ा बनाने के लिए एक जटिल जटिल दृश्य है, लेकिन मैं पथ का उपयोग करने के तरीके को समझने में आपकी सहायता कर सकता हूं। डेवलपर वेबसाइट का लिंक यहां दिया गया है: http://developer.android.com/reference/android/graphics/Path.html

इस लिंक को देखें। मैंने आपके लिए शुरू करने के लिए एक छोटी सी चीज़ बनाई है। एक चीज जिसे आप समझने की जरूरत है वह है कि पथ से बाहर एक छोटा सर्कल कैसे कटौती करें, जिसे मैं नहीं जानता। मुझे लगता है कि आपको अपना रास्ता एक सर्कल का पालन करने के लिए क्लिपिंग में देखना होगा (आप टुकड़े के बाहर सर्कल बनाने के लिए क्लिपिंग भी कर सकते हैं, मैंने अभी पहले क्लिपिंग नहीं की है)।

private Bitmap getPuzzleBitmap(Bitmap bitmap) 
{ 
    Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888); 
    Canvas canvas = new Canvas(output); 

    final int color = 0xff424242; 
    final Paint paint = new Paint(); 
    final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()); 

    calculatePuzzlePath(bitmap.getWidth(), bitmap.getHeight()); 

    paint.setAntiAlias(true); 
    canvas.drawARGB(0, 0, 0, 0); 
    paint.setColor(color); 
    canvas.drawPath(puzzlePath, paint); 

    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); 
    canvas.drawBitmap(bitmap, rect, rect, paint); 

    return output; 
} 

private void calculatePuzzlePath(int width, int height) 
{ 
    float radius = (height/2) - 5; 
    float smallRadius = radius/3; 
    radius -= smallRadius * 2; 
    float centerX = width/2; 
    float centerY = height/2; 
    puzzlePath = new Path(); 
    // Bottom right 
    puzzlePath.moveTo(centerX + radius, centerY + radius); 
    // Top right 
    puzzlePath.lineTo(centerX + radius, centerY - radius); 
    // Center top 
    puzzlePath.lineTo(centerX, centerY - radius); 
    // Add outside circle to center top 
    puzzlePath.addCircle(centerX, centerY - radius - ((radius/3)/2), radius/3, Path.Direction.CCW); 

    // Top left 
    puzzlePath.lineTo(centerX - radius, centerY - radius); 
    // Bottom left 
    puzzlePath.lineTo(centerX - radius, centerY + radius); 
    //Bottom right 
    puzzlePath.lineTo(centerX + radius, centerY + radius); 
} 

मुझे आशा है कि यह इस के साथ आरंभ करने के लिए पर्याप्त है।

गुड लक!