Programas A REVISAR NetBeans

Alumnos:
JOSE JUA MUÑIZ HERNANDEZ
EDGAR FRANCISCO BENAVIDES PERALES

Página 110 imagen.

Página 123 Círculo Mayor.

Página 125 Termómetro.

Página 129 Cara.

Página  155 Cajas.

Página 159 Estrellas.

Página 160 Caminata.

Página 163 Pisos De Apartamento.

Página 167 Escalones.

Página 172 Globo.

Página 219 Gráficos.

APIS 3D en Java

API de graficos tridimensionales.

Los gráficos 3D se han convertido en algo muy popular, particularmente en videojuegos, al punto que se han creado interfaces de programación de aplicaciones (API) especializadas para facilitar los procesos en todas las etapas de la generación de gráficos por computadora. Estas interfaces han demostrado ser vitales para los desarrolladores de hardware para gráficos por computadora, ya que proveen un camino al programador para acceder al hardware de manera abstracta, aprovechando las ventajas de tal o cual placa de video.
Las siguientes interfaces para gráficos por computadora son particularmente populares:

• OpenGL
• Direct3D (subconjunto de DirectX para producir gráficos interactivos en 3D)
• RenderMan
• Metal
• Vulkan

Java 3D
El API Java 3D es un interface para escribir programas que muestran e interactuan con gráficos tridimensionales. Java 3D es una extensión estándard del JDK 2 de Java. El API Java 3D proporciona una colección de constructores de alto-nivel para crear y manipular geometrías 3D y estructuras para dibujar esta geometría. Java 3D proporciona las funciones para creación de imágenes, visualizaciones, animaciones y programas de aplicaciones gráficas 3D interactivas.


¿Qué es el API 3D de Java?
El API 3D de Java es un árbol de clases Java que sirven como interface para sistemas de renderizado de gráficos tridimensionales y un sistema de sonido. El programador trabaja con constructores de alto nivel para crear y manipular objetos geométricos en 3D. Estos objetos geométricos residen en un universo virtual, que luego es renderizado. El API está diseñado con flexibilidad para crear universos virtuales precisos de una ámplia variedad de tamaños, desde astronómicos a subatómicos.
A pesar de toda esta funcionalidad, el API es sencillo de usar. Los detalles de renderizado se manejan automáticamente. Aprovechándose de los Threads Java, el renderizador Java 3D es capaz de renderizar en paralelo. El renderizador también puede optimizarse automáticamente para mejorar el rendimiento del renderizado.
Un programa Java 3D crea ejemplares de objetos Java 3D y los sitúa en un estructura de datos de escenario gráfico. Este escenario gráfico es una composición de objetos 3D en una estructura de árbol que especifica completamente el contenido de un universo virtual, y cómo va a ser renderizado.

Los programas Java 3D pueden escribirse para ser ejecutados como aplicaciones solitarias o como applets en navegadores que hayan sido extendidos para soportar Java 3D, o ambos.


Crear una esfera en 3D.

Para crear un objeto 3D es necesario tener instalada la API Java3D.

Codigo:
package esfera3d;

import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.Sphere;
import com.sun.j3d.utils.universe.SimpleUniverse;
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.GraphicsConfiguration;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.Node;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;

public final class Esfera3D extends Applet {

public Esfera3D() {
setLayout(new BorderLayout());
GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
Canvas3D canvas3D = new Canvas3D(config);
add("Center", canvas3D);
BranchGroup escena = crearEscenaGrafico();
SimpleUniverse simpleU = new SimpleUniverse(canvas3D);
simpleU.getViewingPlatform().setNominalViewingTransform();
simpleU.addBranchGraph(escena);
}

public BranchGroup crearEscenaGrafico() {
BranchGroup objPrincipal = new BranchGroup();
objPrincipal.addChild(CrearEsfera());
objPrincipal.addChild(CrearIluminacion());
return objPrincipal;
}

private Node CrearEsfera() {
Sphere esfera = new Sphere(0.3f); //Tamaño esfera (0.3)
return esfera;
}

private Node CrearIluminacion() {
Color3f colorLuz = new Color3f(1.0f, 0.5f, 6.1f);
BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 20.0), 100.0);
Vector3f direccionLuz = new Vector3f(4.0f, -7.0f, -12.0f);
DirectionalLight luz1 = new DirectionalLight(colorLuz, direccionLuz);
luz1.setInfluencingBounds(bounds);
return luz1;
}

public static void main(String[] args) {
Frame frame = new MainFrame(new Esfera3D(), 256, 256); //Tamaño ventana de 256x256 pixeles.
}
}

Gráficos. Animación de un fractal.

Esta vez crearemos un nuevo proyecto que consiste en una pequeña animación de un fractal tipo arbol. Se juega con el grosor de las "ramas", los grados de inclinación entre ellas y una velocidad de animación no constante (descelerada). Para ello como va siendo habitual usando Netbeans creamos un nuevo proyecto en el cual se utiliza un jFrame donde se le añade un jButton y un jPanel.

Codigo 1 (Principal.java)

package Animacio4;

public class Principal extends javax.swing.JFrame {

int grados = 0; //Inclinación arbol
int depth = 9; //Profundidad de las ramas
double sep = 0; //Grados de separacion entre ramas

public Principal() {
initComponents();
this.setLocationRelativeTo(null); //Centrar pantalla
}

private void initComponents() { ... }

private void jButtonIniciarActionPerformed(java.awt.event.ActionEvent evt) {
grados = 0;
sep = 0;
for (int i = 0; i > -90; i--) {
sep = (sep < 90) ? sep += 0.333 : sep;
Dibujo.Dibujar(
jPanel1.getGraphics(),
jPanel1.getWidth() / 2,
jPanel1.getHeight(),
grados -= 1,
depth,
sep);
try {
Thread.sleep((int) sep); //Velocidad de la animación
} catch (InterruptedException ex) {
}
}
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Principal().setVisible(true);
}
});
}

// Variables declaration - do not modify
private javax.swing.JButton jButtonIniciar;
private javax.swing.JPanel jPanel1;
// End of variables declaration

}

Codigo 2 (Dibujo.java):

package Animacio4;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;

public class Dibujo {

public static void Dibujar(Graphics g, int x1, int y1, double angle, int depth, double sep) {
//Salir cuando la profundidad a llegado al limite
if (depth == 0) return;
//Borra jPanel
if (depth == 9) {
g.setColor(Color.WHITE);
g.fillRect(0, 0, x1 * 2, y1);
}

Graphics2D g2 = (Graphics2D) g;
//Tipo de pincel (grosor)
Stroke stroke = new BasicStroke((float) depth);
g2.setStroke(stroke);
//Color azul
g.setColor(Color.blue);
//Filtro antialiasing
g2.setRenderingHint(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
//Calculo coordenadas
int x2 = x1 + (int) (Math.cos(Math.toRadians(angle)) * depth * 5.0);
int y2 = y1 + (int) (Math.sin(Math.toRadians(angle)) * depth * 5.0);
//Dibuja linia
g2.drawLine(x1, y1, x2, y2);
//Dibuja bifurcaciones (recursivo)
Dibujar(g2, x2, y2, (angle - (sep)), depth - 1, sep);
Dibujar(g2, x2, y2, (angle + (sep)), depth - 1, sep);
}

}