domingo, 27 de noviembre de 2011

examen de la unidad 2


//---------------------------------------------------------------------------
#define ROUND(x) ((int)(x+0.5))

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Math.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void TForm1::Inicia()
{
   int grados, cont = 24;
   int Figura[5][2];

   Figura[0][0]= 5;  Figura[0][1]= -5;
   Figura[1][0]= 5;  Figura[1][1]= 20;
   Figura[2][0]= 1;  Figura[2][1]= 1;
   Figura[3][0]= 10; Figura[3][1]= 1;
   Figura[4][0]= 5;  Figura[4][1]= 20;

   Dibujar(Figura);
   grados = 45;
   for(int i = 0;  i < cont; i++)
   {
     Figura[0][0]+= 10; //5;
     Figura[1][0]+= 10; //5;
     Figura[2][0]+= 10; //5;
     Figura[3][0]+= 10; //5;
     Figura[4][0]+= 10; //5;
     Sleep(30);
     Rotar(Figura,grados);
     grados+=25;
   }
   Canvas->Font->Color = clRed;
   Canvas->TextOutA(240,0,"CRASH");
}

//---------------------------------------------------------------------------
void TForm1::Dibujar(int Fig[][2])
{
//SUPONGA: ClientWidth = ClientHeight = 500
   int centroX = ClientWidth/2;
   int centroY = ClientHeight/2;
   int x1,y1,x2,y2;
   x1 = Fig[2][0];
   y1 = Fig[2][1];
   Canvas->Pen->Color = RGB(0,100,130);
   Canvas->MoveTo(x1+centroX, y1+centroY);
   for(int i = 0; i < 5; i++)
   {
      x2 = Fig[i][0];
      y2 = Fig[i][1];
      //Line_DDA(x1+centroX, y1+centroY, x2+centroX, //y2+centroY);

      Canvas->LineTo(x2+centroX, y2+centroY);
      x1 = x2;
      y1 = y2;
   }
}

//---------------------------------------------------------------------------
void TForm1::Rotar(int fig[][2],int grados)
{
   float angulo = grados * M_PI /180.0;
   int FiguraT[5][2];
   float MatT[2][2];

   MatT[0][0]= cos(angulo);         MatT[0][1] = sin(angulo);
   MatT[1][0]= -sin(angulo);        MatT[1][1] = cos(angulo);
   for(int i = 0;i < 5; i++)
   {
      for(int j = 0; j < 2; j++)
      {
          FiguraT[i][j]= 0;
          for(int k = 0; k < 2; k++)
            FiguraT[i][j]+= ROUND(fig[i][k]*MatT[k][j]);
      }
   }
   Dibujar(FiguraT);
}

//---------------------------------------------------------------------------
void __fastcall TForm1::FormClick(TObject *Sender)
{
   Repaint();
   Inicia();

}
//-------------------------

circulo y linea dda


