आइसोसर्फ़स रेंडरिंग रिक्स्टिंग अल्गोरिथम का उपयोग करना

इस लेख में मैं आपको Isosurface रेंडरिंग या isosurface रेंडरिंग के बारे में बताना चाहता हूं।

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

तो, Isosurface क्या है - यह, जैसा कि विकिपीडिया हमें बताता है, समोच्च रेखा का एक 3-आयामी संस्करण है, जो बदले में "एक पंक्ति है जिस बिंदु पर मापा मूल्य समान मूल्य को बनाए रखता है"। शब्दों में, यह पूरी तरह से स्पष्ट नहीं हो सकता है - आइए तस्वीरों को बेहतर तरीके से देखें।



ये चित्र "मापी गई मात्रा" - घनत्व के विभिन्न मूल्यों के साथ सतहों को दिखाते हैं। पहला मान दूसरे से कम है।

एक संक्षिप्त सिद्धांत के साथ शुरू करने के लिए।

मैं चिकित्सा छवियों के प्रसंस्करण में शामिल हूं। चिकित्सा उपकरणों से प्राप्त आंकड़ों में मुख्य रूप से तथाकथित कच्ची या ग्रेस्केल छवि होती है - 8 बिट्स (256 शेड्स) से 16 बिट्स (65,536 शेड्स ऑफ ग्रे)। चूंकि वास्तव में 16 बिट्स बहुत है, संक्षिप्त संस्करण अक्सर उपयोग किया जाता है - 12 बिट्स, अर्थात, उच्च बाइट से एक भाग का उपयोग किया जाता है, यह हमें 4096 ग्रे रंग देता है।
इसके अलावा, एक ग्रे छवि को एक रंग में बदलने के लिए, आप तथाकथित LUT - टेबल का उपयोग कर सकते हैं। यह तालिका पंक्तियों का एक संग्रह है, जिनमें से प्रत्येक में RGBA मान होता है। 12 बिट्स के लिए, इस तालिका में 4096 पंक्तियाँ हैं। और जब हम किसी वैक्सील के मान के साथ मिलते हैं, उदाहरण के लिए, 542, तो हम क्रमशः इस तालिका की 542 पंक्तियों से लेते हैं जो आरजीबीए के संकेत हैं।
ये टेबल योग्य चिकित्सकों / इंजीनियरों द्वारा संकलित किए गए हैं जो जानते हैं कि RGBA के साथ घनत्व मूल्य को कैसे सहसंबंधित करना है। अल्फा चैनल का उपयोग करना, अर्थात, पारदर्शिता, आपको तालिकाओं को बनाने की अनुमति देता है, जिसके उपयोग से हम केवल हड्डियों, या केवल नसों, या धमनियों को प्रदर्शित करने की अनुमति देंगे - बाकी पारदर्शी होगा। अर्थात्, LUT को मक्खी पर बदलते हुए, हर बार हमें उसी वस्तु का एक नया प्रदर्शन मिलता है।

छवि डेटा रेंडर करने का मुख्य तरीका वॉल्यूम रे कास्टिंग (रूसी के समान कुछ - वॉल्यूम रेंडरिंग ) है। मैं यहाँ बहुत विस्तार से इसका वर्णन नहीं करूँगा। लेकिन उनके काम को समझना हमारे लिए इसोसेर्फस के प्रतिपादन की प्रक्रिया को समझना महत्वपूर्ण है।

रे कास्टिंग एल्गोरिथ्म यह है कि हम अपनी वस्तु को किरणों से भेदते हैं। एक किरण हमारी आंख (कैमरा) से आती है, स्क्रीन के हर बिंदु (हर पिक्सेल) से गुजरती है, और एक निश्चित स्वर में हमारी वस्तु के साथ जुड़ जाती है (यदि कोई चौराहा है)। बीम इस पर नहीं रुकता है, लेकिन आगे बढ़ता है, आगे के स्वरों को पार करता है और एक निश्चित तरीके से प्रत्येक बिंदु से जानकारी जमा करता है। बीम को रोकने के लिए कई मानदंड हो सकते हैं, सबसे आम है जब संचित मूल्य के अल्फा 1 के करीब है (व्यवहार में, a> 0.95 का उपयोग किया जाता है), या, उदाहरण के लिए, यदि हम छवि की सीमाओं से परे जाते हैं। यही है, संक्षेप में, अनुरेखण के दौरान, हम पारदर्शी स्वरों को त्याग देते हैं और एक निश्चित तरीके से पारभासी मूल्यों को जमा करते हैं, जब तक कि हम एक ठोस वस्तु तक नहीं पहुंचते हैं, जो कि हमारी किरण इसकी अस्पष्टता के कारण नहीं गुजरती है। परिणामी मूल्य का उपयोग स्क्रीन पर प्रस्तुत करने के लिए किया जाता है।

