Graficacion (Ramirez Flores Yajairo): octubre 2013

domingo, 27 de octubre de 2013

4TO. CONGRESO NACIONAL

MIS EXPERIENCIAS....

Antes que nada el congreso nacional de ingenierías es fortalecer el programa de movilidad estudiantil

CURSO C++.
Mis experiencias en el curso en el transcurso de la semana fue que fui aprendiendo cosas nuevas y mas que nada reforzando lo que una vez vi en preparatoria.

lunes, 14 de octubre de 2013

PROGRAMAS

ROTACION.

package j2d_rotate;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.geom.Line2D;
import java.awt.geom.QuadCurve2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JPanel;
/**
*
* @author Mouse
*/
public class j2dPanel extends JPanel{
double centrox,centroy;
double rotate;
/*constructor*/
public j2dPanel(Dimension d){
this.setPreferredSize(d);
this.setSize(d);
this.setVisible(true);
//se obtiene las coordenadas del centro del jpanel
this.centrox= this.size().width/2;
this.centroy = this.size().height/2;
//se inicializa la rotacion en o grados
rotate = 0;
this.repaint();
}

@Override
public void paintComponent(Graphics g){
//se inicializa java2d
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// se aÃ±ade un color de fondo degrado
g2.setPaint(new GradientPaint(0, 0, new Color(131,131,131), Float.valueOf(this.getSize().width), 0, new Color(188,194,236)));
g2.fill(g2.getClip());
//se creo otro objeto AffineTransform para guardar los valores iniciales
AffineTransform oldt = g2.getTransform();
//se aplica la rotacion y se traslada las coordenadas para que coincida con el centro del JPanel
g2.transform(AffineTransform.getRotateInstance(Math.toRadians(rotate),this.centrox,this.centroy));
/************************************************************************/
/* Una ves que se aplica la transformacion , todas las figuras se dibujaran siguiendo
el angulo asignado en radianes y tomando como eje el centro del JPanel */
//grosor y color de pincel
g2.setColor(new Color(200,10,10));
//se dibuja la figura, junto a una linea que nos servira para apreciar mejor la rotacion
g2.setPaint(new GradientPaint((float) this.centrox-100, (float) this.centroy, new Color(200,0,25), (float) this.centrox+100, (float) this.centroy, new Color(0,96,27)));
g2.fill(new Rectangle2D.Double( this.centrox-100, this.centroy-50, 200, 100));
g2.fill(new Rectangle2D.Double( this.centrox-100, this.centroy-50, 100, 170));
g2.setColor(new Color(0,0,200));
g2.setStroke(new BasicStroke(4.0f));
g2.draw(new Line2D.Double(this.centrox,this.centroy,this.centrox+100,this.centroy));
//un poco de texto
g2.setFont(new Font("Arial", Font.BOLD, 12));
g2.drawString(" R=" + rotate+"Â°",(float) this.centrox+100 ,(float) this.centroy);
/************************************************************************/

//retornamos a los valores iniciales
g2.setTransform(oldt);

g2.setColor(new Color(0,0,0));
g2.setFont(new Font("Arial", Font.PLAIN, 12));
g2.drawString("RotaciÃ³n (Grados) = " + rotate + "Â°", 10,25);
g2.drawString("RotaciÃ³n (Radianes) = " + Math.toRadians(rotate), 10,50);
g2.setFont(new Font("Arial", Font.BOLD, 12));
g2.drawString("x' 180Â°", 10 ,(float) this.centroy-10);
g2.drawString("x 0Â°", this.getSize().width-50 ,(float) this.centroy-10);
g2.drawString("y 270Â°", (float) this.centrox+5 ,30);
g2.drawString("y' 90Â°", (float) this.centrox+5 ,this.getSize().height-30);
// se dibuja una figura con forma de "flecha"
g2.setStroke(new BasicStroke(2.0f));
g2.draw(new QuadCurve2D.Double(this.centrox + 0, this.centroy + 50, this.centrox + 45,this.centroy + 45, this.centrox + 50, this.centroy + 0));
g2.draw(new Line2D.Double(this.centrox + 0,this.centroy + 50,this.centrox + 10,this.centroy + 40));
g2.draw(new Line2D.Double(this.centrox + 0, this.centroy + 50,this.centrox + 14, this.centroy + 55));

//dibujamos unaas lineas que simularan el eje de coordenas X & Y
g2.setStroke(new BasicStroke(1.0f));
g2.setColor(new Color(0,0,0));
g2.draw(new Line2D.Double(this.centrox,0,this.centrox,this.centroy*2));
g2.draw(new Line2D.Double(0,this.centroy,this.centrox*2,this.centroy));

this.repaint();
}

//aplica la rotacion en grados
public void setRotate(double r){
this.rotate=r;
}
//generamos un numero al azar de 0 a 360
public void setRotateRandom(){
this.rotate=(int)(Math.random()*360);
}
}

------------------------------------------------------------------------------------------------------------