#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::PaintBox1MouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
          Edit2->Text = x2 = X;
          Edit4->Text = y2 = Y;

          if(RadioButton1->Checked)
          {
             PaintBox1->Repaint();
             g->Linea_DDA(x1, y1, x2, y2);

          }

          if(RadioButton2->Checked)
          {
             PaintBox1->Repaint();
             g->Circulo_X_Segmento(xc, yc, x2 - x1);
          }

          if(RadioButton3->Checked)
          {

          }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::PaintBox1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    Edit1->Text = x1 = X;
    Edit3->Text = y1 = Y;

    Edit5->Text = xc = X;
    Edit6->Text = yc = Y;
    Edit7->Text = xc - x1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
                g = new Graficos(PaintBox1->Canvas);

}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton1Click(TObject *Sender)
{
        if(RadioButton1->Checked)
        {
           Edit1->Enabled = true;
           Edit2->Enabled = true;
           Edit3->Enabled = true;
           Edit4->Enabled = true;
           Edit5->Enabled= false;
           Edit6->Enabled = false;
           Edit7->Enabled = false;
           Button1->Enabled = false;
           //Button2->Enabled = false;
           Button3->Enabled = false;
           Button4->Enabled = false;
           Button5->Enabled = false;
           Button6->Enabled = false;
           //Edit8->Enabled = false;
           //Edit9->Enabled = false;
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton2Click(TObject *Sender)
{
        if(RadioButton2->Checked)
        {
           Edit1->Enabled = false;
           Edit2->Enabled = false;
           Edit3->Enabled = false;
           Edit4->Enabled = false;
           Edit5->Enabled= true;
           Edit6->Enabled = true;
           Edit7->Enabled = true;
           Button1->Enabled = false;
           //Button2->Enabled = false;
           Button3->Enabled = false;
           Button4->Enabled = false;
           Button5->Enabled = false;
           Button6->Enabled = false;
           //Edit8->Enabled = false;
           //Edit9->Enabled = false;
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RadioButton3Click(TObject *Sender)
{
        if(RadioButton3->Checked)
        {
           Edit1->Enabled = false;
           Edit2->Enabled = false;
           Edit3->Enabled = false;
           Edit4->Enabled = false;
           Edit5->Enabled= false;
           Edit6->Enabled = false;
           Edit7->Enabled = false;
           Button1->Enabled = true;
           //Button2->Enabled = true;
           Button3->Enabled = true;
           Button4->Enabled = true;
           Button5->Enabled = true;
           Button6->Enabled = true;
           //Edit8->Enabled = true;
           //Edit9->Enabled = true;
        }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
     PaintBox1->Repaint();
     xcW = PaintBox1->ClientWidth/2;
     ycH = PaintBox1->ClientHeight/2;
     g->Espiral_1(xcW, ycH);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
     PaintBox1->Repaint();
     xcW = PaintBox1->ClientWidth/2;
     ycH = PaintBox1->ClientHeight/2;
     g->Espiral_2(xcW, ycH);
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Button5Click(TObject *Sender)
{
     PaintBox1->Repaint();
     xcW = PaintBox1->ClientWidth/2;
     ycH = PaintBox1->ClientHeight/2;
     val = ComboBox1->Text.ToInt();
     g->Efecto_Espiral_1(xcW, ycH, val);
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button6Click(TObject *Sender)
{
     PaintBox1->Repaint();
     xcW = PaintBox1->ClientWidth/2;
     ycH = PaintBox1->ClientHeight/2;
     rad = ComboBox3->Text.ToDouble();
     th = ComboBox2->Text.ToDouble();
     g->Efecto_Espiral_2(xcW, ycH, th, rad);

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
     PaintBox1->Repaint();
     xcW = PaintBox1->ClientWidth/2;
     ycH = PaintBox1->ClientHeight/2;
     val2 = ComboBox4->Text.ToInt();
     radi = ComboBox5->Text.ToDouble();
     g->Efecto_1(xcW, ycH, val2, radi);
}
//---------------------------------------------------------------------------

fractales



#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

//Esta funcion dibujara solo 1 triangulo y entonces empezara la funcion de recursividad a si mismo
void TForm1::drawSierpinski(float x1, float y1, float x2, float y2, float x3, float y3)
{
        //Aqui dibujamos las 3 lineas del triangulo, uniendo los 3 puntos para generar lineas
        this->Canvas->Pen->Color=(TColor)random(65000);
        this->Canvas->MoveTo(x1,y1);
        this->Canvas->LineTo(x2,y2);
        this->Canvas->MoveTo(x2,y2);
        this->Canvas->LineTo(x3,y3);
        this->Canvas->MoveTo(x3,y3);
        this->Canvas->LineTo(x1,y1);
        //Llamamos a la funcion de recursividad y pintara el resto de los tringulos, las 3 esquinas de triangulo son simempre el centro de su posicion
        subTriangle
        (
            1, //Esto representa la primer recursicion
            (x1 + x2) / 2, //coordenada x de la primera esquina
            (y1 + y2) / 2, //coordenada y de la primera esquina
            (x1 + x3) / 2, //coordenada x de la segunda esquina
            (y1 + y3) / 2, //coordenada y de la segunda esquina
            (x2 + x3) / 2, //coordenada x de la tercera esquina
            (y2 + y3) / 2  //coordenada y de la tercera esquina
        );
}
//La funcion de recursividad subtriangulo pintara todo lo que esta dentro del tringulo mayor a este
void TForm1::subTriangle(int n, float x1, float y1, float x2, float y2, float x3, float y3)
{
        Sleep(10);
        //Dibujamos los 3 lados del subtriangulo
        this->Canvas->MoveTo(x1,y1);
        this->Canvas->LineTo(x2,y2);
        this->Canvas->MoveTo(x2,y2);
        this->Canvas->LineTo(x3,y3);
        this->Canvas->MoveTo(x3,y3);
        this->Canvas->LineTo(x1,y1);
        //Llamadas a si mismo 3 veces con nuevas esquinas,pero solo si el actual numero de recurrencias es menor que la profundidad maxima
        if(n < depth)
        {
        //Triangulo mas pequeño #1
           subTriangle
           (
            n+1, //numero de recurrencias para la siguiente llamada con aumento de 1
            (x1 + x2) / 2 + (x2 - x3) / 2, //coordenada x de la primera esquina
            (y1 + y2) / 2 + (y2 - y3) / 2, //coordenada y de la primera esquina
            (x1 + x2) / 2 + (x1 - x3) / 2, //coordenada x de la segunda esquina
            (y1 + y2) / 2 + (y1 - y3) / 2, //coordenada y de la segunda esquina
            (x1 + x2) / 2, //coordendaa x de la tercera esquina
            (y1 + y2) / 2  //coordenada y de la tercera esquina
        );
        //Triangulo mas pequeño #2
        subTriangle
        (
            n+1, //numero de recurrencias para la siguiente llamada con aumento de 1
            (x3 + x2) / 2 + (x2 - x1) / 2,
            (y3 + y2) / 2 + (y2 - y1) / 2,
            (x3 + x2) / 2 + (x3 - x1) / 2,
            (y3 + y2) / 2 + (y3 - y1) / 2,
            (x3 + x2) / 2,
            (y3 + y2) / 2
        );
        //Triangulo mas pequeño #3
        subTriangle
        (
            n+1, //numero de recurrencias para la siguiente llamada con aumento de 1
            (x1 + x3) / 2 + (x3 - x2) / 2,
            (y1 + y3) / 2 + (y3 - y2) / 2,
            (x1 + x3) / 2 + (x1 - x2) / 2,
            (y1 + y3) / 2 + (y1 - y2) / 2,
            (x1 + x3) / 2,
            (y1 + y3) / 2
        );
    }
}




void __fastcall TForm1::Button1Click(TObject *Sender)
{
        this->Repaint();
        Sleep(1);
        Button1->Enabled=false;
        //Llamamos a la función de Sierpinski (funciona con cualquier esquina dentro de la pantalla)
        //Asignamos las coordenadas del tringulo principal "el mas grande"
        drawSierpinski(10, h - 10, w - 10, h - 10, w / 2, 10);
        Button1->Enabled=true;
        Button1->SetFocus();

}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
        depth=7;
        this->ClientWidth=640;
        this->ClientHeight=480;
        w=this->ClientWidth;
        h=this->ClientHeight;    
}
//---------------------------------------------------------------------------

Manipulacion de colores y pixeles

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
     TColor color,r;
     for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
          color= Image1->Canvas->Pixels[i][j];
          r=color & 255;
          Image2->Canvas->Pixels[i][j]=r;

       }
     }

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
    TColor color,r;
     for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
          color= Image1->Canvas->Pixels[i][j];
          r=color & 0xff0000;
          Image2->Canvas->Pixels[i][j]=r;

       }
     }

}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)
{
    TColor color,r;
     for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
          color= Image1->Canvas->Pixels[i][j];
          r=color & 0x000ff00;
          Image2->Canvas->Pixels[i][j]=r;

       }
     }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)
{
     Image2->CleanupInstance();
     for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
Image2->Canvas->Pixels[Image2->Width -i][Image2->Height -j]=Image1->Canvas->Pixels[i][j];

       }
     }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
   Label2->Caption=X ;
    Label4->Caption= Y;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
    Label2->Caption= X;
    Label4->Caption=Y;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Image2MouseMove(TObject *Sender, TShiftState Shift,
      int X, int Y)
{
    //Label2->Caption=X ;
    //Label4->Caption= Y;
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Button5Click(TObject *Sender)
{    Image2->CleanupInstance();
      Image2->Height=Image1->Width -3;
      Image2->Width=Image1->Height-3;
       for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
          Image2->Canvas->Pixels[j][i]=Image1->Canvas->Pixels[i][j];

       }
     }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button6Click(TObject *Sender)
{
     Image2->CleanupInstance();
      /*Image2->Height=Image1->Width -3;
        Image2->Width=Image1->Height-3;
       for(int i=0;i<Image1->Width;i++)
     {
       for(int j=0;j<Image1->Height;j++)
       {
           Image2->Canvas->Pixels[i][j]=Image1->Canvas->Pixels[Image1->Height-j][Image1->Width -i];

       } */ for(int x = 0; x < Image1->Width; x++)
            {
            for(int y =0; y < Image1->Height; y++)
             {
               int w= -1*(x-Image1->Width);
               Image2->Canvas->Pixels[w][y] = Image1->Canvas->Pixels[x][y];
             }
             }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button7Click(TObject *Sender)
{
      TColor pixelColor, Verde;
    for(int y=0; y<Image1->Height; y++)
     for(int x=0; x<Image1->Width; x++)
      {
        pixelColor= Image1->Canvas->Pixels[x][y];
        //Verde = pixelColor & 0x0000FF00;
          Verde = pixelColor | 0x0000FF00;

        Image2->Canvas->Pixels[x][y] ^= Verde;
      }
}

domingo, 11 de septiembre de 2011

Cómo funcionan las pantallas de LCD, LCD de LED y Plasma

Conoce en detalle el proceso de funcionamiento de las pantallas de LCD y Plasma desde el momento en que enciendes la TV hasta la formación de la imagen que ves.


Las pantallas de Plasma, paneles de LCD o TV’s de LCD con panel de LED. Hace un poco menos de 10 años, palabras como esas hacían parte del vocabulario de pocas personas. Hoy en día, en cambio, ellas se transformaron en sinónimo de sueño de consumo para muchas personas que conversan abiertamente sobre sus ventajas y desventajas.

Bajakí ya abordó en diversos artículos las diferencias entre todos los tipos de pantallas, detalles de configuración que debes llevar en consideración a la hora de la compra de un determinado equipo y como identificar el modelo que se adapta mejor a tu estilo y a tus necesidades.
¿Pero alguna vez te preguntaste como es que esos equipos funcionan? ¿Qué diferencia una tecnología de la otra y hace con que una pantalla de Plasma, por ejemplo, presente mayor contraste en relación a otras tecnologías? ¿Qué es lo que ocurre exactamente dentro del equipo a partir del momento en que lo conectas al tomacorriente hasta el momento en que la imagen se forma y llega hasta tus ojos? Prepárate para viajar por dentro de los televisores y conocer la tecnología que está por detrás de las imágenes que ves.
LCD versus Plasma: una antigua discusión


Pantallas de cristal líquido. Es prácticamente imposible no encontrar en tu casa al menos un equipo con un display o visor con esa tecnología. Las pantallas de cristal líquido no están presentes apenas en los televisores, sino también en celulares, relojes, monitores, calculadoras y todo lo que necesite de una pantalla.
Las ventajas de los displays de LCD en relación a los ya casi extintos monitores CRT son muchas. La más perceptible de todas es el tamaño. Aún al inicio del desarrollo de la tecnología, raramente un panel LCD pasaba los 3,5 cm de profundidad, mientras que los televisores convencionales se presentaban en cajas enormes y pesadas.
Cuando los comparamos a los de pantalla de Plasma, los modelos más avanzados pueden presentar un consumo de hasta 60% menor de energía. En el proceso no hay emisión de ningún tipo de onda electromagnética perjudicial a la salud y la durabilidad media puede llegar a 60 mil horas de uso, el equivalente a 2,5 mil días o algo más de 6 años de funcionamiento constante.
Fuente: LG

Aun con tantos puntos positivos, las pantallas de LCD también presentan desventajas, en especial cuando las comparamos con las pantallas de Plasma. Ángulo de visión, tiempo de respuesta y contraste son elementos que a pesar del avance tecnológico, todavía pueden ser fácilmente superados en una competencia directa con el funcionamiento de las pantallas de plasma.

Por sus características de funcionamiento que resultan en un mayor contraste y consecuentemente, una mejor percepción de imagen por parte del usuario, las pantallas de Plasma son la principal preferencia de los aficionados por pantallas inmensas y alto nivel de detalles.
Para entender de forma clara la razón por la cual una tecnología presenta determinados puntos positivos o negativos en relación a la otra, es necesario comprender como se forma la imagen en cada una de ellas. Es justo eso lo que mostraremos en este artículo. Después de eso, con seguridad será más fácil escoger el modelo que más se adapta a tus necesidades.


Primer paso: la televisión recibe las señales de video
Cuando el cine fue presentado al mundo por primera vez, muchos imaginaron que aquellas imágenes en movimiento mostradas en una pantalla no pasaban de trucos de brujería. Hasta ese entonces, nadie había visto nada parecido y comprender conceptos tan abstractos como una “copia del mundo real” era una tarea bastante complicada.
Hoy en día ciertamente nadie más imagina que exista algún tipo de magia negra en acción para que un televisor funcione, Sin embargo, no por eso, comprender el concepto de formación de una imagen es una tarea fácil para quien no trabaja en áreas relacionadas a la tecnología o no tiene tanta afinidad con el tema.
Todo el proceso comienza cuando una señal de video es enviada para el equipo, que llega por medio de un cable externo que puede ser VGA, HDMI, AVI, DVI o cualquier otro dispositivo que permita la transmisión de datos de medio para la TV.


A pesar de que todos tengan la misma función, la forma como eso ocurre es lo que hace con que algunos cables sean más adecuados que otros para determinado tipo de transmisión. Los dos principales factores a ser llevados en consideración, en esa cuestión son: la velocidad de transmisión y la cantidad de datos.
Cuando más moderno sea el cable, mayor será el número de informaciones transmitidas por segundo. De la misma forma, el proceso ocurre más rápido de acuerdo con el cable utilizado. Eso acaba resultando al final del proceso en la posibilidad de envío y recibimiento de imágenes de mayor calidad.
Es justamente por ese motivo, por ejemplo, que los cables HDMI son los más indicados para la transmisión de datos de un Blu-ray Player para la TV, ya que consigue transferir un mayor número de datos y de forma más raída que un cable AVI o DVI. Por eso, recuerda verificar las conexiones disponibles en un equipo antes de comprar un producto.


Segundo paso: descodificar la señal y enviarla para la pantalla
La señal de video acabó de llegar por el cable. No puedes verlo, pero internamente la punta del cable en cuestión está conectada a una tarjeta descodificadora, una especie de tarjeta de video. Ella es la responsable por “leer” las señales de video recibidas, interpretarlas y enviarlas para la pantalla en forma de puntos coloridos. Esos puntos coloridos, también conocidos como píxeles, serán los responsables por componer un cuadro de imagen.
Las especificaciones de una tarjeta de TV son secundarias y difícilmente verás indicado en algún manual de instrucciones o guía de usuario, el modelo de la placa utilizada. Sin embargo, eso no significa que ella no sea importante, sino todo lo contrario.
La calidad de una tarjeta puede ser evaluada de acuerdo con la velocidad de descodificación de los datos y la calidad final que presenta. En esa cuestión, los ítems como tiempo de respuesta y posibilidades de contraste y brillo son los mejores indicadores de desempeño.
Cuanto menor sea el tiempo de respuesta, menos tiempo la tarjeta descodificadora se toma para interpretar las señales recibidas y transformarlas en informaciones de puntos de colores. De la misma forma, opciones de configuración de contraste y brillo son determinadas por la intensidad con que una información es enviada para la pantalla.
Un ejemplo: un punto blanco con el brillo en 100% es diferente a un punto blanco con el brillo en 20 %. La capacidad de enviar a la pantalla decenas de opciones de porcientos de blanco, o cualquier otro color, de forma precisa, determina un nivel de calidad superior o inferior de un equipo.
Es importante resaltar que elementos como contraste y brillo sufren la influencia también de la manera en que los píxeles son formados en la pantalla, diferenciándose en las pantallas de LCD y Plasma. O sea, las señales enviadas por una tarjeta para una pantalla de LCD y Plasma, a pesar de que sean iguales, pueden presentar resultados diferentes. Hablaremos más sobre eso más adelante.


Tercer paso: composición de los píxeles
Una pantalla de TV, no importa si es de Plasma, LED o LCD, está compuesta por píxeles. Los píxeles son pequeños puntos de imagen que sumados componen un cuadro entero y por su vez formando una imagen. Para entender mejor como funciona, vamos a tomar como ejemplo una pantalla de TV con resolución Full HD – 1920x1080 píxeles.
Imagina la pantalla de tu televisor dividida en pequeños cuadros formando líneas y columnas. El primer número, 1920, corresponde al número de líneas en que la pantalla será dividida. Ya el segundo, 1080, corrsponde al número de columnas.
De esa forma puedes imaginar millones de cuadros lado a lado para formar una imagen. Para ser más exacto, en nuestro ejemplo de la pantalla con resolución Full HD son exactos 2.073.600 puntos de colores, o píxeles, para formar un cuadro con la imagen.
O sea, cuando la tarjeta recibe una señal de video, ella envía 2.073.600 informaciones diferentes para la pantalla, una para cada punto específico. Para tener una idea de la velocidad de procesamiento de esas informaciones basta estar atento a la frecuencia.

Un televisor con frecuencia de 120Hz, por ejemplo, exhibe 120 cuadros diferentes de imagen por segundo. Eso significa más de 248 millones de informaciones de datos para píxeles por segundo, números que realmente impresionan ¿no es cierto?
Cada píxel muestra de forma independiente un color. Cuando la resolución es menor la pantalla está compuesta por menos píxeles y consecuentemente, la calidad de la imagen es menos. Lo que ocurre es que los pequeños cuadrados quedan mayores y el usuario comienza a notar de forma consciente que la imagen está hecha de cuadrados.




Para ilustrar ese proceso, basta ver una fotografía de baja resolución. Pega cualquier imagen y aplica sobre ella el mayor zoom posible. Repara que a medida que amplías la imagen, los píxeles se hacen más perceptibles, dando la impresión de pérdida en la calidad de la imagen.
Puedes estar preguntándote: ¿y cómo funciona el proceso durante un upscale o cuando la imagen de la fuente es de menor calidad de lo que la pantalla puede ofrecer? El procedimiento de recibimiento de datos y lectura es el mismo, lo que cambia es la proyección.
El upscale funciona como una especie de relleno inteligente. Él interpreta cuales son los píxeles que no recibieron informaciones de color y basado en los píxeles más próximos, rellena el espacio con píxeles aproximados, minimizando la percepción del usuario y presentando un resultado final de mayor calidad.
El proceso funciona muy bien y deja las imágenes finales con una calidad superior a la fuente original. Sin embargo, por razones obvias, el upscale tiene una calidad inferior a la de una fuente en alta resolución, ya que en vez de píxeles aproximados tenemos píxeles originales con sus variaciones e colores específicos.


Cuarto paso: formación de color en los píxeles
Los tres primeros pasos que presentamos funcionan de la misma manera en cualquier tipo de pantalla.  El recibimiento de datos, la descodificación y la formación de la imagen por píxeles es un proceso idéntico tanto en los televisores de Plasma, LCD y LED.
Lo que diferencia la calidad de una para otra es la forma en que esos datos de color son exhibidos. Para entender mejor las diferencias entre ellos, es necesario conocer de forma detallada el proceso de formación de un píxel, en los tres tipos de pantalla.






Pantallas de Plasma


El proceso de formación de imagen en una pantalla de Plasma es uno de los grandes responsables por su alta tasa de contraste y por eso mismo tal vez sea la mayor diferencia del producto en relación a las pantallas de LCD y LED. Si estás preguntándote cómo es posible que un líquido sea responsable por la formación de imagen, notarás en esta explicación que el funcionamiento es mucho más complejo de lo que puedes imaginar.
En una TV de Plasma, la pantalla que visualizas es en realidad, una combinación de dos planchas de vidrio. Entre esas planchas existen una serie de electrodos que reciben las señales de video descodificados y los exhiben de forma precisa.
Para que los electrodos sean activados y muestren los colores correctos ellos necesitan de Plasma, una sustancia que no está dentro de la pantalla en estado permanente. Sí, es eso mismo. Tu TV de Plasma, cuando está apagada no tiene plasma.
La transformación ocurre dentro de cada uno de los píxeles. Cada pequeño cuadrado es subdividido en tres partes. Cada una de las partes representa un color del perfil RGB, siendo R el rojo, G el verde y B el azul. Todos los colores que visualizas en la pantalla son formados a partir de una combinación entre esos tres colores primarios.
Cada una de esas tres partes dentro del píxel está compuesta por el elemento químico fósforo. Esa sustancia tiene como característica el hecho de emitir luz cuando es bombardeada por rayos ultravioletas. La combinación de los colores y la luz emitida forman un punto de imagen.
Para que esa emisión de luz sea posible es necesario llevar en consideración que además de fósforo, otros dos elementos químicos componen cada subpíxel: el xenón (Xe) y el neón (Ne). Todos ellos están en estado gaseoso.
Cuando un impulso eléctrico  de aproximadamente 30 volts es ejercido sobre todas esas sustancias, ellas se mezclan y se transforman en una especie de líquido. Ese líquido es llamado de plasma. La descarga ocurre en una fracción de segundo y después de la corriente eléctrica, el Plasma se vuelve estable otra vez, regresando al estado gaseoso.
La transformación de los gases en líquido y posteriormente, la transformación del líquido en gas hacen con que los electrodos liberen energía. Esa energía es liberada en forma de rayos ultravioletas, los elementos necesarios por la emisión de luz y consecuente formación de los tres colores primarios.
Son los rayos ultravioletas los que agitan el subpíxel, haciendo con que emita luz en el color específico que está programado para hacer. La intensidad de cada uno de los colores, mezclados forman un único color. Un solo píxel puede reproducir un espectro de hasta 549 millones de colores.
¿Describiendo así, paso a paso, parece algo demorado y trabajoso, no es cierto? Sin embargo, imagina que en un televisor de 120 Hz, ese proceso que ocurre dentro de cada píxel y es repetido cerca de 120 veces por segundo.
Nuestro ejemplo de la tabla con resolución Full HD, es la mezcla del proceso ind
ividual ocurrido en cada uno de los 2.073.600 píxeles que formará un cuadro de imagen. El conjunto de cuadros de imagen, exhibidos sucesivamente, le dará al espectador la impresión de movimiento, formando el video de la manera como lo conocemos.

Pantallas LCD
De forma general, el proceso de formación de una imagen en las pantallas de LCD es el mismo. Existe el envío de una señal de imagen descodificado para los píxeles que a partir de una matriz RGB, forman todo el espectro de colores que podemos visualizar en la pantalla.
Para entender el funcionamiento de las pantallas LCD, necesitamos entender lo que es el cristal líquido, elemento fundamental en la composición del producto. A ejemplo de la pantalla de Plasma, en la LCD dos finas planchas de vidrio son colocadas lado a lado. Entre ellas el espacio es rellenado con una solución de cristal líquido.
El tipo de líquido utilizado en la fabricación de esos productos es bastante específico y tiene como objetivo, funcionar como una especie de cortina, permitiendo o no y regulando la firma con que la luz es difundida a través de él.
¿Estamos acostumbrado a conocer sustancia en los estados sólido, líquido y gaseoso, cierto? Sin embargo, el cristal líquido utilizado en las pantallas puede ser considerado sólido y líquido al mismo tiempo. Parece confuso, pero la explicación es simple.
La sustancia es capaz de mantener sus moléculas con características de los dos estados al mismo tiempo, haciendo con que ella se comporte de diferentes maneras bajo las mismas circunstancias, a pesar de que aparente una forma líquida.
El fenómeno de formación de una imagen comienza también cuando un impulso eléctrico es aplicado sobre cada uno de los píxeles compuestos por cristales líquidos. Al mismo tiempo, una luz no polarizada es emitida al fondo del panel.
La luz, al pasar por el líquido, es polarizada, y puede ser verse de varios colores diferentes. Para ilustrar bien esa cuestión, basta recordar la formación del arcoíris. A la luz del sol cuando incide sobre las gotas de lluvia surge el llamado proceso de refracción.
Ese fenómeno no es nada más que la dispersión que la luz sufre al atravesar una gota de agua. O sea, ella llega con una intensidad y dentro de la gota, modifica su percepción, saliendo del otro lado con un aspecto diferente.
En la naturaleza no hay control de esa variación y por eso, ves un arcoíris con múltiples colores, no todos con la misma intensidad, nitidez  ni brillo  en todos los puntos del cielo. Dentro de la pantalla, los impulsos eléctricos son los responsables por el control del color.

                                                                       Fuente:Wikipedia
1.    Filtro vertical en película polariza la luz cuando entra.
2.    Substrato de vidrio con electrodos de ITO. Las formas de esos electrodos van a determinar lo que aparece en la TV cuando está encendida. Cristales verticales son grabados en la superficie junto con los cristales líquidos, en consonancia con la luz polarizada.
3.    Cristal líquido.
4.    Substrato de vidrio con película de electrodo común ITO con surcos horizontales para alinearse con el filtro horizontal.
5.    Filtro horizontal en película para bloquear o permitir el paso de la luz.
6.    Superficie reflectora para enviarle de nuevo la luz al telespectador.
Cuando la luz de fondo es emitida, ella atraviesa la capa de cristales líquidos y modifica su percepción. Una corriente eléctrica agita las moléculas de cristal, haciendo con que determinadas partes obstruidas y otras pasen por un ángulo diferente.
Cada ángulo corresponde a un color. De esa forma, mezclando los datos recibidos de la tarjeta de video con la refracción de una luz de fondo a través del cristal líquido, el resultado es un punto de color específico que surge dentro de cada píxel.
La proyección de ese color nacida en medio de los cristales líquidos es lo que va a condicionar el color exhibido por un pequeño tubo fluorescente. Para garantizar que el pixel sea integralmente relleno con el mismo color, un panel blanco de difusión se encarga de uniformizar el color.
Ese proceso ocurre decenas de veces por segundo en cada píxel, de acuerdo con la frecuencia del equipo. El resultado de todos los píxeles sumados forma un cuadro de imagen y los cuadros de imágenes exhibidos seguidamente crean la impresión de movimiento.
La composición del color en los paneles de LCD explica la razón por la cual las pantallas de Plasma presentan un nivel de contraste superior. El proceso de formación de imagen en las pantallas de Plasma es químico y proporciona más precisión que el proceso en las pantallas de LCD, que es óptico.

Pantallas de LED
Si analizamos única y exclusivamente el proceso de formación de color en las pantallas LED, veremos que no se diferencia en nada de las pantallas convencionales de LCD. La diferencia está en un refuerzo que auxilia el proceso de exhibir colores más intensos y precisos.
Técnicamente toda vez que no referimos a la “pantalla de LED” estamos hablando de una pantalla de LCD con panel de LED. El término “pantalla de LED” se hizo popular comercialmente para diferenciar un modelo de otro, pero en la práctica, ambos tienen la misma esencia.
La señal de video descodificada es enviada para la pantalla. Cada píxel recibe una información y la luz de fondo, atravesando el cristal líquido, es polarizada formando un punto de color. La gran diferencia está en el auxilio de precisión de color sobrepuesto a la luz emitida.
O sea, sin en las pantallas de LCD una luz común es enviada para atravesar los cristales líquidos y formar un punto de color del otro lado, aquí un panel de LED’s refuerza la formación del color. Así, tenemos por detrás de cada píxel tres minúsculos LED’s en los colores primarios que forman el RGB.
Algunos equipos más modernos llegan a tener cuatro puntos de luz. Además del RGB, un segundo punto rojo refuerza la intensidad del color. El resultado es exactamente la diferencia que las pantallas de LED tienen en relación a las de LCD convencionales: mayor brillo, nitidez, contraste y cantidad de colores.
Descubriendo un fenómeno: el efecto burn-in
Uno de los eventos relacionados a las pantalla de Plasma con mucha frecuencia es el efecto burn-in. Él ocurre cuando la pantalla muestra por un tiempo continuo una misma imagen estática. Al apagar el televisor, es posible notar una especie de “mancha”, marcando la pantalla.
Ese fenómeno no es una exclusividad de las pantallas de Plasma y puede ocurrir también en LCD’s y LED’s. Actualmente, los nuevos productos lanzados en el mercado atenúan significativamente ese efecto, pero eso no significa que estés 100% libre de ese problema.
La exhibición de una imagen estática de forma continua hace con que el fósforo presente en la composición de las pantallas de Plasma asuma una forma modular permanente. En otras palabras, es como se “quemara” el píxel, afectando su capacidad de agitarse y formar nuevos colores.
En las pantallas de LCD y LED, como el proceso químico es menos intenso, la probabilidad del burn-in ocurrir es remota, pero no está descartada. Fenómenos similares como la “quema” de píxeles que puede ocurrir cuando el equipo ultrapasa su vida útil, hacen con que el riesgo exista. Sin embargo, quédate tranquilo, ya que es poco probable que eso ocurra.