मैं एक आईफोन व्यू में धुंधला पाठ कैसे बना सकता हूं?

Question

मैं विभिन्न पाठ और छवि तत्वों के साथ एक दृश्य बना रहा हूं।

मैं इसके पीछे पाठ की धुंधली प्रतिलिपि के साथ दृश्य में कुछ पाठ प्रदर्शित करना चाहता हूं, लेकिन केवल एक टेक्स्ट छाया नहीं।

मैं यूआईएममेज या परत पर गॉसियन धुंधला पाठ कैसे लागू करूं?

Answer 1

डेस्कटॉप पर, कोई प्रश्न नहीं, आप CoreImage का उपयोग करने के लिए इसका उपयोग करेंगे।

हालांकि फोन पर, मुझे नहीं लगता कि कोरग्राफिक्स का उपयोग करके ऐसा करने का कोई तरीका मौजूद है। यदि यह बिल्कुल महत्वपूर्ण है OpenGLES मदद करने में सक्षम हो सकता है।

हालांकि, मैं आपके इंटरफ़ेस पर पुनर्विचार करने का सुझाव दूंगा। मुझे लगता है कि धुंधला पाठ विचलित हो जाएगा।

संपादित करें: mledford टिप्पणियों में बताता है कि आप CoreAnimation का उपयोग कर सकते हैं। मुझे नहीं पता कि फोन पर सीए में डेस्कटॉप पर ब्लर त्रिज्या शामिल है, लेकिन आप इसे आजमा सकते हैं।

Answer 2

आईफोन ओएस कोई कोर छवि फ़िल्टर प्रदान नहीं करता है जो मुझे पता है - अन्यथा, हाँ, फ़िल्टर किए गए कैलियर इसे करने का सही तरीका होगा। यदि NSBitmapImageRep उपलब्ध था, तो आप टेक्स्ट को चित्रित करके, छवि को कम करने (डाउनसमैप्लिंग) करके एक आदिम धुंध कर सकते हैं, फिर छवि को फिर से बढ़ा सकते हैं (दुर्भाग्य से) - दुर्भाग्यवश ऐसा लगता है कि यह भी गायब है। मैंने फ्लैश में धुंधला पाठ पूरा किया है, जो (पिछली बार जांच की गई) में पिक्सेल-स्तरीय फ़िल्टरिंग नहीं है; आप उस पर एक ट्यूटोरियल ढूंढने की कोशिश कर सकते हैं और देख सकते हैं कि आप कोको टच में क्या अनुकूलित कर सकते हैं।

Answer 3

यदि आप अल्फा परतों का उपयोग करते हैं तो आप एक प्रदर्शन हिट लेंगे। यदि संभव हो तो एक अलग दृष्टिकोण पर विचार करें (शायद टेक्स्ट को प्रीकंपोजिट करना और इसे कई परतों के बजाय ग्राफिक में फ़्लैट करना)।

इसे आज़माएं, और प्रदर्शन की जांच करने के लिए उपकरण का उपयोग करें और देखें कि यह स्वीकार्य है या नहीं। यदि आप इसे स्क्रॉलिंग व्यू में कर रहे हैं, तो आपकी स्क्रॉलिंग लॉट को दबाएगी।

Answer 4

ऐप्पल के GLImageProcessing iPhone नमूना पर एक नज़र डालें। यह कुछ चीजों के अलावा, कुछ धुंधला करता है।

प्रासंगिक कोड में शामिल हैं:

static void blur(V2fT2f *quad, float t) // t = 1 
{ 
    GLint tex; 
    V2fT2f tmpquad[4]; 
    float offw = t/Input.wide; 
    float offh = t/Input.high; 
    int i; 

    glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex); 

    // Three pass small blur, using rotated pattern to sample 17 texels: 
    // 
    // .\/.. 
    // ./\\/ 
    // \/X/\ rotated samples filter across texel corners 
    // /\\/. 
    // ../\. 

    // Pass one: center nearest sample 
    glVertexPointer (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x); 
    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s); 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
    glColor4f(1.0/5, 1.0/5, 1.0/5, 1.0); 
    validateTexEnv(); 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 

    // Pass two: accumulate two rotated linear samples 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    glEnable(GL_BLEND); 
    glBlendFunc(GL_SRC_ALPHA, GL_ONE); 
    for (i = 0; i < 4; i++) 
    { 
     tmpquad[i].x = quad[i].s + 1.5 * offw; 
     tmpquad[i].y = quad[i].t + 0.5 * offh; 
     tmpquad[i].s = quad[i].s - 1.5 * offw; 
     tmpquad[i].t = quad[i].t - 0.5 * offh; 
    } 
    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].x); 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 
    glActiveTexture(GL_TEXTURE1); 
    glEnable(GL_TEXTURE_2D); 
    glClientActiveTexture(GL_TEXTURE1); 
    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].s); 
    glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
    glBindTexture(GL_TEXTURE_2D, tex); 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); 
    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,  GL_INTERPOLATE); 
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,   GL_TEXTURE); 
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,   GL_PREVIOUS); 
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,   GL_PRIMARY_COLOR); 
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,  GL_SRC_COLOR); 
    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE); 
    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,  GL_PRIMARY_COLOR); 

    glColor4f(0.5, 0.5, 0.5, 2.0/5); 
    validateTexEnv(); 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 

    // Pass three: accumulate two rotated linear samples 
    for (i = 0; i < 4; i++) 
    { 
     tmpquad[i].x = quad[i].s - 0.5 * offw; 
     tmpquad[i].y = quad[i].t + 1.5 * offh; 
     tmpquad[i].s = quad[i].s + 0.5 * offw; 
     tmpquad[i].t = quad[i].t - 1.5 * offh; 
    } 
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 

    // Restore state 
    glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
    glClientActiveTexture(GL_TEXTURE0); 
    glBindTexture(GL_TEXTURE_2D, Half.texID); 
    glDisable(GL_TEXTURE_2D); 
    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,  GL_SRC_ALPHA); 
    glActiveTexture(GL_TEXTURE0); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    glDisable(GL_BLEND); 
}