public class Interfaz extends javax.swing.JFrame {

j2dPanel j2d;

/** Creates new form Interfaz */

public Interfaz() {

initComponents();

this.setTitle("ROTACION. GRAFICACION");

j2d = new j2dPanel(PANEL.getSize());

PANEL.add(j2d);

PANEL.repaint();

}

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents

private void initComponents() {

jPanel1 = new javax.swing.JPanel();

cmdRotar1 = new javax.swing.JButton();

txtRotate = new javax.swing.JTextField();

jLabel1 = new javax.swing.JLabel();

cmdRotar2 = new javax.swing.JButton();

PANEL = new javax.swing.JPanel();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jPanel1.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0, 0, 0)));

cmdRotar1.setText("Rotar Figura");

cmdRotar1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

cmdRotar1ActionPerformed(evt);

}

});

txtRotate.setText("45");

jLabel1.setText("Angulo de rotacion (en grados):");

cmdRotar2.setText("Rotar Random");

cmdRotar2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

cmdRotar2ActionPerformed(evt);

}

});

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addGap(32, 32, 32)

.addComponent(jLabel1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(txtRotate, javax.swing.GroupLayout.PREFERRED_SIZE, 81, javax.swing.GroupLayout.PREFERRED_SIZE)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(cmdRotar1, javax.swing.GroupLayout.PREFERRED_SIZE, 177, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(cmdRotar2, javax.swing.GroupLayout.DEFAULT_SIZE, 195, Short.MAX_VALUE)

.addContainerGap())

);

jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(jPanel1Layout.createSequentialGroup()

.addContainerGap()

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)

.addComponent(jLabel1)

.addComponent(txtRotate, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(cmdRotar1)

.addComponent(cmdRotar2))

.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

);

PANEL.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0, 0, 0)));

javax.swing.GroupLayout PANELLayout = new javax.swing.GroupLayout(PANEL);

PANEL.setLayout(PANELLayout);

PANELLayout.setHorizontalGroup(

PANELLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 673, Short.MAX_VALUE)

);

PANELLayout.setVerticalGroup(

PANELLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 381, Short.MAX_VALUE)

);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()

.addContainerGap()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)

.addComponent(PANEL, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jPanel1, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

.addContainerGap())

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()

.addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(PANEL, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addContainerGap())

);

pack();

}// </editor-fold>//GEN-END:initComponents

private void cmdRotar1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cmdRotar1ActionPerformed

j2d.setRotate(Double.valueOf(txtRotate.getText()));

}//GEN-LAST:event_cmdRotar1ActionPerformed

private void cmdRotar2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_cmdRotar2ActionPerformed

j2d.setRotateRandom();

}//GEN-LAST:event_cmdRotar2ActionPerformed

/**

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new Interfaz().setVisible(true);

}

});

}

// Variables declaration - do not modify//GEN-BEGIN:variables

private javax.swing.JPanel PANEL;

private javax.swing.JButton cmdRotar1;

private javax.swing.JButton cmdRotar2;

private javax.swing.JLabel jLabel1;

private javax.swing.JPanel jPanel1;

private javax.swing.JTextField txtRotate;

// End of variables declaration//GEN-END:variables

}

------------------------------------------------------------------------------------------------------------

public class Main {

/**

* @param args the command line arguments

public static void main(String[] args) {

new Interfaz().show();

}

------------------------------------------------------------------------------------------------------------

ESCALACION.

import java.io.File;

import java.io.IOException;

import javax.imageio.ImageIO;

import javax.swing.JFileChooser;

import javax.swing.filechooser.FileNameExtensionFilter;

/**

* @web

* @author Mouse

public class interfaz extends javax.swing.JFrame {

private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");

private JFileChooser fileChooser = new JFileChooser();

private File Directorio = fileChooser.getCurrentDirectory();

private Zoom zoom;

/** Creates new form interfaz */

public interfaz() {

initComponents();

this.setTitle("ESCALACION. GRAFICACION");

this.setLocationRelativeTo(null);

}

