पायगम पानी की लहर प्रभाव

Question

मैंने इसके लिए गुगल किया है लेकिन फ्लैश पर एक ही प्रभाव के विपरीत कोई तैयार स्क्रिप्ट नहीं है। मैंने The Water Effect Explained पर एल्गोरिदम की जांच की है और Perlin Noise के कार्यान्वयन का भी परीक्षण किया है, जो एक सपाट सतह पर तरंगों के अंत का एक अच्छा सिमुलेशन प्रदान करता है। मैं माउसओवर/होवर कार्यों के आधार पर कई फ़्लैश प्रभावों पर पाया गया एक ही कार्यान्वयन की तलाश में हूं। यह एक इंटरैक्टिव फ्लोर लाइब्रेरी को लक्षित कर रहा है, और मैं इस मामले के लिए फ्लैश से दूर जाने का आनंद लेता हूं, विशेष रूप से कोड की ऐसी आसान रिवर्स-इंजीनियरिंग से बचने के लिए - और हाँ, मुझे पता है कि यह केवल कुछ तैयार किए गए फ़्लैश कोड का उपयोग कर सकता है, लेकिन मैं केवल अंतिम उपाय के रूप में इसका उपयोग करेगा।

क्या किसी ने Pygame (OpenGL का उपयोग करके या नहीं) के लिए इस प्रभाव का उपयुक्त कार्यान्वयन देखा है?

संपादित करें:क्या कोई भी OpenCV/OpenGL और Pygame का उपयोग करके इस प्रभाव का उपयुक्त कार्यान्वयन प्रदान कर सकता है?

अपराधी यहां पाइथन के माध्यम से बाह्य दुभाषिया (ट्रैकर - टीयूआईओ नहीं) से भेजे गए मानों की एक सूची पास करने के लिए (कोड) इंटरफ़ेस है। मैंने कुछ सीधी दिनों के लिए कोशिश की है लेकिन पायगम कुछ भी सी/सी ++ कोड (ओपनजीएल में शेडर्स के लिए उपयोग किए जाने के रूप में) के रूप में तेज़ी से उत्पन्न करने में सक्षम नहीं है, और सी/सी ++ का मेरा ज्ञान शून्य है। तो लक्ष्य कम से कम पाइथन कोड से आ रहा है।

फ्लैश प्रभाव से अलग एक अच्छा उदाहरण है, लेकिन यह अभी भी अच्छा है Water Simulation using Java applet।

(बक्षीस जवाब दिखा रहा है कि पर्याप्त विवरण नहीं है क्योंकि यह ओपी को सबसे अच्छा था क्योंकि वह उस कोड को बनाने में असमर्थ है क्योंकि वह मूलभूत कौशल की कमी करता है और यह उत्तर शायद कई लोगों के लिए उपयोग किया जाएगा) ।

Answer 1

घ के बाद: यहाँ एक नमूना उपयोग है ओंग होमवर्क (ए.के.ए.शोध) और पाइथन में प्रश्न पर पोस्ट किए गए जावा कोड संदर्भ को सीधे रूपांतरित करने की कोशिश कर रहा है, और पाइथन/न्यूम्पी को रिपल के रिपिप्लिंग के लिए अपनी स्थिति के आधार पर पिक्सेल रंगों की एक विशाल सरणी अद्यतन करने का प्रयास करते समय बहुत ही दुखद अनुभव है प्रभाव (माफ करना, मेरी पहली भाषा अंग्रेजी नहीं है), इस प्रकार प्रभाव गणना के प्रत्येक पास के लिए कई (एक्स, वाई) पदों को पार्स कर रहा है और स्क्रीन पर प्रदर्शित सतह पर (सर्फरेय ensues) पर प्रकाश डाल रहा है, मैं आ गया हूँ निष्कर्ष - जिसे अन्य टिप्पणीकारों द्वारा समर्थित किया गया है - कि Pygame बस वास्तव में पिक्सल की पूरी सरणी को पार करने के लिए पर्याप्त शक्तिशाली नहीं होगा और 24 एफपीएस की न्यूनतम दर पर स्क्रीन पर प्रत्येक पिक्सेल पर गणना के परिणाम लागू करें (एक के लिए कम से कम औसत अनुभव)।

Last Light Productions और पूर्व Project Geometrian, इयान मैलेट के पीछे बहुत डेवलपर का हवाला देते हुए:

pygame पिक्सेल धकेलने के लिए बहुत अच्छा नहीं है। जीपीयू के अलावा कुछ भी नहीं है।

खोज तो निकला Alkahest के लिए एक खोज होने के लिए - कुछ है जो कभी बाहर बारी होगी सही मायने में पाया जा - और छवियों rippling का एक ही विचार पर आधारित है, लेकिन में पारदर्शिता का उपयोग करके इस समय माध्यम से देखते हैं पायगम सतहों की कई परतें, मैंने गामेदेव पर Pygame circular cropping/masks प्रश्न पोस्ट किया। chosen answer वास्तव में इस तथ्य की पुष्टि करता है कि मुझे पहले से ही डर था कि पगैम नौकरी के लिए पर्याप्त माचो कभी नहीं होगा।

