Graficación - Carlos Ernesto Guzmán Rubio

miércoles, 24 de enero de 2018

Conclusion de funciones de una DBA

Una base de datos es una coleccion de información accedida y administrada por un DBMS.
El DBA es la persona con mas conocimientos sobre bases de datos en una organización.
es responsable de:
* recuperabilidad
*integridad
*seguridad
*disponibilidad
*desempeño
*desarrollo y soporte a pruebas

Las funciones de un dba dependen de la descripcion del puesto, corporación y politicas de tecnologias de información.

martes, 23 de enero de 2018

1.1 Administrador de Base de Datos

Un administrador de base de datos (DBA) dirige o lleva a cabo todas las actividades relacionadas con el mantenimiento de un entorno de base de datos exitoso. Las responsabilidades incluyen el diseño, implementación y mantenimiento del sistema de base de datos; el establecimiento de políticas y procedimientos relativos a la gestión, la seguridad, el mantenimiento y el uso del sistema de gestión de base de datos; y la capacitación de los empleados en la gestión y el uso de las bases de datos. Se espera que un DBA se mantenga al tanto de las nuevas tecnologías y los nuevos enfoques de diseño.

1.1.1 Funciones de un DBA

Sus tareas incluyen las siguientes:
* Implementar, dar soporte y gestionar bases de datos corporativas.
* Crear y configurar bases de datos relacionales.
* Ser responsables de la integridad de los datos y la disponibilidad.
* Diseñar, desplegar y monitorizar servidores de bases de datos.
* Diseñar la distribución de los datos y las soluciones de almacenamiento.
* Garantizar la seguridad de las bases de datos, realizar copias de seguridad y llevar a cabo l la recuperación de desastres.
* Planificar e implementar el aprovisionamiento de los datos y aplicaciones.
* Diseñar planes de contingencia.
* Diseñar y crear las bases de datos corporativas de soluciones avanzadas.
* Analizar y reportar datos corporativos que ayuden a la toma de decisiones en la inteligencia de negocios.
* Producir diagramas de entidades relacionales y diagramas de flujos de datos, normalización esquemática, localización lógica y física de bases de datos y parámetros de tablas.

1.1.2 Relación de DBA con otras áreas de los Sistemas.

En sistemas muy complejos cliente/servidor y de tres capas, la base de datos es sólo uno de los elementos que determinan la experiencia de los usuarios en línea y los programas desatendidos. El rendimiento es una de las mayores motivaciones de los DBA para coordinarse con los especialistas de otras áreas del sistema fuera de las líneas burocráticas tradicionales. Uno de los deberes menos respetados por el administrador de base de datos es el desarrollo y soporte a pruebas, mientras que algunos otros encargados lo consideran como la responsabilidad más importante de un DBA. Las actividades de soporte incluyen la colecta de datos de producción para llevar a cabo pruebas con ellos; consultar a los programadores respecto al desempeño; y hacer cambios a los diseños de tablas de manera que se puedan proporcionar nuevos tipos de almacenamientos para las funciones de los programas.

1.2 El procesador y sus registros internos

Los registros del procesador se emplean para controlar instrucciones en ejecución, manejar direccionamiento de memoria y proporcionar capacidad aritmética. Los registros son direccionables por medio de un nombre. Los bits por convención, se numeran de derecha a izquierda, como en:

... 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Los registros internos del procesador se pueden clasificar en 6 tipos diferentes

1. Registros de segmento

2. Registros de propósito general

3. Registros de apuntadores

4. Registros de banderas

5. Registros de Puntero de instrucción

6. Registros de Pila

Registros de segmento
Un registro de segmento tiene 16 bits de longitud y facilita un área de memoria para direccionamiento conocida como el segmento actual.

Registros de propósito general.

Los registros de propósito general AX, BX, CX y DX son los caballos de batalla del sistema. Son únicos en el sentido de que se puede direccionarlos como una palabra o como una parte de un byte. El último byte de la izquierda es la parte "alta", y el último byte de la derecha es la parte "baja". Por ejemplo, el registro CX consta de una parte CH (alta) y una parte Cl (baja), y usted puede referirse a cualquier parte por su nombre.

Registro de Apuntador de Instrucciones.

El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de dirección de la siguiente instrucción que se ejecuta. El IP está asociado con el registro CS en el sentido de que el IP indica la instrucción actual dentro del segmento de código que se está ejecutando actualmente. Los procesadores 80386 y posteriores tienen un IP ampliado de 32 bits, llamado EIP.

Registros Apuntadores.
Los registros SP (apuntador de la pila) Y BP (apuntador de base) están asociados con el registro SS y permiten al sistema accesar datos en el segmento de la pila.

Registros Índice.

Los registros SI y DI están disponibles para direccionamiento indexado y para sumas y restas.