/** This method is called from within the constructor to

* initialize the form.

* WARNING: Do NOT modify this code. The content of this method is

* always regenerated by the Form Editor.

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents

private void initComponents() {

jPanel1 = new javax.swing.JPanel();

jMenuBar1 = new javax.swing.JMenuBar();

jMenu1 = new javax.swing.JMenu();

jMenuItem1 = new javax.swing.JMenuItem();

jMenu2 = new javax.swing.JMenu();

jMenu3 = new javax.swing.JMenu();

jMenuItem5 = new javax.swing.JMenuItem();

jMenuItem2 = new javax.swing.JMenuItem();

jMenuItem6 = new javax.swing.JMenuItem();

jMenuItem7 = new javax.swing.JMenuItem();

jMenu4 = new javax.swing.JMenu();

jMenuItem3 = new javax.swing.JMenuItem();

jMenuItem8 = new javax.swing.JMenuItem();

jMenuItem9 = new javax.swing.JMenuItem();

jMenuItem10 = new javax.swing.JMenuItem();

jMenuItem4 = new javax.swing.JMenuItem();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);

jPanel1.setLayout(jPanel1Layout);

jPanel1Layout.setHorizontalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 728, Short.MAX_VALUE)

);

jPanel1Layout.setVerticalGroup(

jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 517, Short.MAX_VALUE)

);

jMenu1.setText("File");

jMenuItem1.setText("Abrir imagen...");

jMenuItem1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem1ActionPerformed(evt);

}

});

jMenu1.add(jMenuItem1);

jMenuBar1.add(jMenu1);

jMenu2.setText("Herramientas");

jMenu3.setText("Zoom (+)");

jMenuItem5.setText("100%");

jMenuItem5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem5ActionPerformed(evt);

}

});

jMenu3.add(jMenuItem5);

jMenuItem2.setText("75%");

jMenuItem2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem2ActionPerformed(evt);

}

});

jMenu3.add(jMenuItem2);

jMenuItem6.setText("50%");

jMenuItem6.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem6ActionPerformed(evt);

}

});

jMenu3.add(jMenuItem6);

jMenuItem7.setText("25%");

jMenuItem7.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem7ActionPerformed(evt);

}

});

jMenu3.add(jMenuItem7);

jMenu2.add(jMenu3);

jMenu4.setText("Zoom (-)");

jMenuItem3.setText("99%");

jMenuItem3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem3ActionPerformed(evt);

}

});

jMenu4.add(jMenuItem3);

jMenuItem8.setText("75%");

jMenuItem8.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem8ActionPerformed(evt);

}

});

jMenu4.add(jMenuItem8);

jMenuItem9.setText("50%");

jMenuItem9.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem9ActionPerformed(evt);

}

});

jMenu4.add(jMenuItem9);

jMenuItem10.setText("25%");

jMenuItem10.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem10ActionPerformed(evt);

}

});

jMenu4.add(jMenuItem10);

jMenu2.add(jMenu4);

jMenuItem4.setText("Restaurar");

jMenuItem4.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jMenuItem4ActionPerformed(evt);

}

});

jMenu2.add(jMenuItem4);

jMenuBar1.add(jMenu2);

setJMenuBar(jMenuBar1);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

);

pack();

}// </editor-fold>//GEN-END:initComponents

private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem1ActionPerformed

Abrir_Imagen();

}//GEN-LAST:event_jMenuItem1ActionPerformed

private void jMenuItem4ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem4ActionPerformed

zoom.Restaurar();

}//GEN-LAST:event_jMenuItem4ActionPerformed

private void jMenuItem5ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem5ActionPerformed

zoom.Aumentar(100);

}//GEN-LAST:event_jMenuItem5ActionPerformed

private void jMenuItem2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem2ActionPerformed

zoom.Aumentar(75);

}//GEN-LAST:event_jMenuItem2ActionPerformed

private void jMenuItem6ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem6ActionPerformed

zoom.Aumentar(50);

}//GEN-LAST:event_jMenuItem6ActionPerformed

private void jMenuItem7ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem7ActionPerformed

zoom.Aumentar(25);

}//GEN-LAST:event_jMenuItem7ActionPerformed

private void jMenuItem3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem3ActionPerformed

zoom.Disminuir(99);

}//GEN-LAST:event_jMenuItem3ActionPerformed

private void jMenuItem8ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem8ActionPerformed

zoom.Disminuir(75);

}//GEN-LAST:event_jMenuItem8ActionPerformed

private void jMenuItem9ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem9ActionPerformed

zoom.Disminuir(50); // TODO add your handling code here:

}//GEN-LAST:event_jMenuItem9ActionPerformed

private void jMenuItem10ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jMenuItem10ActionPerformed

zoom.Disminuir(25);

}//GEN-LAST:event_jMenuItem10ActionPerformed

//muestra una ventana de dialgo para abrir un archivo de imagen

public void Abrir_Imagen(){

fileChooser = new JFileChooser();

fileChooser.setFileFilter(filter);

fileChooser.setCurrentDirectory( Directorio );

int result = fileChooser.showOpenDialog(null);

if ( result == JFileChooser.APPROVE_OPTION ){

try {

zoom = new Zoom(ImageIO.read( fileChooser.getSelectedFile() ));

this.jPanel1.removeAll();

this.jPanel1.add(zoom);

this.jPanel1.repaint();

this.Directorio = fileChooser.getCurrentDirectory();

} catch (IOException ex) {

System.out.println("error: " + ex);

}

/**

* @param args the command line arguments

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new interfaz().setVisible(true);

}

});

}

// Variables declaration - do not modify//GEN-BEGIN:variables

private javax.swing.JMenu jMenu1;

private javax.swing.JMenu jMenu2;

private javax.swing.JMenu jMenu3;

private javax.swing.JMenu jMenu4;

private javax.swing.JMenuBar jMenuBar1;

private javax.swing.JMenuItem jMenuItem1;

private javax.swing.JMenuItem jMenuItem10;

private javax.swing.JMenuItem jMenuItem2;

private javax.swing.JMenuItem jMenuItem3;

private javax.swing.JMenuItem jMenuItem4;

private javax.swing.JMenuItem jMenuItem5;

private javax.swing.JMenuItem jMenuItem6;

private javax.swing.JMenuItem jMenuItem7;

private javax.swing.JMenuItem jMenuItem8;

private javax.swing.JMenuItem jMenuItem9;

private javax.swing.JPanel jPanel1;

// End of variables declaration//GEN-END:variables

}

------------------------------------------------------------------------------------------------------------

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.RenderingHints;

import java.awt.image.BufferedImage;

import javax.swing.JPanel;

/**

* @web

* @author Mouse

public class Zoom extends JPanel {

private Image FOTO_ORIGINAL;

private Image FOTO_tmp;

private BufferedImage Imagen_en_memoria;

private Graphics2D g2D;

private boolean con_foto = false;

private int valEscalaX=0;

private int valEscalaY=0;

/* al crear el objeto se crea con una imagen pasada como parametro*/

