1 / 18

Implementación de un visor molecular con HOpenGL

Implementación de un visor molecular con HOpenGL. Juan Antonio Chaves Naranjo Oscar Noel Amaya García Valentín Adolfo Acosta García. Índice. Motivaciones Herramientas para su desarrollo Estructuras de datos para manejo de modelos moleculares 3D Implementación Visor 3D molecular

kyros
Télécharger la présentation

Implementación de un visor molecular con HOpenGL

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Implementación de un visor molecular con HOpenGL Juan Antonio Chaves Naranjo Oscar Noel Amaya García Valentín Adolfo Acosta García

  2. Índice • Motivaciones • Herramientas para su desarrollo • Estructuras de datos para manejo de modelos moleculares 3D • Implementación Visor 3D molecular • Comparación de código con visor similar en lenguaje Imperativo (Tcl/Tk) • Comparación rendimiento con visor similar en lenguaje Imperativo (Tcl/Tk) • Conclusiones • Bibliografía UMA, Programación Declarativa Avanzada Curso 08/09

  3. 1. Motivaciones • Elección del tema respondiendo a la curiosidad del uso de OpenGL en un lenguaje funcional. • Comparativa de uso/rendimiento de OpenGL en Haskell y en un lenguaje imperativo. En este caso usamos Tcl/Tk (John Ousterhout, 1999). • A priori no buscamos un fin educativo. UMA, Programación Declarativa Avanzada Curso 08/09

  4. 1. Motivaciones • Tcl/Tk • Wrapper OpenGL • Lenguaje Interpretado

  5. 2. Herramientas para su desarrollo • Haskell (U. Yale y U. Glasgow, 1990) • Lenguaje funcional • OpenGL (Silicon Graphics Inc. 1992) • API gráfica multiplataforma y multilenguaje para la modelización 2D y 3D. Orientado a lenguajes imperativos. • Haskell y OpenGL: HOpenGL (1999) • La eclosión de las mónadas hace que programas en Haskell se comporten como los programas imperativos y por tanto facilita la interacción entre Haskell y OpenGL. UMA, Programación Declarativa Avanzada Curso 08/09

  6. 3. Estructuras de datos para manejo de modelos moleculares • El estándar en representaciones moleculares son los ficheros “.mol”. Nº de Átomos Nº de Enlaces Átomo de Carbono en la posición definida 18 18 0 0 0 0 0 0 0 0 1 V2000 2.4333 -0.7208 0.0000 C 0 0 0 0 0 0 0 0 0 0 0 0 ......... 3.1454 0.2032 -0.8617 H 0 0 0 0 0 0 0 0 0 0 0 0 2 1 1 0 0 0 0 ....... 18 6 1 0 0 0 0 Átomo de Hidrógeno en la posición definida Define el enlace entre el átomo nº 18 y el 6 • Dichos datos son encapsulados dentro de una mónada IO para su posterior acceso en el visor 3D. UMA, Programación Declarativa Avanzada Curso 08/09

  7. -- leerMol :: (Num a, Num b, … , Num d) => -- [Char] -> IO (d,a,[((f,g,e),[Char])],[(c,b)])) leerMol nombreFichero = do cad <- readFile nombreFichero return (leerMol2 cad) leerMol2 cad = (nAtomos, nEnlaces, atomos, enlaces) where (l1,r1) = leeLínea cad (l2,r2) = leeLínea r1 (l3,r3) = leeLínea r2 (l4,r4) = leeLínea r3 (nAtomos,nEnlaces) = leeNAtomNEnl l4 (atomos,r5) = leeAtomos nAtomos r4 (enlaces,r6) = leeEnlaces nEnlaces r5 UMA, Programación Declarativa Avanzada Curso 08/09

  8. 4. Implementación Visor 3D molecular • Cabe destacar principalmente 3 funciones que son las que modelan el funcionamiento básico. • Función main • Función iniciarDisplayListMol • Función display UMA, Programación Declarativa Avanzada Curso 08/09

  9. 4. Implementación Visor 3D molecular glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(500,500); main = do (progName,_) <- getArgsAndInitialize initialDisplayMode $= [ RGBMode, WithDepthBuffer, DoubleBuffered ] initialWindowSize $= Size 500 500 createWindow "Visor Haskell + OpenGL" depthFunc $= Just Less clearColor $= Color4 0.1 0.2 0.4 0 shadeModel $= Smooth position (Light 0) $= Vertex4 1 1 1 0 lighting $= Enabled light (Light 0) $= Enabled depthFunc $= Just Less frontFace $= CW lighting $= Enabled glClearColor(0.1,0.2,0.4,0); glShadeMode(GL_SMOOTH); glEnable(GL_LIGHTING); UMA, Programación Declarativa Avanzada Curso 08/09

  10. 4. Implementación Visor 3D molecular light (Light 0) $= Enabled autoNormal $= Enabled normalize $= Enabled depthFunc $= JustLess fontOffset <- makeRasterFont listName <- iniciarDisplayListMol "aspirina.mol" pPos <- new (90::Int,270::Int,2.0) keyboardMouseCallback $= Just (keyboardpPos) displayCallback $= displaypPoslistNamefontOffset reshapeCallback $= Justreshape mainLoop glutDisplayFunc(display); glutReshapeFunc(reshape); UMA, Programación Declarativa Avanzada Curso 08/09

  11. 4. Implementación Visor 3D molecular iniciarDisplayListMol fichero = do [listName] <- genObjectNames 1 defineList listName Compile $ do (nAt,nEnl,atom,enl) <- leerMol fichero pintaAtomos atom pintaEnlaces atom enl return listName listName=glGenList(1); glNewList(listName, GL_COMPILE); UMA, Programación Declarativa Avanzada Curso 08/09

  12. 4. Implementación Visor 3D molecular glLoadIdentity(); glClearutReshapeFunc(reshape); displaypPoslistNamefontOffset = do loadIdentity setPointOfViewpPos clear [ColorBuffer,DepthBuffer] translate (Vector3 0.0 0.5 0.0 :: Vector3 GLdouble) rotate 90 (Vector3 1.0 0.0 0.0 :: Vector3 GLdouble) callListlistName swapBuffers glTranslated(0.0,0.5,0.0); glRotated(1.0,0.0,0.0); UMA, Programación Declarativa Avanzada Curso 08/09

  13. 5. Comparación de código con lenguaje Imperativo Imperativo VS Funcional Iteradores – F. Recursivas Wrapers OpenGL Estructuras especiales UMA, Programación Declarativa Avanzada Curso 08/09

  14. 5. Comparación de código con lenguaje Imperativo pintaEnlacesatom [] = do -- Posibles acciones return () pintaEnlacesatom ((id1,id2):xs) = do let p1 = posAtomo id1 atom let p2 = posAtomo id2 atom let c = vectorSub p1 p2 letlong = vectorNorm c letang = (vectorAngle (0,0,1) c) * 57.2957795131 let (ex,ey,ez) = vectorCrossProduct (0,0,1) c letlongSeg = long/2.0 let (tx,ty,tz) = vectorSum p1 (vectorScale 0.0 c) preservingMatrix $ do translate (Vector3 txtytz :: Vector3 GLdouble) rotateang (Vector3 ex eyez) currentColor $= Color4 0 0 1 1 materialAmbientAndDiffuse Front $= colorAtomo (simboloAtomo id1 atom) renderObjectSolid (Cylinder' 0.07 longSeg 15 15) ASIGNACIONES ACCIONES SECUENCIALES UMA, Programación Declarativa Avanzada Curso 08/09

  15. 5. Comparación de código con lenguaje Imperativo let (tx,ty,tz) = vectorSum p1 (vectorScale 0.5 c) preservingMatrix $ do translate (Vector3 tx ty tz :: Vector3 GLdouble) rotate ang (Vector3 ex ey ez) materialAmbientAndDiffuse Front $= colorAtomo (simboloAtomo id2 atom) renderObject Solid (Cylinder' 0.07 longSeg 15 15) pintaEnlaces atom xs return () LLAMADA RECURSIVA UMA, Programación Declarativa Avanzada Curso 08/09

  16. 6. Comparación de rendimiento con lenguaje Imperativo Lenguaje Imperativo Interpretado Vs Lenguaje Funcional + Mónadas compilado ¿Qué pensáis? UMA, Programación Declarativa Avanzada Curso 08/09

  17. 7. Conclusiones • Amplia nuestros conocimiento de Haskell, que es uno de los objetivos de esta asignatura. • No nos resulta muy útil en comparación con los lenguajes imperativos: • Bajo rendimiento • Pocas ventajas en la programación • No parece ser el lenguaje de programación más adecuado para el modelado 3D, como así lo demuestra el mercado. UMA, Programación Declarativa Avanzada Curso 08/09

  18. 8. Bibliografía UMA, Programación Declarativa Avanzada Curso 08/09 • Material y documentación • http://www.haskell.org/haskellwiki/Opengl/(2009) • Tutoriales • http://www.cin.ufpe.br/~haskell/hopengl/(2002) • http://public.tfh-berlin.de/~panitz/hopengl/(2003) • PFC – Oscar Noel Amaya García • http://www.lcc.uma.es(2007)

More Related