Registro de Banderas.

De los 16 bits del registro de banderas, nueve son comunes a toda la familia de procesadores 8086, y sirven para indicar el estado actual de la máquina y el resultado del procesamiento.
Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente.

Registros de PILA

La pila es un área de memoria importante y por ello tiene, en vez de uno, dos registros que se usan como desplazamiento (offset) para apuntar a su contenido. Se usan como complemento al registro.

Más información de cada registro:

http://itpn.mx/recursosisc/6semestre/lenguajesdeinterfaz/Unidad%20I.pdf

1.1 Importancia de la programación en lenguaje ensamblador

Definición: El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico para cada arquitectura de microprocesador.

La importancia del lenguaje ensamblador es principalmente que se trabaja directamente con el microprocesador; por lo cual se debe de conocer el funcionamiento interno de este, tiene la ventaja de que en el se puede realizar cualquier tipo de programas que en los lenguajes de alto nivel no lo pueden realizar. Otro punto sería que los programas en ensamblador ocupan menos espacio en memoria

miércoles, 8 de noviembre de 2017

Graficas en 3D

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()
ax1 = fig.add_subplot(111, projection='3d')

xpos = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
ypos = [2,3,4,5,1,6,2,1,7,2,3,5,1,3,2]
num_elements = len(xpos)
zpos = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
dx = np.ones(15)
dy = np.ones(15)
dz = [71,22,36,47,25,69,75,48,99,200,11,12,33,14,85]

ax1.bar3d(xpos, ypos, zpos, dx, dy, dz, color='gold')
plt.show()

martes, 7 de noviembre de 2017

Cubos y Triangulo en 3D

TRIANGULO

import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

verticies = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (0,0,1)
    )
edges = (
    (0,1),
    (0,3),
    (0,4),
    (2,1),
    (2,3),
    (4,2),
    (4,3),
    (4,1)
    )

def Cube():
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(verticies[vertex])
    glEnd()


def main():
    pygame.init()
    display = (800,600)
    pygame.display.set_mode(display, DOUBLEBUF|OPENGL)

    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)

    glTranslatef(0.0,0.0, -5)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)


main()

CUBO

import pygame
from pygame.locals import *

from OpenGL.GL import *
from OpenGL.GLU import *

verticies = (
    (1, -1, -1),
    (1, 1, -1),
    (-1, 1, -1),
    (-1, -1, -1),
    (1, -1, 1),
    (1, 1, 1),
    (-1, -1, 1),
    (-1, 1, 1)
    )

edges = (
    (0,1),
    (0,3),
    (0,4),
    (2,1),
    (2,3),
    (2,7),
    (6,3),
    (6,4),
    (6,7),
    (5,1),
    (5,4),
    (5,7)
    )


def Cube():
    glBegin(GL_LINES)
    for edge in edges:
        for vertex in edge:
            glVertex3fv(verticies[vertex])
    glEnd()


def main():
    pygame.init()
    display = (800,600)
    pygame.display.set_mode(display, DOUBLEBUF|OPENGL)

    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)

    glTranslatef(0.0,0.0, -5)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)


main()


CUBO RELLENO DE COLORES


import sys, math, pygame
from operator import itemgetter


class Point3D:
    def __init__(self, x=0, y=0, z=0):
        self.x, self.y, self.z = float(x), float(y), float(z)

    def rotateX(self, angle):
        """ Rotates the point around the X axis by the given angle in degrees. """        rad = angle * math.pi / 180        cosa = math.cos(rad)
        sina = math.sin(rad)
        y = self.y * cosa - self.z * sina
        z = self.y * sina + self.z * cosa
        return Point3D(self.x, y, z)

    def rotateY(self, angle):
        """ Rotates the point around the Y axis by the given angle in degrees. """        rad = angle * math.pi / 180        cosa = math.cos(rad)
        sina = math.sin(rad)
        z = self.z * cosa - self.x * sina
        x = self.z * sina + self.x * cosa
        return Point3D(x, self.y, z)

    def rotateZ(self, angle):
        """ Rotates the point around the Z axis by the given angle in degrees. """        rad = angle * math.pi / 180        cosa = math.cos(rad)
        sina = math.sin(rad)
        x = self.x * cosa - self.y * sina
        y = self.x * sina + self.y * cosa
        return Point3D(x, y, self.z)

    def project(self, win_width, win_height, fov, viewer_distance):
        """ Transforms this 3D point to 2D using a perspective projection. """        factor = fov / (viewer_distance + self.z)
        x = self.x * factor + win_width / 2        y = -self.y * factor + win_height / 2        return Point3D(x, y, self.z)