public Zoom(BufferedImage f){

this.FOTO_ORIGINAL = f;

this.FOTO_tmp = f;

this.setSize(f.getWidth(),f.getHeight());

this.setVisible(true);

this.con_foto=true;

}

@Override

protected void paintComponent(Graphics g) {

Graphics2D g2 = (Graphics2D)g;

if(this.con_foto){

Imagen_en_memoria = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_RGB);

g2D = Imagen_en_memoria.createGraphics();

g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

//se aÃ±ade la foto

g2D.drawImage(FOTO_tmp,0, 0, FOTO_tmp.getWidth(this), FOTO_tmp.getHeight(this), this);

g2.drawImage(Imagen_en_memoria, 0, 0, this);

}

public void Aumentar(int Valor_Zoom){

//se calcula el incremento

valEscalaX = (int) (FOTO_tmp.getWidth(this) * escala(Valor_Zoom) );

valEscalaY = (int) (FOTO_tmp.getHeight(this) * escala(Valor_Zoom) );

//se escala la imagen sumado el nuevo incremento

this.FOTO_tmp = FOTO_tmp.getScaledInstance((int) (FOTO_tmp.getWidth(this) + valEscalaX), (int) (FOTO_tmp.getHeight(this) + valEscalaY), Image.SCALE_AREA_AVERAGING);

resize();

}

public void Disminuir(int Valor_Zoom){

valEscalaX = (int) (FOTO_tmp.getWidth(this) * escala(Valor_Zoom) );

valEscalaY = (int) (FOTO_tmp.getHeight(this) * escala(Valor_Zoom) );

this.FOTO_tmp = FOTO_tmp.getScaledInstance((int) (FOTO_tmp.getWidth(this) - valEscalaX), (int) (FOTO_tmp.getHeight(this) - valEscalaY), Image.SCALE_AREA_AVERAGING);

resize();

}

private float escala(int v){

return v/100f;

}

public void Restaurar(){

this.FOTO_tmp = this.FOTO_ORIGINAL;

resize();

}

private void resize(){

this.setSize(FOTO_tmp.getWidth(this),FOTO_tmp.getHeight(this));

}

------------------------------------------------------------------------------------------------------------

package jcimagezoom;