एक दिन बाद मैं विकास पर अपने पिछले विचारों पर वापस गया और Ogre3D पर आया। यह पता चला है कि (1) ओग्रे 3 डी और नमूने खुले स्रोत हैं और (2) उदाहरणों में से एक एक 3-डी पानी का मॉडल है जो एक चलती वस्तु के साथ बातचीत करता है, वैसे ही मैंने 2-डी में हासिल करने की कोशिश की, लेकिन एक और अधिक पेशेवर तरीके से।

के बाद से C/C++ में मेरी जानकारी नहीं के बराबर है, मैं how to customize the Ogre3D water demo के बारे में जहां की तलाश शुरू करने के लिए, और जवाब में से एक है, जहां एक SDK प्रदान की जाती है Touchscape से सॉफ्टवेयर (this answer देखें) करने के लिए मुझे बताया की एक झलक के लिए पूछने का फैसला किया।

ओग्रे 3 डी काफी ज्यादा लपेट गया। जल तरंग प्रभाव, ओपन (यह हार्डवेयर के आधार पर optionally उपयोग हो सकता है), Python-Ogre के माध्यम से खेल इंजन और अजगर रैपर - तो अपने ही सवाल का मेरा उत्तर,

किसी को भी इस आशय OpenCV का उपयोग करने का एक उपयुक्त कार्यान्वयन प्रदान कर सकते हैं/ओपनजीएल और पायगम?

मूल रूप से

है हां। एसडीके के साथ प्रदान किए गए ओग्रे 3 डी के पानी डेमो की जांच करें - और इसे Python-Ogre के माध्यम से पायथन में प्लग करें।

Answer 2

निम्नलिखित का उपयोग करते हुए numpy का उपयोग शुरू हो सकता है। यह तेज़ होना चाहिए क्योंकि यह पाइथन में भी तेज हो सकता है (यह देखने के लिए यहां देखें कि http://www.scipy.org/PerformancePython कैसे)। आप लहर समारोह में इस्तेमाल किया समीकरणों को संशोधित करने के लिए होता है कि (यदि आप आंकड़ा करने के लिए -

1. आप लहर की गति को नियंत्रित नहीं कर सकते हैं:

   वैसे वहाँ विधि वर्णित में कई कमियां हैं यह कैसे तरंग समीकरण http://en.wikipedia.org/wiki/Wave_equation से संबंधित है तो आप कर चुके हैं)

2. "पूल" की "गहराई" तय की गई है (और शायद बहुत उथला)। मैं प्रभाव
3. लेख पढ़ता पूर्णांक पिक्सेल ऑफसेट आवर्धित करने के लिए गहराई पैरामीटर जोड़ा - आप अंतर्वेशित मूल्यों के साथ एक बहुत अच्छे परिणाम मिलेगा (मैं लगता है कि आप कि ओपन के साथ है, लेकिन उस क्षेत्र में अपने ज्ञान नहीं के बराबर है कर सकते हैं)

कोड:

import numpy 

def ripple(w1, w2, damp, n = 1): 
    for _ in xrange(n): 
     w2 *= -2 
     w2[1:-1,1:-1] += w1[0:-2, 1: -1] 
     w2[1:-1,1:-1] += w1[2: , 1: -1] 
     w2[1:-1,1:-1] += w1[1:-1, 0: -2] 
     w2[1:-1,1:-1] += w1[1:-1, 2: ] 
     w2 *= .5 * (1. - 1./damp) 
     w1, w2 = w2, w1 

def refract(x, y, w, rindex, depth = 10): 
    sx = x[0,1] - x[0,0] 
    sy = y[1,0] - y[0,0] 

    dw_dx = (w[2: ,1:-1] - w[:-2,1:-1])/sx * .5 
    dw_dy = (w[1:-1,2: ] - w[1:-1,:-2])/sy * .5 

    xang = numpy.arctan(dw_dx) 
    xrefract = numpy.arcsin(sin(xang)/rindex) 
    dx = numpy.tan(xrefract) * dw_dx * depth 

    yang = numpy.arctan(dw_dy) 
    yrefract = numpy.arcsin(sin(yang)/rindex) 
    dy = numpy.tan(yrefract) * dw_dy * depth 

    dx *= numpy.sign(dw_dx) 
    dy *= numpy.sign(dw_dy) 

    xmin = x[0,0] 
    xmax = x[0,-1] 
    x[1:-1,1:-1] += dx 
    x[:,:] = numpy.where(x < xmin, xmin, x) 
    x[:,:] = numpy.where(x > xmax, xmax, x) 

    ymin = y[0,0] 
    ymax = y[-1,0] 
    y[1:-1,1:-1] += dy 
    y[:,:] = numpy.where(y < ymin, ymin, y) 
    y[:,:] = numpy.where(y > ymax, ymax, y) 

x और y एक numpy.meshgrid कॉल से ग्रिड होना चाहिए:

x,y = meshgrid(x,y) 
    w = 10 * exp(- (x*x + y*y)) 
    w1 = w.copy() 
    x1,y1 = meshgrid(r_[0:len(x):1.0], r_[0:len(y):1.0]) 
    ripple(w, w1, 16) # w1 will be modified 
    refract(x1, y1, w1, rindex=2, depth=10) # x1 and y1 will be modified 
    numpy.around(x1, out=x1) # but you will get better results with interpolate 
    numpy.around(y1, out=y1) #