class Simulation:
    def __init__(self, win_width=640, win_height=480):
        pygame.init()

        self.screen = pygame.display.set_mode((win_width, win_height))
        pygame.display.set_caption("Figura de cubo 3D en python")

        self.clock = pygame.time.Clock()

        self.vertices = [
            Point3D(-1, 1, -1),
            Point3D(1, 1, -1),
            Point3D(1, -1, -1),
            Point3D(-1, -1, -1),
            Point3D(-1, 1, 1),
            Point3D(1, 1, 1),
            Point3D(1, -1, 1),
            Point3D(-1, -1, 1)
        ]

        # Define the vertices that compose each of the 6 faces. These numbers are        # indices to the vertices list defined above.        self.faces = [(0, 1, 2, 3), (1, 5, 6, 2), (5, 4, 7, 6), (4, 0, 3, 7), (0, 4, 5, 1), (3, 2, 6, 7)]

        # Define colors for each face        self.colors = [(137, 64, 245), (225, 32, 77), (0, 135, 123), (87, 12, 235), (30, 250, 145), (15, 215, 0)]

        self.angle = 0
    def run(self):
        """ Main Loop """        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()

            self.clock.tick(50)
            self.screen.fill((0, 32, 0))

            # It will hold transformed vertices.            t = []

            for v in self.vertices:
                # Rotate the point around X axis, then around Y axis, and finally around Z axis.                r = v.rotateX(self.angle).rotateY(self.angle).rotateZ(self.angle)
                # Transform the point from 3D to 2D                p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)
                # Put the point in the list of transformed vertices                t.append(p)

            # Calculate the average Z values of each face.            avg_z = []
            i = 0            for f in self.faces:
                z = (t[f[0]].z + t[f[1]].z + t[f[2]].z + t[f[3]].z) / 4.0                avg_z.append([i, z])
                i = i + 1
            # Draw the faces using the Painter's algorithm:            # Distant faces are drawn before the closer ones.            for tmp in sorted(avg_z, key=itemgetter(1), reverse=True):
                face_index = tmp[0]
                f = self.faces[face_index]
                pointlist = [(t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y),
                             (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y),
                             (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y),
                             (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y)]
                pygame.draw.polygon(self.screen, self.colors[face_index], pointlist)

            self.angle += 1
            pygame.display.flip()


if __name__ == "__main__":
    Simulation().run()

martes, 31 de octubre de 2017

Librerias para 3D en Python

Pygame: Sin duda la librería más famosa de Python. Pygame lleva en desarrollo desde el 2001 por lo que tiene un gran comunidad, publicándose en su propia página web gran cantidad de juegos y demos con más de 1.000 proyecto registrados. Es multiplataforma a la perfección y la librería que menos problemas da al portar entre Linux/Windows/Mac, y es famosa por su facilidad de programación. Utiliza una librería de C llamada SDL, librería en la que están escritos los juegos 2d más famosos en Linux como Battle for Wesnoth, SuperTux o StepMania.

PyOpenGL: Hablando de Pygame, esta tiene un fallo, y es que no soporta Aceleración gráfica al basarse en SDL. Aquí entra en juego PyOpenGL, un binding de OpenGL que se puede combinar con Pygame para añadir las funciones que a este le faltan. Eso sí, requiere un nivel de conocimiento de programación de videojuegos más alto, al ser una capa de abstracción máyor. Para quien no conozca OpenGL, es la competencia de DirectX en el mundo del software Libre, y todos los juegos 3d libres y muchos cerrados corren sobre ella incluidos juegos de Blizzard y Valve.

Pyglet: Pyglet es la alternativa a Pygame+PyOpenGL permitiendo aceleración gráfica y trabajar en 2d/3d, todo ello en una sola librería, y sin tener que recurrir a la engorrosa dificultad de PyOpenGL. Eso sí, sacrificando algunas utilidades avanzadas de pyopengl, y siendo un poco más dificil de usar que Pygame. Pyglet es una librería con un desarollo actual más rápido que pygame, que cada día gana más adeptos. En realidad Pyglet utiliza OpenGL en gran parte de sus funciones, pero facilitando su uso.

Panda3d: Librería libre centrada en videojuegos 3D escrita para Python y C++. Es una librería orientada a 3D, y por lo tanto no apta para iniciados. Algunos juegos de Disney han usado esta librería.

https://elbauldelprogramador.com/programando-videojuegos-en-python/

VIDEO USANDO OPENGL - CUBO

https://www.youtube.com/watch?v=R4n4NyDG2hI&list=PLQVvvaa0QuDdfGpqjkEJSeWKGCP31__wD

LISTA DE VIDEOS USANDO PYGLET, OPENGL, BLENDER

https://www.youtube.com/watch?v=Wyv5TnkFuxE&list=PL1P11yPQAo7qaq_Ga-XA7TvuB8jyI3Qjh