/**

* @web

* @author Mouse

public class Main {

public static void main(String[] args) {

new interfaz().setVisible(true);

}

sábado, 12 de octubre de 2013

UNIDAD 3. GRAFICACION 3D

GRAFICACION 3D.

El término gráficos 3D por computadora (o por ordenador) se refiere a trabajos de arte gráfico que son creados con ayuda de computadoras y programas especiales. En general, el término puede referirse también al proceso de crear dichos gráficos, o el campo de estudio de técnicas y tecnología relacionadas con los gráficos tridimensionales.

Un gráfico 3D difiere de uno bidimensional principalmente por la forma en que ha sido generado. Este tipo de gráficos se originan mediante un proceso de cálculos matemáticos sobre entidades geométricas tridimensionales producidas en un ordenador, y cuyo propósito es conseguir una proyección visual en dos dimensiones para ser mostrada en una pantalla o impresa en papel.

En general, el arte de los gráficos tridimensionales es similar a la escultura o la fotografía, mientras que el arte de los gráficos 2D es análogo a la pintura. En los programas de gráficos por computadora esta distinción es a veces difusa: algunas aplicaciones 2D utilizan técnicas 3D para alcanzar ciertos efectos como iluminación, mientras que algunas aplicaciones 3D primarias hacen uso de técnicas 2D.

------------------------------------------------------------------------------------------------------------

3.1 REPRESENTACION DE OBJETOS EN TRES DIMENSIONES.

La representación de los objetos en tres dimensiones sobre una superficie plana, de manera que ofrezcan una sensación de volumen se llama Perspectiva. Se representan los objetos sobre tres ejes XYZ. En el eje Z, se representa la altura. En el eje Y, se representa la anchura y en el eje X, se representa la longitud.

Los distintos tipos de perspectivas dependen de la inclinación de los planos Los sistema más utilizados son la isométrica, la caballera y la cónica. Estudiaremos en este curso las dos primeras.

Perspectiva Isométrica. En ella los ejes quedan separados por un mismo ángulo (120º). Las medidas siempre se refieren a los tres ejes que tienen su origen en un único punto.

Perspectiva Caballera. En ella los ejes X y Z tienen un ángulo de 90º y el eje Y con respecto a Z tiene una inclinación de 135º. En es te caso las medidas en los ejes X y Z son las reales y las del eje Y tiene un coeficiente de reducción de 0.5.

DIBUJAR EN PERSPECTIVA.........

En ambas perspectivas, el sistema más sencillo es llevar las tres vistas principales sobre los planos formados por los ejes:

Alzado en el plano XZ.

Planta en el plano XY.

Perfil en el plano YZ.

Cada una de las aristas que forman las vistas se prolonga paralelamente al eje que corresponda:

Horizontal paralelo al eje de las X.

Vertical paralelo al eje de las Z.

Profundidad paralelo al eje de las Y.

Transformaciones en OpenGL....

En algunos tutoriales anteriores de OpenGL se han mencionado de manera fragmentaria los conceptos de transformaciones:

· En los “Hola Mundo 3d en OpenGL” y “Hola Complicado Mundo OpenGL-win32” se utilizaron algunas transformaciones de proyección y viewport para ajustar la inicialización de la ventana, pero sin entrar mucho en detalle acerca de su funcionamiento.

· Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
· Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).

· De vista: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.

· Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).

· Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes.

· void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION . Por ahora las más interesantes son MODELVIEW y PROJECTION, las otras se verán en su momento.

· Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma.

· void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación. La operación resultante sería algo así como A’ = A M , donde A es la matriz actual, M es la matriz suministrada y A’ es la nueva matriz que resulta de la operación y que reemplaza a A.

· void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(), con la diferencia que trabaja sobre una matriz en orden X así.

· void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.

· void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.
Estas operaciones afectan directamente las matrices mencionadas anteriormente, debido a que las operaciones de “alto nivel” (trasladar, rotar, escalar) que existen mas adelante se concatenan, es decir su efecto se acumula sobre matriz actual, existen dos operaciones que permiten guardar la matriz actual en una pila y restaurarla cuando sea necesario, estas son:

· void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.

· void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual.

Estas dos operaciones son muy utilizadas, debido a que permiten realizar transformaciones sobre objetos diferentes, manteniendo algunas de las anteriores sin modificar.

Proyección........

Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección, en perspectiva y ortográfica, donde la primera corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.

Ortográfica: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:

glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);

Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far).

Transformaciones ModelView........

Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación. La primera idea que se nos viene a la cabeza en el caso de OpeGL es que todo modelo está formado por primitivas, toda primitiva por puntos y finalmente todo punto por una tripleta de coordenadas XYZ, así que si se cambian las coordenadas todo de ahí hacia arriba se mueve.

void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

Hay que tener en cuenta las siguientes características a la hora de utilizar estas funciones:

· Estas tres operaciones afectan la matriz actual seleccionada, bien sea MODELVIEW o PROJECTION, generalmente para propósitos de rotar objetos dentro de la escena se utiliza la matriz MODELVIEW.
· El eje coordenado de referencia para las operaciones tanto en MODELVIEW como en PROJECTION se denomina “eye coordinates”, que traduce coordenadas de “ojo” o mejor “vista”. Este es un sistema inamovible y en ausencia de cualquier transformación, la “cámara” está situada en (0,0,0) apuntando hacia la dirección Z negativa, con el vector “arriba” en el sentido Y positivo.
· Cada operación que afecta la matriz MODELVIEW crea otro sistema coordenado para los objetos que se dibujen después de realizada la trasformación, dicho sistema difiere del “básico”, es decir de las llamadas coordenadas de vista (eye coordinates) dependiendo de todo el conjunto de transformaciones realizadas desde el momento en que la matriz MODELVIEW dejo de ser la identidad.
· Una consecuencia de lo anterior es que las operaciones no son conmutativas, es decir que un llamado de glRotatef(), seguido de uno de glTranslatef() produce un efecto diferente a llamar las operaciones en orden inverso. Esto se ve mejor ilustrado en el gráfico:
· Es importante aprender a utilizar correctamente glPushMatrix(), glPopMatrix() y otras operaciones que permitan salvar y restaurar estados de matriz, debido a que permiten realizar translaciones y rotaciones especificas para un cierto objeto, sin alterar los otros.

Hardware....

En realidad, el API de ogl está pensado para trabajar bajo el respaldo de un hardware capaz de realizar las operaciones necesarias para el renderizado, pero si no se dispone de ese hardware, estas operaciones se calcularan por medio de un software contra la CPU del sistema. Así que los requerimientos hardware son escasos, aunque cuanto mayor sea las capacidades de la maquina, mayor será el rendimiento de las aplicaciones ogl.

Windows.....

En principio, cualquier versión de windows viene con las librerías necesarias para ejecutar cualquier aplicación que utilice OpenGL. Para el desarrollo de las mismas, el Microsoft Visual Studio, y en particular Visual C++ trae también todo lo necesario. Puedes consegir, además, la última versión de la GLUT en la web de Nate Robins.

Coordenadas oculares......

Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar. Por tanto, estas coordenadas representan un sistema virtual de coordenadas fijo usado como marco de referencia común.

Transformaciones

Las transformaciones son las que hacen posible la proyección de coordenadas 3D sobre superficies 2D. También son las encargadas de mover, rotar y escalar objetos.

El modelador

En esta sección se recogen las transformaciones del observador y del modelado puesto que, como se verá en el apartado, constituyen, al fin y al cabo, la misma transformación.

Transformaciones del observador.....

La transformación del observador es la primera que se aplica a la escena, y se usa para determinar el punto más ventajoso de la escena. Por defecto, el punto de vista está en el origen (0,0,0) mirando en dirección negativa del eje z. La transformación del observador permite colocar y apuntar la cámara donde y hacia donde se quiera.

Transformaciones del modelo

Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena. La apariencia final de los objetos depende en gran medida del orden con el que se hayan aplicado las transformaciones.

Transformaciones de la proyección

La transformación de proyección se aplica a la orientación final del modelador. Esta proyección define el volumen de visualización y establece los planos de trabajo

Los dos tipos de proyección más utilizados son la ortográfica y la perspectiva, que veremos más adelante.

Transformaciones de la vista

En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando.

Matrices

Las matemáticas que hay tras estas transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones de las que se acaba de hablar puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación.

El canal de transformaciones

Para poder llevar a cabo todas las transformaciones de las que se acaba de hablar, deben modificarse dos matrices: la matriz del Modelador y la matriz de Proyección.

La matriz del modelador

La matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas transformado que se está usando para colocar y orientar los objetos.

----------------------------------------------------------------------------------------------------------------------------------

3.2 VISUALIZACION DE OBJETOS........

No cabe duda de que la representación tridimensional del territorio abre nuevas posibilidades en el ámbito geográfico. Pero el 3D por sí solo no está justificado. Las acciones para la navegación por una escena tridimensional son más complejas que las necesarias para la navegación en un plano. Cada aplicación de software ha resuelto de manera distinta, la manera de controlar la elevación, rotación y cabeceo del punto de vista, lo que requiere un aprendizaje por parte del usuario. Además, el tiempo real de las escenas exige más cantidad de recursos, tanto de cálculo como de datos.

La representación tridimensional es conveniente cuando la visualización de una tercera magnitud, típicamente la elevación del terreno, resulta útil para la interpretación de los datos que se quieren mostrar. Se presentan a continuación algunos de los usos más comunes.
GRAFICACION 2D.

GRAFICACION 3D.

PROYECCIONES.....

Existen dos métodos básicos para proyectar objetos tridimensionales sobre una superficie de visión bidimensional. Todos los puntos del objeto pueden proyectarse sobre la superficie a lo largo de líneas paralelas o bien los puntos pueden proyectarse a lo largo de las líneas que convergen hacia una posición denominada centro de proyección. Los dos métodos llamados proyección en paralelo y proyección en perspectiva, respectivamente, se ilustran. En ambos casos, la intersección de una línea de proyección con la superficie de visión determinada las coordenadas del punto proyectado sobre este plano de proyección. Por ahora, se supone que el plano de proyección de visión es el plano z = 0 de un sistema de coordenadas del izquierdo.

PROYECCIÓN EN PARALELO.....

Una proyección en paralelo preserva dimensionar relativas de los objetos y esta es la técnica que se utiliza en dibujo mecánico para producir trazos a escala de los objetos en las dimensiones. Este método sirve para obtener vistas exactas de varios lados de un objeto, pero una proyección en paralelo no ofrece una presentación realista del aspecto de un objeto tridimensional.

Las vistas formadas con proyecciones en paralelo se pueden caracterizar de acuerdo con el angulo que la dirección de proyección forma con el plano de proyección. Cuando la dirección de proyección es perpendicular al plano de proyección, se tiene una proyección ortogonal.Una proyección que no es perpendicular al plano se denomina proyección oblicua.

PROYECCIÓN ORTOGONAL......

La Proyección ortogonal es aquella cuyas rectas proyectantes auxiliares son perpendiculares al plano de proyección (o a la recta de proyección), estableciéndose una relación entre todos los puntos del elemento proyectante con los proyectados.

Existen diferentes tipos:

Vista A: Vista frontal o alzado

Vista B: Vista superior o planta
Vista C: Vista derecha o lateral derecha

Vista D: Vista izquierda o lateral izquierda

Vista E: Vista inferior
Vista F: Vista posterior

Las ecuaciones de transformación parea efectuar una proyección paralela ortogonal son directas.Para cualquier punto (x, y, z), el punto de proyección (Xp, Yp, Zp) sobre la superficie de visión se obtiene como Xp=X, Yp=y, Xp=0.

PROYECCIÓN OBLICUA. .....

Es aquella cuyas rectas proyectantes auxiliares son oblicuas al plano de proyección, estableciéndose una relación entre todos los puntos del elemento proyectante con los proyectados.

Una proyección Oblicua se obtiene proyectando puntos a lo largo de líneas paralelas que no son perpendiculares al plano de proyección. La figura muestra una proyección oblicua de un punto (x, y, z) por una línea de proyección a la posición (xp, Yp).

------------------------------------------------------------------------------------------------------------

3.3 TRANSFORMACIONES TRIDIMENSIONALES.....

MÉTODO DE TRASLACIÓN...

En una representación coordenada homogénea tridimensional, un punto es trasladado (fig.11.1) de la posición (x,y,z) a la posición (x’,y’,z’) con la Operación matricial.

[x´,y´,z´,1]=[x, y, z, 1]

Los parámetros Tx, Ty, Tz, que especifican distancias de traslación para las coordenadas, reciben la asignación de cualquier valor real. La representación matricial de la ecuación 11.1 es equivalente a las tres ecuaciones

x’ =x + Tx, y’ = y + Ty, z’ =z + Tz

Un objetivo se traslada en tres dimensiones transformando cada punto definidor del objeto. La traslación de un objeto representada como un conjunto de superficies poligonales se efectúa trasladando los valores coordenados para cada vértice de cada superficie. El conjunto de posiciones coordenadas trasladadas de los vértices define entonces la nueva posición del objeto.

MÉTODO DE ESCALACIÓN....

Operación matricial.

[x´,y´,z´,1]=[x, y, z, 1]

Los parámetros de escalación Sx, Sy, Sz, se les asigna asignación cualquier valor positivo.
Cuando la transformación 11-3 se aplica para definir puntos en un objeto, el objeto se escala y se desplaza en relación con el origen coordenado.

MÉTODO DE ROTACIÓN.

Para especificar una transformación de rotación de un objeto, se debe designar un eje de rotación (en torno al cual se hará girar el objeto) y la cantidad de rotación angular. En aplicaciones bidimensionales, el eje de rotación siempre es perpendicular al plano xy. En tres dimensiones, un eje de rotación puede tener cualquier orientación espacial.los ejes de rotación más fáciles de manejar son aquellos que son paralelos a los ejes coordenados. Asimismo, podemos valernos de las rotaciones en torno a los tres ejes coordenados con el fin de producir una rotación en torno a cualquier eje de rotación especificado en forma arbitraria.
Las direcciones de rotación positivas en torno a los ejes coordenados son en sentido contrario al del reloj, como se observa a lo largo de la posición positiva de cada eje en dirección del origen.

Operación matricial de rotación en el eje Z
El parámetro Ѳ especifica el ángulo de rotación.

[x´,y´,z´,1]=[x, y, z, 1]

Imagen que muestra la rotación de un objeto en torno al eje Z.

Operación matricial de rotación en el eje X
[x´,y´,z´,1]=[x, y, z, 1]

Operación matricial de rotación en el eje y
[x´,y´,z´,1]=[x, y, z, 1]

REPRESENTACIÓN EN UN GRÁFICA 3D DE LOS TRES MÉTODOS ANTERIORES:

------------------------------------------------------------------------------------------------------------

3.4 LINEAS Y SUPERFICIES CURVAS......

LINEAS..

La recta es una sucesión infinita o continua de puntos a lineados en una sola dirección. Es una de las primitivas gráficas en computación gráfica viene dada por la ecuación y= m.x+b, donde m es la pendiente de la recta y v es el corte con el eje y.

Como los pixeles se grafican en posiciones enteras, la linea trazada solo puede aproximar posiciones de lineas reales entre los puntos extremos especificados.

Una linea recta debe dibujarse como una sucesión de pixeles.

Efecto de escalera que se produce cuando se genera una linea como una serie de pixeles .

TRASFORMAR PRIMITIVAS EN PIXELES

Las coordenadas de los pixeles deben estar lo mas cerca posible de una linea recta real.
Un algoritmo debe cumplir con:

*La secuencia de pixeles debe ser lo mas recta que se pueda.

*Las lineas deben tener el mismo grosor e intensidad sin importar el grado de inclinación.

*Las lineas deben dibujarse lo mas rápido posible.

ALGORITMOS PARA TRAZO DE LINEAS......

ALGORITMO DDA.

El analizador diferencial digital(DDA) es un algoritmo que sirve para calcular posiciones de pixeles a lo largo de una linea, mediante el uso de la ecuación.

∆y=m.∆x

Ecuación básica de la recta y=m.x+b m es la pendiente y v es la intersección con el eje y.

ALGORITMO DE BRESENHAM.

Calcula cual de dos pixeles es el mas cercano a la trayectoria de una linea.

El pixel x(i),y(i) se divide en (xi+1,yi)(xi+1,yi+1) hay que decidir cual pintar calculando la distancia vertical entre el centro de cada pixel y la linea real.

Las posiciones de los pixeles se representan por las áreas rectangulares numeradas.

Sección de una retícula de la pantalla donde se desplegara una linea que pasara por:

(Xi,Yi)

De aquí se tiene y=m(xi+1)+b

Definimos:
d1=y-yi
=m(xi+1)+b-yi

d2=(y1+1)-y
=y1+1-m(xi+1)-b

la diferencia es :

definimos pi como:
donde c es:
obtenemos pi+1 de pi
como:

ATRIBUTOS DE LAS PRIMITIVAS DE SALIDA.....

Estilo de lineas

*Los atributos de estilo de linea determinan la forma en que se desplegara una linea por medio de una rutina de trazo de lineas. Los atributos de linea son su tipo,su anchura y su color.

Tipo de linea

Los atributos de linea incluye las lineas solidas,lineas punteadas con lineas y punteadas.

El método setStrokeStyle permite cambiar el estilo de linea.

Este método acepta los siguientes valores:

a) Graphics.SOLID - linea solida

b) Graphics.DOTTED- linea de puntos

GRAPHICS 2D SETSTROKE......

Un objeto basicstroke contiene información sobre la anchura de la linea, estilo de uniones, estilos finales, y estilo de punteado.Esta información se usa cuando se dibuja una Shape con el método DRAW.

La anchura de linea es la longitud de la linea medida perpendicularmente a su trayectoria. La anchura de la linea se especifica como un valor float en las unidades de coordenadas de usuario, que es equivalente 1/72 pulgadas cuando se utiliza la tranformacion por defecto.

Nota:

Para rellenar o puntear un gráfico primitivo,necesitamos hacer dos llamadas separadas a métodos fill o drawString para rellenar el interior y draw para dibujar el exterior.

Los 3 estilos de linea usados en este ejemplo ancho, estrecho y punteado son ejemplares de:

BasicStroke:

// Sets the Stroke.

...

case 0 : g2.setStroke(new BasicStroke(3.0f)); break;

case 1 : g2.setStroke(new BasicStroke(8.0f)); break;

case 2 : float dash[] = {10.0f};

g2.setStroke(new BasicStroke(3.0f,

BasicStroke.CAP_BUTT,

BasicStroke.JOIN_MITER,

10.0f, dash, 0.0f));

break;

BASICSTROKE SOPORTA 3 ESTILOS DE UNIÓN:

*JOIN_BEVEL
*JOIN_MITER
*JOIN_ROUND

El estilo de finales es la decoración que se aplica cuando un segmento de linea termina.
BASICSTROKE soporta 3 estilos de finalización:*CAP_BUTT
*CAP_ROUND
*CAP_SQUARE

El elemento 0 representa el primer punteado , el elemento 1 el primer espacio , etc. La fase de punteado es un desplazamiento en el patrón de punteado, también especificado en unidades de coordenadas de usuario. La fase de punteado indica que parte del patrón de punteado se aplica al principio de la linea.

PATRÓN DE RELLENO.

Los patrones de relleno están definidos por el atributo Paint en el contexto Graphics2d. Para seleccionar el atributo paint, se crea un ejemplar de un objecto que implemente el interface paint y eso pasa dentro del método Graphics2d setPaint.

ANCHURA DE LINEA.

La implementacion de las opciones de anchura de lineas dependen del tipo de dispositivo de salida que se utilice Una linea ancha en un monitor de vídeo podría trazarse como lineas paralelas adyacentes, mientras que una graficadora de pluma podría requerir cambios de pluma . Como sucede con otros atributos puede usarse como comando de anchura de linea para fijar la anchura regular de la linea.

Color de linea.
Cuando un sistema ofrece sistemas de color (o bien de intensidad) un parámetro que da el indice de color regular se incluye en la lista de valores de atributos del sistema.

Método para cambiar color.
*setColor(int color)
*setColor(int rojo,int verde,int azul)

CONCLUSIÓN............

Graficos 3D

Se llaman gráficos 3D a todos los objetos que se pueden dibujar en un espacio R3: puntos, segmentos, curvas, superficies y varios cuerpos formados por caras poligonales, así como textos y macros.

En una palabra, son gráficos que tienen profundidad y además aportan mucha sensación de realismo.

En los juegos en 3d el personaje que manejamos o cualquier bot se puede mover en los tres ejes cartesianos: x, y , z.

Comparamos por ejemplo el conocido juego Counterstrike con el Mario de antaño, en el primero te puedes mover izquierda, derecha y arriba; en canvio, si lo comparamos con el segundo ves que no te puedes mover en los tres puntos, solo se mueve en lateral (izquierda y derecha). Por eso llegamos a la conclusión que Counterstrike está en tres dimensiones y el juego de Mario en 2d.

La mayoría de juegos 3d han sido modelados mediante polígonos formando una malla y a continuación han sido renderizados.

En la primera imagen se puede apreciar la sensación de profundidad, de este modo llegamos a la conclusión que el gráfico está en 3d como se puede apreciar fácilmente.

Si lo comparamos con la segunda imagen observaremos muchas diferencia, para empezar el fotorrealismo, no tiene el mismo realismo la primera que la segunda; también podemos ver que el personaje de la segunda solo se puede mover de lado.

De esta manera llegamos a la conclusión que es una imagen en 2 dimensiones. (x, y)

3D:

BIBLIOGRAFIA...................

http://graficacionporcomputadora.blogspot.mx/2013/05/34-lineas-y-superficies-curvas_8.html

http://informatica.uv.es/iiguia/AIG/web_teoria/tema3.pdf

http://grafi-ricardo.blogspot.mx/2012/03/la-representacion-de-los-objetos-en.html

Páginas

domingo, 27 de octubre de 2013

4TO. CONGRESO NACIONAL

lunes, 14 de octubre de 2013

PROGRAMAS

sábado, 12 de octubre de 2013

UNIDAD 3. GRAFICACION 3D