मुख्य विषय पर लौटते हुए, मैं यह कहना चाहता हूं कि आइसोसर्फ्स का प्रतिपादन मुख्यतः ब्रेकपॉइंट में भिन्न होता है। हमारे मामले में, जैसे ही हमें एक वैक्सल मिलता है जिसमें एक मूल्य होता है जो शुरू में निर्धारित घनत्व मूल्य से अधिक या उसके बराबर होता है, हम किरण को चालू किरण के लिए रोकते हैं और अगले पर जाते हैं। चूँकि सभी बिंदुओं पर मान समान होने चाहिए, सभी आइसोसर्फेस आमतौर पर समान रूप से रंगीन होते हैं। एक मूल्य - क्रमशः एक रंग।

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

2. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
3. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
4. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
5. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
7. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
9. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
10. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
11. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
12. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
13. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
15. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
16. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
17. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
18. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
19. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
21. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
22. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
23. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
24. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
25. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
26. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
27. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
29. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
30. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
31. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
32. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
33. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
35. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
36. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
37. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
39. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
40. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
41. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
43. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
44. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
45. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
47. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
48. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
49. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }
50. uniform sampler3D volume ; uniform float sampleRate ; uniform float isoValue ; uniform vec4 isoColor ; varying vec4 texCoord0 ; void main ( ) { floast steps = 1.0 / sampleRate ; vec4 outputColor = vec4 ( 0 ., 0 ., 0 ., 0 . ) ; float isoThr ; // get ray position and ray direction vec4 vPosition = gl_ModelViewMatrixInverse [ 3 ] ; vec3 rayPosition = texCoord0 . xyz ; vec3 vecDif = rayPosition - vPosition . xyz ; vec3 rayDirection = sampleRate * normalize ( vecDif ) ; // for all samples along the ray while ( steps ) { steps --; // get trilinear interpolated value from 3d texture float value = texture3D ( volume , rayPosition ) ; isoThr = value - isoValue ; // check if we get isosurface line if ( isoThr < 0 ) { // march to the next sample rayPosition = rayPosition + rayDirection ; // get next density continue ; } // else we do color transformation outputColor = isoColor ; outputColor . rgb = outputColor . rgb * outputColor . a ; #ifdef SHADER // do shading #endif break ; } gl_FragColor . rgba = outputColor ; }

______________________

पाठ को Blog Editor में © SoftCoder.ru द्वारा तैयार किया गया है

किरण कास्टिंग का एक मुख्य पैरामीटर ट्रेस स्टेप है - बीम किस गति से हमारी वस्तु से गुजरती है। यदि हम आयाम X * Y * Z का घन प्रस्तुत करते हैं, तो आदर्श गति 1 / MAX (X, Y, Z) होगी। यही है, कुछ भी याद नहीं करने के लिए विकास 1 voxel से अधिक नहीं होना चाहिए। लेकिन दूसरी ओर, विस्तार का एक स्तर जो प्रदर्शन को प्रभावित करता है, अक्सर इसकी आवश्यकता नहीं होती है।



प्रस्तुत छवियों में हम विभिन्न नमूना के साथ प्रदान की गई छवियों को देखते हैं। पहले मामले में, बस एक ही सही 1 / MAX (एक्स, वाई, जेड) का उपयोग किया गया था - छवि चिकनी दिखाई देने लगी, बिना दृश्य बदलाव के, क्योंकि हम एक भी स्वर को याद नहीं करते थे, लेकिन! एफपीएस केवल 13 फ्रेम प्रति सेकंड है।
दूसरे विकल्प के लिए, हमने दो बार सैंपलरेट का इस्तेमाल किया - यानी हमने हर दूसरे वॉक्सेल को संसाधित किया, और एक ही समय में जो सर्कल बनते हैं, वह आइसोसर्फ के पहले वॉक्सल के स्थान की गणना करने में त्रुटि के कारण पहले से ही दिखाई देता है। लेकिन एक ही समय में एफपीएस 37 फ्रेम तक बढ़ गया।
एल्गोरिथ्म के पारित होने की गति को कैसे बढ़ाया जाए और एक ही समय में गुणवत्ता न खोने के लिए, मैं अगले लेख में विचार करने की कोशिश करूंगा।