Topicos Selectos de Programacion

Ingeniería en Sistemas Computacionales

Salvador Gurrola Velazquez

Salvador.gurrola@yahoo.com.mx

Topicos Selectos de Programacion Aportación de la asignatura al perfil del

egresado Desarrolla sistemas de información, programación de

redes de computadora, sistemas distribuidos, de base y aplicación.

Desarrolla interfaces de software hombre-máquina, máquina-máquina.

Aplica nuevas tecnologías a la solución de problemas de su entorno laboral.

OBJETIVO GENERAL DEL CURSO El estudiante integrará tópicos avanzados de

programación al desarrollo de aplicaciones que requieran multihilo, multimedia, interfaz grafica de usuario y comunicación con puertos.

Topicos Selectos de Programacion Tipos de datos definidos por el

usuario. 1.1 Agregación de datos (struct). 1.2 Uniones de datos (union). 1.3 Registros variantes. 1.4 Tipos de datos enumerados. 1.5 Manejo de bits. 1.6 Campos de bits. 1.7 Operaciones con Bits ( AND, OR, NOT, XOR).

Creación de componentes y librerías dinámicas 2.1 Creación de componentes. 2.2 Creación de librerías dinámicas.

Programación concurrente multihilo.

3.1 Concepto de Hilo.3.2 Comparación de un programa de flujoúnico contra uno de flujo múltiple.3.3 Creación y control de hilos.

3.3.1 Atributos de hilos.3.3.2 Creación e Inicialización dehilos.3.3.3 Arranque de hilos.3.3.4 Manipulación de hilos.3.3.5 Suspensión de hilos.3.3.6 Parada de hilos.

3.4 Sincronización de hilos.3.4.1 Mutex.3.4.2 Semáforos.3.4.3 Barreras (Barrier).

Interfaz Gráfica de Usuario (GUI)4.1 Creación de interfaz gráfica parausuarios.

4.1.1 Librería de interfaz gráfica(API’s).4.1.2 Aplicaciones GUI.

4.2 Computación gráfica.4.2.1 Área de dibujo.4.2.2 Primitivas de dibujo (línea, arco,circulo, colores, rellenos,imágenes).

Topicos Selectos de Programacion Multimedia.

5.1 Introducción a la multimedia. 5.2 Componentes de un sistema multimedia. 5.3 Formatos de archivo multimedia. 5.4 Creación y manipulación de objetos con formatos de archivo gráfico comunes (GIF, TIFF, JPEG, WMF). 5.5 Creación y manipulación de objetos con formatos de animación y video comunes (AVI, QUICKTIME, MPEG, GIF animado). 5.6 Creación y manipulación de objetos con formatos de audio (compresión de sonido, formato MIDI, MP3). 5.7 Integración de los elementos multimedia. 5.8 Interactividad.

Programación de puertos einterrupciones.

6.1 Interrupciones.6.2 Generalidades de los puertos.6.3 Puerto serial y sus variantes.

6.3.1 USB.6.3.2 Infrarrojo.6.3.3 Fire wire.

6.4 Paralelo y sus variantes.6.5 Interrupciones que intervienen en cadapuerto.

6.5.1 Direcciones bases.6.5.2 Registros.

6.6 Envío y recepción de los datos.6.7 Ejemplos de programación entrepuertos y dispositivos.

Topicos Selectos de Programacion Agend

Semana1 Agosto-24 Tipos de datos definidos por el usuario. Semana2 Agosto-31 Semana3 Septiembre-7 Creación de componentes y librerías

dinámicas Semana4 Septiembre-14 Semana5 Septiembre-21 Semana6 Septiembre-28 Programación concurrente multihilo. Semana7 Octubre-5 Semana8 Octubre-12 Semana9 OIctubre-19 Interfaz Gráfica de Usuario (GUI) Semana10 Octubre-26 Semana11 Noviembre-3 Semana12 Noviembre-9 Multimedia. Semana13 Noviembre-16 Semana14 Noviembre-23 Semana15 Noviembre-30 Programación de puertos e interrupciones. Semana16 Diciembre-7 Semana17 Diciembre-14 Examenes de Regularizacion y Extraordinarios

Topicos Selectos de Programacion Evaluación

Asistencia 10% Participación 10% Investigación 20% Creatividad 20% Documentación 20% Proyecto 20%

Topicos Selectos de Programacion Algoritmos

Iterative vs. Recursive approaches Sorting Algorithms (http://www.codeproject.com/KB/recipes/cssorters.aspx)

Programación concurrente multihilo. Demonstration of multi-threading with a distributed control

(http://www.codeproject.com/KB/threads/carmotioncollisionsimulat.aspx) TAM - Threaded Array Manipulator (http://www.codeproject.com/KB/threads/tam.aspx) Smart Thread Pool (http://www.codeproject.com/KB/threads/smartthreadpool.aspx) Process and Module Viewer (http://www.codeproject.com/KB/threads/ProModViewer.aspx

) Work Queue based multi-threading(

http://www.codeproject.com/KB/threads/workqueuethreading.aspx) Real Multi-threading(http://www.codeproject.com/KB/threads/RealMultiThreading.aspx)

Interfaz Gráfica de Usuario (GUI) Photo Album ( http://www.codeproject.com/KB/GDI-plus/etanphotoalbum.aspx) Album Surfer ( http://www.codeproject.com/KB/GDI-plus/Album_Surfer.aspx ) 2D CAD application (

http://www.codeproject.com/KB/GDI-plus/Album_Surfer.aspx) Map component for building GIS applications (

http://www.codeproject.com/KB/graphics/gismap.aspx ) A Simple Photo Publisher Program(

http://www.codeproject.com/KB/graphics/photopublisher.aspx ) Stereoscopy (http://www.codeproject.com/KB/graphics/Stereoscopy.aspx) FractalSnow(http://www.codeproject.com/KB/graphics/fractalsnow.aspx) Invasion(http://www.codeproject.com/KB/directx/invasioncsharp.aspx) Airplane War 0.2(http://www.codeproject.com/KB/directx/warplane.aspx) PhotoUtil(http://www.codeproject.com/KB/GDI-plus/PhotoUtil.aspx)

Games Reversi A Bridge Design Game Learning Draughts/Checkers Sokoban Pro PacSnake Falling Blocks Game Sudoku Game Sliding Puzzle Game Checkers

Multimedia. How to Make Music out of Nothing at All Guitar Tuner Motion Detection Camera Vision Face Detection Speech Recognition A Voice Chat A Text to WAV Converter Hands Gesture Recognition

Programación de puertos e interrupciones. Managed I/O Completion Ports

(IOCP)(http://www.codeproject.com/KB/cs/managediocp.aspx)

I/O Ports Programming (Parallel port)(http://www.codeproject.com/KB/vb/PortAccess.aspx)

Controlling Floppy Drive Stepper Motor via Parallel Port(http://www.codeproject.com/KB/system/floppystepper.aspx)

Detecting Hardware Insertion and/or Removal(http://www.codeproject.com/KB/system/HwDetect.aspx)

How to Prepare a USB Drive for Safe Removal(http://www.codeproject.com/KB/system/RemoveDriveByLetter.aspx)

Bluetooth Simulation in C# with Serial Ports(http://www.codeproject.com/KB/mobile/bth_serial_port.aspx)

MSN Messenger like chat application(http://www.codeproject.com/KB/miscctrl/SimpleMessenger.aspx)

VoIP For You - Full duplex 8bit/8KHz VoIP application(http://www.codeproject.com/KB/IP/VoIP_For_You.aspx)

Topicos Selectos de Programacion FUENTES DE INFORMACIÓN

11. Deitel y Deitel. (1998).

Como programar en Java.

Ed. Prentice Hall.

2. Mitchell will David. (2001).

Java sin errores.

Ed. Mc Graw Hill.

3. Becerril C. Francisco. (1998).

Java a su alcance.

Ed. Mc Graw Hill.

4. Lemay Laura & Perkins Charles L. (1996).

Aprendiendo Java en 21 días.

Ed. Prentice Hall.

5. Smiley John. (2002).

Learn to program with Java.

Ed. Mc Graw Hill.

6. Naughton Patrick . (1996).

The Java Handbook.

Ed. Berkeley, CA: Osborne-McGraw Hill.

7. Schildt Herbert. (2001).The Complete Reference Java 2. Fourth Edition.Ed. McGraw-Hill.

8. Case Bradley Julia & Millspaugh Anita C. Mt. San Antonio College.(2002).

Programming With Java W/CD-ROM.Ed. Mc Graw Hill.

9. Arnow David M. & Weiss Gerald. (2001).Introducción a la programación con Java. Un enfoque orientado aobjetos.Ed. Addison Wesley.

10. Elliotte Rusty Harold (1999).Java I/O O.Ed. O'Reilly & Associates.

11. Scott Oaks and Henry Wong (1999).java Threads, second Edition.Ed. O'Reilly & Associates.

Unidad I Tipos de datos definidos por el usuario.

1.1 Agregación de datos (struct). 1.2 Uniones de datos (union). 1.3 Registros variantes. 1.4 Tipos de datos enumerados. 1.5 Manejo de bits. 1.6 Campos de bits. 1.7 Operaciones con Bits ( AND, OR, NOT, XOR).

COLLECTIONS A collection is a structured data type that stores data and

provides operations for adding data to the collection, removing data from the collection, updating data in the collection, as well as operations for setting and returning the values of different attributes of the collection.

Collections can be broken down into two types: linear and nonlinear. A linear collection is a list of elements where one element follows the

previous element. Elements in a linear collection are normally ordered by position (first, second, third, etc.). In the real world, a grocery list is a good example of a linear collection; in the computer world (which is also real), an array is designed as a linear collection.

Nonlinear collections hold elements that do not have positional order within the collection. An organizational chart is an example of a nonlinear collection, as is a rack of billiard balls. In the computer world, trees, heaps, graphs, and sets are nonlinear collections.

Arrays The most common example of a direct access collection is the array.

We define an array as a collection of elements with the same data type that are directly accessed via an integer index, as illustrated in Figure.

Arrays can be static so that the number of elements specified when the arrayis declared is fixed for the length of the program, or they can be dynamic, where the number of elements can be increased via the ReDim or ReDim Preserve statements.We can use an array to store a linear collection. • Adding new elements to an array is easy since we simply place the new element

in the first free position at the rear of the array. • Inserting an element into an array is not as easy (or efficient), since we will

have to move elements of the array down in order to make room for the inserted element.

• Deleting an element from the end of an array is also efficient, since we can simply remove the value from the last element.

• Deleting an element in any other position is less efficient because, just as with inserting, we will probably have to adjust many array elements up one position to keep the elements in the array contiguous.

One-Dimensional Array Since arrays in C# are implemented as objects, two steps

are needed to obtain one for use in your program. First, you must declare a variable that can refer to an array. Second, you must create an instance of the array by use of new.

type[ ] array-name = new type[size];

int[] sample = new int[10]

int[] sample;

sample = new int[10];

int[] nums;

nums = new int[] { 99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49 };

int[] nums = new int[] { 99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49 };

Multi-Dimensional Array Two-Dimensional Arrays

int[,] table = new int[10, 20];table[3, 5] = 10;

using System;class TwoD {

static void Main() {int t, i;int[,] table = new int[3, 4];

for(t=0; t < 3; ++t) {for(i=0; i < 4; ++i) {table[t,i] = (t*4)+i+1;Console.Write(table[t,i] + " ");

}Console.WriteLine();}

}}

Arrays of Three or More Dimensionstype[,...,] name = new type[size1,size2,...,sizeN];int[,,] multidim = new int[4, 10, 3];multidim[2, 4, 1] = 100;

Multi-Dimensional Array A multidimensional array can be initialized by enclosing each

dimension’s initializer list within its own set of curly braces. For example, the general form of array initialization for a two-dimensional array is shown here:

type[,] array_name = {{ val, val, val, ..., val },{ val, val, val, ..., val },...{ val, val, val, ..., val }}; // Initialize a two-dimensional array.

using System;class Squares {

static void Main() {int[,] sqrs = {{ 1, 1 },{ 2, 4 },{ 3, 9 },{ 4, 16 },{ 5, 25 },};int i, j;for(i=0; i < 5; i++) {

for(j=0; j < 2; j++)Console.Write(sqrs[i,j] + " ");Console.WriteLine();}

}}

String A string is a collection of characters that can be accessed

based on their index, in the same manner we access the elements of an array.

string str = "C# strings are powerful.";

char[] chrs = {'t', 'e', 's', 't'};

string str = new string(chrs);

// Introduce string.

using System;

class StringDemo {static void Main() {

char[] charray = {'A', ' ', 's', 't', 'r', 'i', 'n', 'g', '.' };

string str1 = new string(charray);

string str2 = "Another string.";

Console.WriteLine(str1);

Console.WriteLine(str2);

}

}

Operating on Strings

To obtain the value of an individual character of a string, you simply use an index. For example:

string str = "test";

Console.WriteLine(str[0]);

You can concatenate (join together) two strings using the + operator. For example, this statement:

string str1 = "One";

string str2 = "Two";

string str3 = "Three";

string str4 = str1 + str2 + str3;

Here is a program that demonstrates Substring( ) and the principle of immutable strings:

// Use Substring().

using System;

class SubStr {

static void Main() {

string orgstr = "C# makes strings easy.";

// Construct a substring.

string substr = orgstr.Substring(5, 12);

Operating on Strings // Some string operations.

using System;

class StrOps {

static void Main() {

string str1 = "When it comes to .NET programming, C# is #1.";

string str2 = string.Copy(str1);

string str3 = "C# strings are powerful.";

int result, idx;

Console.WriteLine("Length of str1: " + str1.Length);

// Display str1, one char at a time.

for(int i=0; i < str1.Length; i++)

Console.Write(str1[i]);

Console.WriteLine();

if(str1 == str2)

Console.WriteLine("str1 == str2");

else

Console.WriteLine("str1 != str2");

if(str1 == str3)

Console.WriteLine("str1 == str3");

else

Console.WriteLine("str1 != str3");

result = str1.CompareTo(str3);

if(result == 0)

Console.WriteLine("str1 and str3 are equal");

else if(result < 0)

Console.WriteLine("str1 is less than str3");

else

Console.WriteLine("str1 is greater than str3");

// Assign a new string to str2.

str2 = "One Two Three One";

idx = str2.IndexOf("One");

Console.WriteLine("Index of first occurrence of One: " + idx);

idx = str2.LastIndexOf("One");

Console.WriteLine("Index of last occurrence of One: " + idx);

}

}

Array of Strings // Demonstrate string arrays.

using System;

class StringArrays {

static void Main() {

string[] str = { "This", "is", "a", "test." };

Console.WriteLine("Original array: ");

for(int i=0; i < str.Length; i++)

Console.Write(str[i] + " ");

Console.WriteLine("\n");

// Change a string.

str[1] = "was";

str[3] = "test, too!";

Console.WriteLine("Modified array: ");

for(int i=0; i < str.Length; i++)

Console.Write(str[i] + " ");

}

}

Struct (c# 2008 p108) the struct (also called structures and records in other

languages). A struct is a composite data type that holds data that may consist of many different data types. For example, an employee record consists of employee’ name (a string), salary (an integer), identification number (a string, or an integer), as well as other attributes.

A powerful addition to the C# struct is the ability to define methods for performing operations stored on the data in a struct. This makes a struct somewhat like a class, though you can’t inherit or derive a new type from a structure. The following code demonstrates a simple use of a structure in C#:

Structusing System;

public struct Name {private string fname, mname, lname;

public Name(string first, string middle, string last) {fname = first;

mname = middle;

lname = last;

}

public string firstName {get {

return fname;

}

set {

fname = firstName;

}

}

public string middleName {get {

return mname;

}

set {

mname = middleName;

}

}

public string lastName {

get {

return lname;

}

set {

lname = lastName;

}

}

public override string ToString() {

return (String.Format("{0} {1} {2}", fname, mname, lname));

}

public string Initials() {

return (String.Format("{0}{1}{2}",fname.Substring(0,1), mname.Substring(0,1), lname.Substring(0,1)));

}

}

public class NameTest {

static void Main() {

Name myName = new Name("Michael", "Mason", "McMillan");

string fullName, inits;

fullName = myName.ToString();

inits = myName.Initials();

Console.WriteLine("My name is {0}.", fullName); Console.WriteLine("My initials are {0}.", inits);

}

}

Enumeration (c# 2008 p104) There are many situations in which you might want to have

a variable that can take one of a fixed set of results. For example, you might want to have an orientation type

that can store one of the values north , south , east , or west .

In situations like this, enumerations can be very useful. Enumerations do exactly what you want in this orientation type:

They allow the definition of a type that can take one of a finite set of values that you supply.

What you need to do, then, is create your own enumeration type called orientation that can take one of the four possible values.

List A sequential access collection is a list that stores its elements in

sequential order. We call this type of collection a linear list. Linear lists are not

limited by size when they are created, meaning they are able to expand and contract dynamically.

Items in a linear list are not accessed directly; they are referenced by their position, as shown in Figure.

The first element of a linear list is at the front of the list and the last element is at the rear of the list.

Because there is no direct access to the elements of a linear list, to access anelement you have to traverse through the list until you arrive at the positionof the element you are looking for. Linear list implementations usually allow two methods for traversing a list—in one direction from front to rear, And from both front to rear and rear to front.

Stack A stack is a list where access is restricted to the beginning (or

top) of the list. Items are placed on the list at the top and can only be removed from the top.

For this reason, stacks are known as Last-in, First-out structures. When we add an item to a stack, we call the operation a push. When we remove an item from a stack, we call that operation a

pop. These two stack operations are shown in Figure

Queue A queue is a list where items are added at the rear of the list and

removed from the front of the list. This type of list is known as a First-in, First-out structure. Adding an item to a queue is called an EnQueue, and removing an

item from a queue is called a Dequeue. Queue operations are shown in Figure

Hash Table Hash table, stores a set of data values associated with a key. In a hash table, a special function, called a hash function, takes

one data value and transforms the value (called the key) into an integer index that is used to retrieve the data.

The index is then used to access the data record associated with the key.

This structure is shown in Figure The key to this data record is the employee’s name.

Dictionary A dictionary is made up of a series of key–value

pairs, called associations. This structure is analogous to a word dictionary,

where a word is the key and the word’s definition is the value associated with the key.

The key is an index into the value associated with the key.

Dictionaries are often called associative arrays because of this indexing scheme, though the index does not have to be an integer.

Tree A tree collection looks like an upside-down tree,

with one data element as the root and the other data values hanging below the root as leaves.

The elements of a tree are called nodes, and the elements that are below a particular node are called the node’s children.

A sample tree is shown in Figure

Treepublic void Insert(int i) {

Node newNode = new Node();

newNode.Data = i;

if (root == null)

root = newNode;

else {

Node current = root;

Node parent;

while (true) {

parent = current;

if (i < current.Data) {

current = current.Left;

if (current == null) {

parent.Left = newNode;

break;

}

else {

current = current.Right;

if (current == null) {

parent.Right = newNode;

break;

}

}

}

}

Treepublic void Insert(int i) {

Node newNode = new Node();

newNode.Data = i;

if (root == null)

root = newNode;

else {

Node current = root;

Node parent;

while (true) {

parent = current;

if (i < current.Data) {

current = current.Left;

if (current == null) {

parent.Left = newNode;

break;

}

else {

current = current.Right;

if (current == null) {

parent.Right = newNode;

break;

}

}

}

}

Set A set is a collection of unordered data values

where each value is unique. The list of students in a class is an example of a

set, as is, of course, the integers. Operations that can be performed on sets include

union and intersection. An example of set operations is shown in Figure

Graph A graph is a set of nodes and a set of edges that

connect the nodes. Graphs are used to model situations where each

of the nodes in a graph must be visited, sometimes in a particular order, and the goal is to find the most efficient way to “traverse” the graph.

Graphs are used in logistics and job scheduling and are well studied by computer scientists and mathematicians.

Network A network is a special type of graph where each

of the edges is assigned a weight. The weight is associated with a cost for using

that edge to move from one node to another. Figure depicts a network of cities where the

weights are the miles between the cities (nodes).

The Bitwise Operators

The bitwise operators AND, OR, XOR, and NOT are, respectively, &, |, ^, and ~.

The Bitwise Operators

// Uppercase letters.

using System;

class UpCase {

static void Main() {char ch;for(int i=0; i < 10; i++) {

ch = (char) ('a' + i);Console.Write(ch);// This statement turns off the 6th bit.ch = (char) (ch & 65503); // ch is now uppercaseConsole.Write(ch + " ");

}

}

}

The Bitwise Operators

// Lowercase letters.using System;class LowCase {

static void Main() {char ch;for(int i=0; i < 10; i++) {

ch = (char) ('A' + i);Console.Write(ch);// This statement turns on the 6th bit.ch = (char) (ch | 32); // ch is now lowercaseConsole.Write(ch + " ");}

}

}

The Bitwise Operators

// Demonstrate the XOR.

using System;

class Encode {static void Main() {

string msg = "This is a test";

string encmsg = "";

string decmsg = "";

int key = 88;

Console.Write("Original message: ");

Console.WriteLine(msg);

// Encode the message.

for(int i=0; i < msg.Length; i++)

encmsg = encmsg + (char) (msg[i] ^ key);

Console.Write("Encoded message: ");

Console.WriteLine(encmsg);

// Decode the message.

for(int i=0; i < msg.Length; i++)

decmsg = decmsg + (char) (encmsg[i] ^ key);

Console.Write("Decoded message: ");

Console.WriteLine(decmsg);

}

}

The Bitwise Operators

// Demonstrate the bitwise NOT.

using System;

class NotDemo {

static void Main() {sbyte b = -34;for(int t=128; t > 0; t = t/2) {

if((b & t) != 0) Console.Write("1 ");else Console.Write("0 ");}

Console.WriteLine();// Reverse all bits.b = (sbyte) ~b;for(int t=128; t > 0; t = t/2) {

if((b & t) != 0) Console.Write("1 ");else Console.Write("0 ");

}

}

}

The Bitwise Operators// Demonstrate the shift << and >> operators.

using System;

class ShiftDemo {

static void Main() {

int val = 1;

for(int i = 0; i < 8; i++) {

for(int t=128; t > 0; t = t/2) {

if((val & t) != 0) Console.Write("1 ");

else Console.Write("0 ");

}

Console.WriteLine();

val = val << 1; // left shift

}

Console.WriteLine();

val = 128;

for(int i = 0; i < 8; i++) {

for(int t=128; t > 0; t = t/2) {

if((val & t) != 0) Console.Write("1 ");

else Console.Write("0 ");

}

Console.WriteLine();

val = val >> 1; // right shift

}

}

}

Unidad II Creación de componentes y librerías dinámicas

2.1 Creación de componentes. 2.2 Creación de librerías dinámicas.

COM

What is COM? Simply put, COM is a system API that

allows your application to access the functions and data in another application (EXE) or a dynamically linked library (DLL).

COM actually stands for Component Object Model as an attempt to create an analogy with the hardware inside your computer.

Why Was COM Developed? COM evolved out of the solution to a specific

problem — how to allow a word processor to edit the spread sheet in a letter without the user having to exit the word processor to do it.

This solution was called OLE (Object Linking and Embedding) and contained a very sophisticated API that allows you even today to edit a letter within Internet Explorer using Microsoft Word.

Most of this functionality is found in the OLE32.DLL.

What are the Other Uses of COM? Once the COM API was exposed, Microsoft used it to

create what were then called OLE Controls to allow sophisticated controls (e.g., buttons that spiral, list boxes that play music) written in Visual C++ to be accessible to Visual Basic applications.

Eventually this same technology was used to allow a control to be downloaded and used by your web browser.

At this point, the name changed to ActiveX Controls or just plain ActiveX purely for marketing reasons.

Although you can package any functionality in an ActiveX Control (this is still the only way to create a COM object in VB), its requirements have been specialized for supporting a user interface control.

How Does COM Work? 1. First, you call the ::CoCreateInstance() COM API call,

either directly or through a C++ class that wraps it. You specify two ID’s, one for the class you want to instantiate and one for the DLL or EXE file it lives in. Very unique ID’s are used instead of a class or filename to avoid the problem of having two COM objects with the same names on the same large system.

2. Since the DLL or EXE filename is specified with an ID, COM has to first convert it to an actual DLL or EXE filename by looking in the system registry where it was stored when the DLL/EXE was installed.

3. Now supplied with the actual filename, COM loads up the requested DLL using the LoadLibrary() API call or starts the desired EXE using the RPC (Remote Procedure Call) API.

How Does COM Work? 4. Then COM tells the DLL or EXE which class to instantiate by using

the other ID you specified to ::CoCreateInstance(). Once the DLL or EXE has created an object, ::CoCreateInstance() returns its pointer.

5. If the class lives in a DLL on your own system, calling its methods and passing arguments to it is not unlike any DLL method call using a class pointer, i.e., p->Func(a,b);.

6. If however you’re calling a method on an object that was created in an EXE or on another machine, the arguments you pass to it go through the same serialization process that you would expect between any client and its server over a network — except COM does this for you automatically and almost transparently.

7. Destroying a COM object is a matter of telling the COM API you no longer need it by decrementing a reference count in the object. Once it reaches zero, COM destroys the object.

8. If all of the objects a DLL has supplied to your application are destroyed, COM unloads the DLL. If all of the objects an EXE has supplied any application on your system or the network are destroyed, COM stops the EXE

How Does COM Work?

Guids A GUID is the Microsoft interpretation of the Universally Unique

Identifier (UUID) proposed by the Open Software Foundation (OSF).

A guid is a 128 bit number that is theoretically unique over time and space.

To make it unique over space, it includes a fixed number that identifies the machine it was created on, usually a network card address.

If there is no network card, another equally unique but constant number is located.

To make a guid unique over time, it includes a time stamp of when it was created.

This stamp is the number of minutes that have elapsed since 1490.

And just to be on the safe side, a guid also contains a random number generated just for the occasion.

System Registry COM information can be found in the system registry under

the HKEY_CLASSES_ROOT key which itself points to the information under the HKEY_LOCAL_MACHINE\SOFTWARE\Classes\ key. The majority of the listing you’ll find directly under this key are file extension associations (e.g., .txt is associated with notepad.exe) and COM Program ID’s, but buried in this listing, you’ll also find three other COM subkeys: AppID, CLSID, and Interface.

UserControls (Advanced C# Programming) The UserControl class is a control that contains a drawing

surface, like a form, that allows you to design composite controls in the Forms Designer for Windows Forms and ASP.NET.

When designing UserControls, you perform the same activities that you would perform when designing a form. Drag and drop controls onto the form, generate the event handlers, modify properties, and implement new methods.

The only noteworthy difference between designing forms and UserControls is that forms are generally designed for end users and UserControls are designed for both end users and other developers—that is, your UserControls will appear on forms and in the Toolbox.

The last bit of information suggests that if we want to build reusable UserControls then we need to make them general enough so they are not too dependent on a specific application.

Understanding UserControls

There are three basic strategies for implementing custom controls in C#.

You can inherit from the Control class to have the ultimate flexibility but the most amount of work.

You can implement from a control that is closer to the new one that you want to make, resulting in less flexibility and less work. For instance, if you want to make a label control that has special effects, you could inherit from System.Windows.Forms.Label.

Finally, if you want to make a control that is composed of several visual elements, then the best way to do it is to create a UserControl.

What Is a UserControl?

UserControls are defined in the System.Windows.Forms and System.Web.UI namespaces.

For our purposes, we are referring to the System.Windows.Forms.UserControl.

UserControls inherit from ContainerControl, which in turn inherits from ScrollableControl, which itself inherits from the Control Class.

If you look at the .NET Framework, you will note that this is exactly the same ancestry as a Windows Form.

What Is a UserControl?

When you are designing a UserControl you will perform the same activities that you perform when designing a Form.

Like Forms, UserControls contain other controls referred to as constituent controls.

A UserControl has a graphical user interface, as do Forms, and usually contains many constituent controls to make up part of a whole solution.

GUI

There are several strategies that you can employ when designing the visual aspect of UserControls:

You can get great background graphics and make your controls semi-transparent.

You can get a right-brained person or graphic artist to design some basic visuals for you, and then you can create a standard set of UserControls that you can use over and over again.

You can layer controls to create the effect of both depth and richness, mirroring some of the better-looking software that exists.

Creating a Control Library

The Windows Control Library template in the New Project dialog is a good way to begin building UserControls. The Windows Control Library will yield an assembly with a DLL extension, and the project will be created with a single UserControl.

When you create a Windows Control Library, the output type will be Class Library (read DLL), and the template will add the System, System.Data, System.Drawing, System.Windows.Forms, and System.XML namespace references.

The template will also add AssemblyInfo.cs and UserControl1.cs modules.

The AssemblyInfo file is provided for adding metadata, and the UserControl module contains a class, which inherits from UserControl, that you can use to begin implementing your first UserControl.

Creating a Control Library

A recommended approach to building UserControls at this point is to build the control with a general solution in mind and to use a generic application to test the UserControl.

When the control has the general properties, methods, events, and constituent controls that you have determined are needed, you can incorporate the new UserControl into your application.

Creating a ButtonCluster Control

The ButtonCluster uses four standard Button controls on a UserControl container.

The ButtonCluster control is shown at the center of the form in Figure.

The text on the buttons suggests that clicking a particular button will move the elements in the direction indicated by the arrow.

Creating a ButtonCluster Control

From Figure we can determine that the UserControl is composed of four buttons.

To keep the buttons aligned, we will need to respond to Resize events sent to the UserControl, we will need to modify the Text property for the buttons, and we will need to surface the individual Button Click events in order to allow users to respond to Click events.

Designing the UserControl Visual Interface

The visual appearance of our first user control is composed of four equally-sized buttons lined up in a vertical stack.

To make the control as generic as possible, we might want to allow the buttons to be aligned horizontally.

We may also want to allow the actual buttons to be rendered using other kinds of buttons

To create the button cluster class, create a new Windows Control Library project. Drop four buttons on the UserControl container.

Designing the UserControl Visual Interface

Use the Visual Studio .NET Format | Make Same Size | Both menu to make the buttons the exact same size. (Make the buttons roughly square.)

Use the Format | Align | Centers menu item to align the buttons along a center vertical axis.

Resize the UserControl to approximately the same width as a single button and the height to that of all four buttons (an example can be seen in Figure.

Don’t worry about precise visual sizing, as we will write the code to make the control visually perfect.

The next thing we need to do is write the code to resize each of the buttons proportionately to the size of the containing control.

Implementing the UserControl Resize Event Handler

When the UserControl is resized, we want our buttons to occupy and fully consume exactly one-fourth of the available space. Fortunately, the UserControl can be designed like a form.

To generate the Resize event handler, we can use the Event view of the Properties window.

private void UserControlButtons_Resize(object sender,

System.EventArgs e){ResizeButtons();}

Implementing the UserControl Resize Event Handler Following a good convention, we simply implement the event

handler by calling a wellnamed method. The well-named method mitigates the need for a comment, and

the name indicates precisely what the code will do. As an alternative, we can override the OnResize method. If you choose to override OnResize, make sure you call the base

class method. By convention, .NET uses the On prefix for event methods; hence,

the Resize event would have an OnResize method that invokes it. If you elect to override the OnResize method, then the overridden

method might be implemented as follows:

protected override void OnResize(System.EventArgs e)

{

base.OnResize(e);

ResizeButtons();

}

Determining Equal Subdivisions for the Buttons

Now that we have an event handler, our UserControl is notified when it is resized. From this point, we can implement the code that sizes each button equally.

When we are coding, it is useful to determine when a solution is generic enough to make sense in some other context.

Determining the fractional part of a rectangle is generally useful, and experience suggests that I can reuse this behavior.

When code may be generally useful, it is a good idea to create a new class and implement the behavior in the new class.

The listing implements a Rectangle class that can calculate a new top and new bottom for a rectangle that is a fractional subdivision of a bounding rectangle.

The Rectangles classusing System;

using System.Drawing;

namespace UserControlsExamples

{

public class Rectangles

{private Rectangles(){}public static Rectangle

GetVerticalRectangle(Rectangle rectangle, int index, int

segments ){

Rectangle r = rectangle;r.Size = new Size( r.Width,NewBottom(rectangle, index,

segments));r.Location = new Point(0,NewTop(rectangle, index,

segments));return r;

}

public static int NewTop( Rectangle rectangle,

int index, int segments ){

return (int)((float)index / segments *

rectangle.Height);}

public static int NewBottom( Rectangle rectangle,

int index, int segments){

return rectangle.Height / segments;

}

}

}The class is pretty straightforward: calculate a new top based on the number of subdivisions and the actual division you want, and calculate the bottom by making the height an equal subdivision.

The Program

Now that we have some general methods for determining rectangular subdivisions, we can resize the buttons in the cluster quite easily.

private void Initialize()

{

buttons = new Button[]{buttonAllRight, buttonRight,

buttonLeft, buttonAllLeft};

}

private void ResizeButtons()

{

if( buttons == null ) return;

for( int i=0; i<buttons.Length; i++)

{buttons[i].Bounds = Rectangles.GetVerticalRectangle(this.Bounds, i, buttons.Length);

}

}

The Program

The ButtonCluster class was implemented to store a reference to each button in an array (see the preceding listing).

Storing the buttons in an array field facilitates iterating over each button and invoking the Rectangles.

GetVerticalRectangle method on each rectangle. The argument this. Bounds is the rectangle for the

user control. The index i is used as the rectangular subdivision,

and the Length of the array indicates the number of subdivisions.

This approach actually makes the code quite extensible, since we are not relying on literal values to determine the index or number of buttons.

Surfacing Constituent Events

When it comes to the visual aspects of our button cluster, all we need to do is modify the Text property and we are finished.

For a more refined look, use the Button.Image property and provide a graphic arrow.

Programmatically, however, we are not quite finished.

The purpose of buttons is to respond to Click events.

As the event handler is implemented so far, consumers will not be able to get at the Click events for the buttons contained on this control.

This presents a slightly sticky problem. A solution is that we must surface the events of the

constituent controls.

Promoting Events in Constituent Controls

When you add controls to a UserControl, the new controls are added as fields in the UserControl.

The properties of the controls on the UserControl are encapsulated two layers deep.

Assume you have an instance of a UserControl, userControl1. Further assume that userControl1 contains a Button control.

To get at the Text property of the button, a consumer would have to write some code like userControl1.Button.Text. Counting the number of member-of operators, we know that the Text property is two layers deep.

As a result, the button’s Text property is not going to show up in the Properties window.

Promoting Events in Constituent Controls

Assuming that Button is public, a consumer could programmatically modify the properties of the Button contained in the UserControl.

However, if you want to modify those properties and events in the Properties window, then you will have to surface the properties and events of constituent controls.

We want to enable consumers to write code that responds to the individual button clicks, so we’ll need to surface the Button Click events.

To surface constituent control events, we need to write event handlers for the controls.

Then we need to implement new events in the UserControl. When the constituent control events are raised, we pass the

raised events up to the new UserControl events.

Promoting Events in Constituent Controls1: private void Initialize()

2: {

3: buttons = new Button[]{buttonAllRight, buttonRight,

4: buttonLeft, buttonAllLeft};

5:

6: buttonAllRight.Click += new EventHandler(OnAllRightClick);

7: buttonRight.Click += new EventHandler(OnRightClick);

8: buttonAllLeft.Click += new EventHandler(OnAllLeftClick);

9: buttonLeft.Click += new EventHandler(OnLeftClick);

10: }

11:

12: private bool IsValidIndex(int index)

13: {

14: return (index >= buttons.GetLowerBound(0) &&

15: index <= buttons.GetUpperBound(0));

16: }

17:

18: public Button this[int index]

19: {

20: get

21: {

22: Debug.Assert(IsValidIndex(index));

23: return buttons[index];

24: }

25: }

26:

27: public event EventHandler AllRightClick;

28: public event EventHandler RightClick;

29: public event EventHandler AllLeftClick;

30: public event EventHandler LeftClick;

31:

32: private void OnAllRightClick(object sender, System.EventArgs e)

33: {

34: if(AllRightClick != null)

35: AllRightClick(sender, e);

36: }

37:

38: private void OnRightClick(object sender, System.EventArgs e)

39: {

40: If(RightClick != null)

41: RightClick(sender, e);

42: }

43:

44: private void OnAllLeftClick(object sender, System.EventArgs e)

45: {

46: if(AllLeftClick != null)

47: AllLeftClick(sender, e);

48: }

49:

50: private void OnLeftClick(object sender, System.EventArgs e)

51: {

52: If(LeftClick != null)

53: LeftClick(sender, e);

54: }

Promoting Events in Constituent Controls

Lines 27 through 30 declare four public events. These events will show up in the Event view of the

Properties window as AllRightClick, RightClick, AllLeftClick, and LeftClick.

Consumers can add event handlers to these event properties. Following convention, lines 6 through 9 add private event handlers to the Click event for our constituent button controls.

When the Button Click events are raised, our internal events check to see if consumers have associated event handlers with our public events.

If the UserControl’s public events have handlers assigned to them, then the events are bubbled up to the surface of the UserControl.

Creating a PickList Control

We have the ButtonCluster. We can use it in any application by referencing the DLL assembly that contains the ButtonCluster.

We can also use the ButtonCluster as a control in another UserControl.

By layering complexity, rather than building a single, monolithic control, we end with more individual controls and controls that are easier to manage.

The next control we will build is a UserControl with two ListBox controls and one ButtonCluster.

As the ButtonCluster is a separate UserControl, when we build the PickList control, we are acting as a consumer of the ButtonCluster and only have to focus on the new behavior.

This is clearly simpler than building a monolithic control that defines the Button and ListBox behavior in one class.

Creating a PickList Control

Implement the PickList by creating a new UserControl. Paint two ListBox controls on the UserControl, place a panel in

between, and add a ButtonCluster to the panel. To maintain the relative position of the ListBoxes and the

panel containing the ButtonCluster, change the left ListBox’s Dock property to Left, the right ListBox’s Dock property to Right, and the center panel to Fill.

When the UserControl is resized, the ListBoxes and ButtonClusters will maintain the appearance shown in Figure.

The ButtonCluster’s position can be maintained with the following statement:

buttonCluster1.Location = new Point(panel1.Left + (panel1.Width - buttonCluster1.Width) / 2,panel1.Top + (panel1.Height - buttonCluster1.Height) / 2);

Creating a PickList Control Implement the PickList by creating a new UserControl. Paint two ListBox controls on the UserControl, place a panel in between, and

add a ButtonCluster to the panel. To maintain the relative position of the ListBoxes and the panel containing the

ButtonCluster, change the left ListBox’s Dock property to Left, the right ListBox’s Dock property to Right, and the center panel to Fill.

When the UserControl is resized, the ListBoxes and ButtonClusters will maintain the appearance shown in Figure.

The ButtonCluster’s position can be maintained with the following statement:

buttonCluster1.Location = new Point(

panel1.Left + (panel1.Width - buttonCluster1.Width) / 2,

panel1.Top + (panel1.Height - buttonCluster1.Height) / 2);

The horizontal location of the ButtonCluster is offset from the left edge of the panel by half the difference of the containing panel and the ButtonCluster. The vertical location of the ButtonCluster is offset from the top of the panel by half the difference of the height of the panel and height of the ButtonCluster.

Adding and Removing Elements from ListBoxes

There are four buttons, and we can implement the individual behavior of each button in a handful of ways.

Click the >> (all right) button, and all of the elements are moved from the left list to the right list. The << (all left) button performs the opposite operation.

Click the > (right) button, and only the selected items are moved from the left list to the right, and the < (left) button moves the selected items from the right list to the left list.

Moving items between ListBox controls1: private void SourceToTarget(ListBox.ObjectCollection

source,

2: ListBox.ObjectCollection target)

3: {

4: target.AddRange(source);

5: source.Clear();

6: }

7:

8: private void MoveAllLeft()

9: {

10: SourceToTarget(listBoxRight.Items, listBoxLeft.Items);

11: }

12:

13: private void MoveAllRight()

14: {

15: SourceToTarget(listBoxLeft.Items, listBoxRight.Items);

16: }

17:

18: private void SourceToTarget(ListBox.SelectedObjectCollection

19: source, ListBox.ObjectCollection target)

20: {

21: IEnumerator e = source.GetEnumerator();

22: while(e.MoveNext())

23: {

24: target.Add(e.Current);

25: }

26: }

27:

28: private void RemoveSelected(ListBox listBox)

29: {

30: for( int i=listBox.Items.Count - 1; i>=0; i--)

31: If(listBox.GetSelected(i))

32: listBox.Items.RemoveAt(i);

33: }

34:

35: private void MoveLeft()

36: {

37: SourceToTarget(listBoxRight.SelectedItems,

38: listBoxLeft.Items);

39: RemoveSelected(listBoxRight);

40: }

41:

42: private void MoveRight()

43: {

44: SourceToTarget(listBoxLeft.SelectedItems,

45: listBoxRight.Items);

46: RemoveSelected(listBoxLeft);

47: }

Moving items between ListBox controls MoveAllRight and MoveAllLeft call the SourceToTarget method, which

takes two ListBox.ObjectCollection objects. The lists are transposed according to which direction we are moving

the items. ListBox.ObjectCollection represents all of the items in the list. After we invoke AddRange on line 4, we clear all of the elements in

the source list, line 5. To move only the selected items, we invoke the SourceToTarget

method that takes a ListBox.SelectedObjectCollection as the first argument and a ListBox.ObjectCollection as the second argument.

We transpose the arguments according to the direction we are moving elements.

We copy only selected items by using an enumerator; AddRange is not defined for the ListBox.SelectedObjectCollection.

After we enumerate all selected items and copy the selected items to the target—lines 18 to 26—we invoke RemoveSelected.

RemoveSelected uses an integer, because GetSelected and RemoveAt—lines 31 and 32— are defined to take an integer.

BeginUpdate and EndUpdate Sometimes you will need to move a large number of items into a

ListBox. If you allow the ListBox to update the list view each time you add an

element, the ListBox will take longer to load. To load a large number of items, call ListBox.BeginUpdate before you

begin loading the list, and call ListBox.EndUpdate when you have finished loading the list.

BeginUpdate will prevent the listing from drawing the new items until you call EndUpdate.

The following code fragment demonstrates the technique:listBox1.BeginUpdate();

// load the list. For example, add the code on lines 21 to 25 of listing 3

listBox1.EndUpdate();

Surfacing Constituent Properties Surfacing constituent properties is easier than surfacing constituent events. To surface a property of a control contained in your UserControl, declare a public property

that has the same type as the control’s property you want to surface. Return and set the value of the constituent control’s property in the newly defined

UserControl property. For example, we have defined the AboutBoxInfo UserControl. To allow users to change the PictureBox.Image property, we need to surface the Image

property. Assuming that our PictureBox control were allowed to use the default name, then adding

the next property statement to our user control would suitably surface the constituent image property.

public Image Image

{get

{

return pictureBox1.Image;

}

set

{

pictureBox1.Image = value;

}

}

Defining a Data Bound UserControl

The Control class introduces a DataBindings property that is a ControlBindingsCollection.

You can bind controls to any class that implements the IBindingList, ITypedList, or Ilist interfaces.

The obvious classes are the ArrayList and Hashtable and the ADO.NET DataSet DataTable, DataView, and DataViewManager classes.

Additionally, you can bind to lists of strongly typed objects of the same type.

This means that you can bind controls to arrays of user-defined objects.

Implementing the UserControl Create a UserControl named ContactInformation. Add three Labels and three TextBox controls to ContactInformation.

Change the Text property of the Labels to “First Name:”, “Last Name”, and “Phone Number:”.

Define three public properties named FirstName, LastName, and PhoneNumber.

Define the properties as string types. The completed example is shown in Figure. Use the figure as a visual

guide.

Implementing the UserControlpublic string FirstName

{

get

{

return textBox1.Text;

}

set

{

textBox1.Text = value;

}

}

public string LastName

{

get

{

return textBox2.Text;

}

set

{

textBox2.Text = value;

}

}

public string PhoneNumber

{

get

{

return textBox3.Text;

}

set

{

textBox3.Text = value;

}

}

Implementing the ContactInformation Class1: public class Contacts

2: {

3: private ArrayList items;

4:

5: public Contacts()

6: {

7: items = new ArrayList();

8: }

9:

10: public ArrayList Items

11: {

12: get

13: {

14: return items;

15: }

16: }

17: }

18:

19: public class Contact

20: {

21: private string firstName;

22: private string lastName;

23: private string phoneNumber;

24:

25: public Contact( string firstName, string lastName, string phoneNumber)

26: {

27: his.firstName = firstName;

28: this.lastName = lastName;

29: this.phoneNumber = phoneNumber;

30: }31:32: public string FirstName33: {34: get35: {36: return firstName;37: }38: set39: {40: firstName = value;41: }42: }43:44: public string LastName45: {46: get47: {48: return lastName;49: }50: set51: {52: lastName = value;53: }54: }55:56: public string PhoneNumber57: {58: get59: {60: return phoneNumber;61: }62: set63: {64: phoneNumber = value;65: }66: }67: }

Binding and Navigating1: Contacts c = new Contacts();

2:

3: private void FormDataBound_Load(object sender, System.EventArgs e)

4: {

5: c.Items.Add( new Contact("Paul", "Kimmel", "(517) 555-1212"));

6: c.Items.Add( new Contact("Trevor", "MacDonald", "(517) 555-1212"));

7:

8: contactInformation1.DataBindings.Add(

9: new Binding("FirstName", c.Items, "FirstName"));

10:

11: contactInformation1.DataBindings.Add(

12: new Binding("LastName", c.Items, "LastName"));

13:

14: contactInformation1.DataBindings.Add(

15: new Binding("PhoneNumber", c.Items, "PhoneNumber"));

16: }

17:

18: private void buttonNext_Click(object sender, System.EventArgs e)

19: {

20: ((CurrencyManager)contactInformation1.

21: BindingContext[c.Items]).Position -= 1;

22: }

23:

24: private void buttonPrevious_Click(object sender, System.EventArgs e)

25: {

26: ((CurrencyManager)contactInformation1.

27: BindingContext[c.Items]).Position += 1;

28: }

Custom Painting in UserControls

When you add constituent controls to a custom UserControl, you will have to provide custom painting for the constituent controls in each particular control’s Paint event handler.

Suppose we wanted to make the labels for our ContactInformation UserControl appear embossed. (Embossing is an effect that makes the text appear to have depth.) Using a System.Windows.Forms.

Label control painted on the UserControl, we would need to implement an event handler to handle the Label’s Paint event, as the following code demonstrates:this.label1.Paint += new

System.Windows.Forms.PaintEventHandler(this.label1_Paint);

private void label1_Paint(object sender, System.Windows.Forms.PaintEventArgs e)

{

// Demonstrates text customization

Label l = (sender as Label);

e.Graphics.DrawString(l.Text, l.Font, Brushes.White, new PointF(2,0));

}

Transparent UserControl Background

To allow your custom UserControls to be transparent, you will need to set the control style to support a transparent background. This is easily accomplished by calling the SetStyle method in the UserControl’s constructor, as demonstrated here:

SetStyle(ControlStyles.SupportsTransparentBackColor, true);

Extending UserControls Through Inheritance

You can extend existing UserControls through inheritance. From the Project menu, select Add Inherited Control. The Add New Items dialog will open, with the Inherited User Control template

selected. After you click OK, the Inheritance Picker dialog (Figure ) will be displayed. Select one of the controls from the current solution or browse for an

additional DLL assembly. Add the new behavior and state information, and then compile and test your custom control.

Using BeginUpdate and EndUpdate

If you write code that adds a large number of elements to a ListBox, each added item will force the ListBox to update, incurring the overhead of repainting the list each time an element is added. For big lists, this can result in very poor performance.

Instead, every time you load items to a ListBox (or ComboBox) one element at a time, you can precede loading the items with a call to BeginUpdate and follow the load process with an EndUpdate. You can include a try finally block to ensure that the EndUpdate method is invoked. The code that follows demonstrates loading 100,000 integer objects to a ListBox.private void LoadListBox()

{

listBox1.BeginUpdate();

try

{

for(int i=0; i<100000; i++)

listBox1.Items.Add(i);

}

finally

{

listBox1.EndUpdate();

}

}

Using the ThreadPool to Load a ListBox There are several ways to use threads in .NET. One of the easiest is to use a

thread available in the ThreadPool. The ThreadPool class contains a pool of threads that you can send work to in

the form of a delegate. Define the delegate to perform the work of loading the ListBox and send the

delegate to the ThreadPool.QueueUserWorkItem. Additionally, Windows Forms are not directly thread-safe.

You must call the control’s Invoke method to interact with a Windows Forms control on the same thread on which it was created. 1: private delegate void Add(int i);

2:

3: private void AddItem(int i)

4: {

5: listBox1.Items.Add(i);

6: Application.DoEvents();

7: }

8:

9: private void LoadListBox(object state)

10: {

11: for( int i=0; i<100000; i++)

12: listBox1.Invoke(new Add(AddItem), new object[]{i});

13: }

14:

15: private void Form1_Load(object sender, System.EventArgs e)

16: {

17: System.Threading.ThreadPool.QueueUserWorkItem(

18: new System.Threading.WaitCallback(LoadListBox));

19: }

Using the ThreadPool to Load a ListBox To load the ListBox using the ThreadPool class, we need to complete several

steps. The first step is to define a delegate type that reflects a procedure we will use to

interact with the Form’s thread. Line 1 defines a new delegate, Add, using a method signature that takes an

integer and returns void. In Listing, lines 3 through 7 define a method that will interact with the ListBox

directly. AddItem inserts a single item at a time and calls DoEvents to help flush the

message queue of the Form’s thread. Lines 9 through 13 represent the method that will run on its own thread. LoadListBox takes a single argument, an object. A method that returns void and takes an object has the same signature as a

WaitCallback delegate. LoadListBox iterates through a loop and invokes the AddItem method. We use listBox1.Invoke—Invoke is thread-safe—to ensure that items are actually

added to the list on the same thread that the ListBox lives on. Lines 15 through 19 ask the ThreadPool to perform some work.

ThreadPool .QueueUserWorkItem places work in the form of a WaitCallback delegate in the ThreadPool queue.

The ThreadPool invokes the delegate method using an available Thread or spins up a new one. Either way, we only care that the ThreadPool does its job.

Creating the Rectangle

To ensure that the second time the text is written it is written in the same rectangular region as the original text, we can use the ClientRectangle of the Label itself.

To create a specific text effect, we need to slightly offset the text the second time it is drawn.

A shallow shadow effect can be created by offsetting the text the second time by X–1 and Y–1, where X and Y represent the upper-left position of the ClientRectangle.

Other effects can be created changing the text offset values. Implementing a truly flexible solution means that we

ultimately let the consumer specify the offsetting values. While prototyping, it is sufficient to use literal values.

Auto Documentation Feature1: /// <summary>

2: /// Custom text effects for Windows Forms

3: /// </summary>

4: [ToolboxBitmap(

5: @"EffectsLabel2.bmp")]

6: //[ToolboxBitmap(typeof(Label))]

The three hash mark (///) comments that can be used to generate documentation for your code.

The Tools | Build Comment Web Pages menu option will incorporate comments tagged with three hash marks into HTML help documentation.

Figure shows the comment on line 2 incorporated into the help documentation for the EffectsLabel.

In addition to using the three hash marks for documenting your code, you can use special XML tags to create other documentation features. Table lists the comment tags for generating documentation.

Defining the Category19: [Description("Describes the appearance of the label's text."),

20: Category("Appearance")]

21: public DrawStyle Style

22: {

23: get

24: {

25: return style;

26: }

The Properties window organizes properties either alphabetically or by category.

This is to help consumers find properties at design time. The CategoryAttribute is demonstrated in Line 20

demonstrates the CategoryAttribute. We are indicating that the DrawStyle is categorized as an

Appearance property. If you click the Categorized utton in the Properties window,

then the properties for the selected control will be displayed by category, as shown in Figure

Providing a Description

At the bottom of the Properties window is a description of the selected property.

This value didn’t get there by accident.

The DescriptionAttribute takes a string argument.

The text used to initialize the DescriptionAttribute will be displayed at the bottom of the Properties window unless you deselect the Description context menu item.

Adding a Custom Bitmap for Your Control

If you want your control to have a custom bitmap, then you can apply the ToolboxBitmapAttribute to the class.

This attribute can refer to an external bitmap file or use type information to request an existing icon for an existing control.

[ToolboxBitmap(@"c:\temp\EffectsLabel2.bmp")]

//[ToolboxBitmap(typeof(Label))] The first statement demonstrates how to associate an external bitmap with our

control (see Figure ), and the second (commented) statement demonstrates how to request the type information for the Label control.

If we use the second attribute statement, then our EffectsLabel will have the same icon as the Label control.

To create a custom 16×16 pixel bitmap for the EffectsLabel, you can use the Project | Add New Item menu and add a Bitmap to the solution.

This step will automatically open the Image editor, which will allow you to draw a custom bitmap.

The Image editor works like the Paint program that is provided with Windows.

Testing Your Component An easy way to test your custom control is to add an application to

the solution containing the control. I f the control is a Windows Forms control, then add a Windows

application to the solution. Add a project reference to the control in your Windows application,

and programmatically create and invoke methods that exercise the behavior of your custom control.

Code to test a Windows Forms control can be placed in the Load event handler for a Form.

Implementing Trap Behavior You can verify that all code paths work to some degree by simply exercising

those paths. Exercising a path simply means that you compile and test the code,

providing test data that takes all possible branches within your code. This won’t test your code for all possible states, but it will help you ensure

that there are no obvious, embarrassing defects. A good technique for ensuring that you have exercised all states is to

implement a trap. A trap is a method that is called that halts processing when a code path has

been executed. You can implement a trap simply by calling the Debug. Assert method with the argument False. If you place a trap at each code branch and comment out the traps each

time one is triggered, you have a record verifying that all branches have been tested.

Remove all of the comments to reset the traps if you need to run the tests after your component is updated.

Here is a statement that demonstrates the technique. (This statement assumes that you have included a using statement with the System.Diagnostics namespace in the module containing the trap.) Debug.Assert(false);

Adding the Component to the Toolbox

After you have created your custom control, you will want to incorporate the control into the Toolbox.

This step is accomplished by selecting Tools | Customize Toolbox and browsing to the assembly containing the custom control.

You can add additional tabs to the Toolbox through the Toolbox context menu and drag your controls to their own tabs.

After you have added your control to the Toolbox, you can drag and drop instances of the control to Forms.

When you add a control to your application from the Toolbox, an instance of the control is added to the Form and a reference to the assembly is added to the list of References in the solution.

If you modify your control, then you may need to Reset the Toolbox and re-add the modified assembly to the Toolbox. (If changes to the control do not seem to be reflected in your application, then remove the reference to the control’s assembly and Reset the Toolbox, adding the updated list of assemblies referenced by the Toolbox.)

Creating a Merge Module Thus far we have built and tested a custom control and installed it in our

Toolbox. Suppose you want to distribute your control to other developers. To reliably distribute your control with your applications, you will need to

create a Merge Module Project. Merge Module Projects are defined as template projects in Visual

Studio .NET. The recommended process is to define a Merge Module Project for every custom control and include all of the files, resources, registry entries, and setup logic necessary to install your custom control.

Merge Modules contain version information for a component, ensuring that components are not removed when other application assemblies have dependencies on those components.

For this reason, a new Merge Module should be created for every version of your component after a Merge Module has been added to an Installer file.

Merge Modules cannot be installed directly; a Merge Module must be installed as part of a Windows Installer (.msi) file.

Creating a Merge Module

Follow the numbered steps provided next to add a Merge Module Project to the solution containing the Custom Control, add the output from the CustomControl project to the Merge Module, and create a Windows Installer.1. Select File | Add Project | New Project and select the Merge

Module Project template from the Add New Project dialog. (The Merge Module Project is a template in the Setup and Deployment Projects folder.)

2. Provide a meaningful name for the Merge Module and click OK. (I used CustomControls.msm for the EffectsLabel assembly.)

3. Select the Merge Module Project in the Solution Explorer, and click Project | Add | Project Output to open the Add Project Output Group dialog (shown in Figure 9-5).

4. Repeat step 1. This time, select the Setup Project template.

5. Select the Setup Project in the Solution Explorer, and select Project | Add | Merge Module. The Merge Modules explorer dialog will be displayed. Navigate to the CustomControls.msm Merge Module and click OK.

6. When the Setup Project is compiled, the Windows Installer, setup, and .ini files will be copied or created in the Setup Project folder.

Creating a Merge Module

The primary output from the Setup Project is the setup.msi file.

This file contains the application files, registry settings, dependent files like our CustomControl.dll, and instructions for installing these files.

Creating a Merge Module

The primary output from the Setup Project is the setup.msi file.

This file contains the application files, registry settings, dependent files like our CustomControl.dll, and instructions for installing these files.

DLL’s

DLL Basics

Dynamic-link libraries (DLLs) have been the cornerstone of Microsoft Windows since the first version of the operating system.

All the functions in the Windows API are contained in DLLs. The three most important DLLs are Kernel32.dll, which

contains functions for managing memory, processes, and threads; User32.dll, which contains functions for performing user-interface tasks such as window creation and message sending; and GDI32.dll, which contains functions for drawing graphical images and displaying text.

Windows also comes with several other DLLs that offer functions for performing more specialized tasks.

For example, AdvAPI32.dll contains functions for object security, registry manipulation, and event logging; ComDlg32.dll contains the common dialog boxes (such as File Open and File Save); and ComCtl32.DLL supports all of the common window controls.

Reasons for using DLLs:

They extend the features of an application. Since DLLs can be dynamically loaded into a process's address space, an application can determine at run time what actions to perform and then load the code to execute those actions on demand. For example, a DLL is useful when one company creates a product and wants to allow other companies to extend or enhance the product.

They can be written in many programming languages. You can choose the best language for the job at hand. Perhaps your application's user interface is best programmed with Microsoft Visual Basic, but the business logic is better handled by C++. The system allows a Visual Basic program to load a C++ DLL, a Cobol DLL, a Fortran DLL, and so on.

They simplify project management. If different groups work on different modules during the development process, the project is easier to manage.

Reasons for using DLLs:

They help conserve memory. If two or more applications use the same DLL, the DLL has its pages in RAM once and the pages are shared by all of the applications. The C/C++ run-time library is a perfect example. Many applications use this library. If all these applications link to the static library, the code for functions such as sprintf, strcpy, malloc, and so on exist in memory multiple times. However, if all these applications link to the DLL C/C++ run-time library, the code for these functions is in memory only once, which means that memory is used more efficiently.

They facilitate resource sharing. DLLs can contain resources such as dialog box templates, strings, icons, and bitmaps. Multiple applications can use DLLs to share these resources.

They facilitate localization. Applications frequently use DLLs to localize themselves. For example, an application that contains only code and no user interface components can load the DLL containing localized user interface components.

Reasons for using DLLs:

They help resolve platform differences. The various versions of Windows offer different functions. Frequently, developers want to call new functions if they exist on the host version. However, if your source code contains a call to a new function and your application is about to run on a version of Windows that doesn't offer that function, the operating system loader will refuse to run your process.

They can serve special purposes. You can extend Windows Explorer's shell by creating COM objects that must live inside a DLL. The same is true for ActiveX controls that can be loaded by a Web browser to create rich Web pages.

DLLs and a Process's Address Space

It is often easier to create a DLL than to create an application because a DLL usually consists of a set of autonomous functions that any application can use.

There is usually no support code for processing message loops or creating windows within DLLs.

A DLL is simply a set of source code modules, with each module containing a set of functions that an application (executable file) or another DLL will call.

After all the source code files have been compiled, they are linked by the linker just as an application's executable file would be.

However, for a DLL you must specify the /DLL switch to the linker.

This switch causes the linker to emit slightly different information into the resulting DLL file image so that the operating system loader recognizes the file image as a DLL rather than an application.

DLLs and a Process's Address Space

Before an application (or another DLL) can call functions in a DLL, the DLL's file image must be mapped into the calling process's address space.

Once a DLL's file image is mapped into the calling process's address space, the DLL's functions are available to all the threads running within the process.

In fact, the DLL loses almost all of its identity as a DLL: To the threads in the process, the DLL's code and data

simply look like additional code and data that happen to be in the process's address space.

When a thread calls a DLL function, the DLL function looks at the thread's stack to retrieve its passed parameters and uses the thread's stack for any local variables that it needs.

In addition, any objects created by code in the DLL's functions are owned by the calling thread or process—a DLL never owns anything.

Building a DLL requires the following steps:

You must first create a header file, which contains the function prototypes, structures, and symbols that you want to export from the DLL.

You create the C/C++ source code module (or modules) that implements the functions and variables that you want in the DLL module. Since these source code modules are not required to build an executable module, the DLL company's source code can remain a company secret.

Building the DLL module causes the compiler to process each source code module, producing an .obj module (one .obj module per source code module).

Building a DLL requires the following steps:

After all of the .obj modules are created, the linker combines the contents of all the .obj modules and produces a single DLL image file. This image file (or module) contains all the binary code and global/static data variables for the DLL. This file is required in order to execute the executable module.

If the linker detects that the DLL's source code module exports at least one function or variable, the linker also produces a single .lib file. This .lib file is small because it contains no functions or variables. It simply lists all the exported function and variable symbol names. This file is required in order to build the executable module.

Once you build the DLL module, you can build the executable module. These steps are:

In all of the source modules that reference functions, variables, data structures, or symbols, you must include the header file created by the DLL developer.

You create the C/C++ source code module (or modules) that implements the functions and variables that you want in the executable module. The code can, of course, reference functions and variables defined in the DLL's header file.

Building the executable module causes the compiler to process each source code module, producing an .obj module (one .obj module per source code module).

After all of the .obj modules are created, the linker combines the contents of all the .obj modules and produces a single executable image file. This image file (or module) contains all the binary code and global/static data variables for the executable. The executable module also contains an import section that lists all the DLL module names required by this executable. In addition, for each DLL name listed, the section indicates which function and variable symbols are referenced by the executable's binary code. The operating system loader parses the import section, as you'll see in a moment.

Once the DLL and the executable modules are built, a process can execute. When you attempt to run the executable module, the operating system's loader performs the following steps:

The loader creates a virtual address space for the new process. The executable module is mapped into the new process's address space. The loader parses the executable module's import section. For every DLL name listed in the section, the loader locates the DLL module on the user's system and maps that DLL into the process's address space. Note that since a DLL module can import functions and variables from another DLL module, a DLL module might have its own import section. To fully initialize a process, the loader parses every module's import section and maps all required DLL modules into the process's address space. As you can see, initializing a process can be time consuming.

Unidad III Programación concurrente multihilo. Programación concurrente multihilo.

3.1 Concepto de Hilo. 3.2 Comparación de un programa de flujo único contra uno de flujo múltiple. 3.3 Creación y control de hilos.

3.3.1 Atributos de hilos. 3.3.2 Creación e Inicialización de hilos. 3.3.3 Arranque de hilos. 3.3.4 Manipulación de hilos. 3.3.5 Suspensión de hilos. 3.3.6 Parada de hilos.

3.4 Sincronización de hilos. 3.4.1 Mutex. 3.4.2 Semáforos. 3.4.3 Barreras (Barrier).

What are Processes When a user starts an Application, memory and a

whole host of resources are allocated for the Application.

The pysichal seperation of this memory and resources is called a Process.

An Application may launch more than 1 Process. Its important to note that Applications and

Processes are not the same thing at all. Each Process has an execution sequence used by

the computers CPU. This execution sequence is known as a Thread.

Multithreaded Processes What happens if we need our Process to do more

than 1 thing, like query a web service and write to a database at the same time.

Luckily we can split a Process to share the time slice allocated to it.

This is done by spawning new threads in the current Process.

These extra threads are sometimes called worker threads.

These worker threads share the processes memory space that is isolated from all other Processes on the system.

The concept of spawning new threads within the same process is called free threading.

Apartment threading Each new thread is started in its own process and

is granted its own data, so threads couldn't share data

With this model each time you want to do some background work it happens in its own process, so was known as Out Of Process.

Free threading Free threading we can get the CPU to execute an

additional thread using the same process data. This is much better than single threaded

apartments, as we get all the added benifits of extra threads with the ability to share the same Process data.

NOTE : Only one thread actually runs on the CPU at one time.

Thread Local Storage When a threads time slice has expired it doesnt

just stop and wait its turn. Recall that a CPU can only run 1 thread at a time,

so the current thread needs to be replaced with the next thread to get some CPU time.

Before that happens the current thread needs to store its state information to allow it to execute properly again.

This is what the TLS is all about. One of the registers stored in the TLS is the

program counter, which tells the thread which instruction to execute next.

AppDomains Microsoft also introduced 1 extra layer of abstraction/isolation called an

AppDomain. The AppDomain is not a physical isolation, but rather a logic isolation within

the Process. Since more than 1 AppDomain can exist in Process we get some benifits. For example until we had an AppDomain Processes that needed to access

each others data had to use a Proxy, which introduced extra code and overhead.

By using a AppDomain it is possible to launch several applications within the same Process.

The same sort of isolation that exists with Processes is also available for AppDomain.

Threads can execure across application domains without the overhead of inter process communication.

This is all encapsulated within the AppDomain class. Any time a namespace is loaded in an application it is loaded into an

AppDomain. The AppDomain used will be the same as the calling code unless otherwise

specified. AppDomain may or may not contain threads, which is different to Processes.

AppDomains

Thread Priorities Just as in real life we as human have priorities, so to do Threads. A programmer can decide a priority for their Thread, but ultimately its up

the recipient to decide what should be acted upon now, and what can wait. Windows uses a priority system from 0-31 where 31 is the higest. Anything higher than 15 needs to be done via an Administrator. Threads that have priority between 16-31 are considered real time and will

pre-empt lower priority level threads. Think about drivers/input devices and things like this, these will be running

with priorities between 16-31.

Lifecyle Of Threads The following figure illustrates the most common thread states, and what

happens to move a thread into each state

Lifecyle Of Threads Here a list of all the available thread states

Starting Threads The simplest way to create a thread is to create a new

instance of the Thread class. The Thread constructor takes a single argument: a delegate

instance. The CLR provides the ThreadStart delegate class specifically

for this purpose, which points to a method you designate. This allows you to construct a thread and to say to it, “When

you start, run this method.” The ThreadStart delegate declaration is:

public delegate void ThreadStart( ); As you can see, the method you attach to this delegate

must take no parameters and must return void. Thus, you might create a new thread like this:

Thread myThread = new Thread( new ThreadStart(myFunc) );

myFunc must be a method that takes no parameters and returns void.

Starting Threads For example, you might create two worker threads, one that

counts up from zero: public void Incrementer( )

{

for (int i =0;i<10;i++) {

Console.WriteLine("Incrementer: {0}", i); }

}

and one that counts down from 10:public void Decrementer( )

{

for (int i = 10;i>=0;i--)

{

Console.WriteLine("Decrementer: {0}", i);

}

}

Starting Threads To run these in threads, create two new threads, each

initialized with a ThreadStart delegate. These in turn would be initialized to the respective member

functions: Thread t1 = new Thread( new ThreadStart(Incrementer) );

Thread t2 = new Thread( new ThreadStart(Decrementer) ); Instantiating these threads does not start them running. To do so you must call the Start method on the Thread

object itself: t1.Start( ); t2.Start( );

Starting Threadsnamespace Programming_CSharp

{

using System;

using System.Threading;

class Tester

{

static void Main( )

{

// make an instance of this class

Tester t = new Tester( );

// run outside static Main

t.DoTest( );

} public void DoTest( )

{

// create a thread for the Incrementer

// pass in a ThreadStart delegate

// with the address of Incrementer

Thread t1 = new Thread( new ThreadStart(Incrementer) );

// create a thread for the Decrementer

// pass in a ThreadStart delegate

// with the address of Decrementer

Thread t2 = new Thread( new ThreadStart(Decrementer) );

// start the threads

t1.Start( );

t2.Start( );

}

// demo function, counts up to 1K

public void Incrementer( )

{

for (int i =0;i<1000;i++)

{

Console.WriteLine( "Incrementer: {0}", i);

}

}

// demo function, counts down from 1k

public void Decrementer( )

{

for (int i = 1000;i>=0;i--)

{

Console.WriteLine( "Decrementer: {0}", i);

}

}

}

}

Joining Threads The Join method (without any parameters) blocks the calling

thread until the current thread is terminated. It should be noted that the caller will block indefinitely if the

current thread does not terminate. If the thread has already terminated when Join method is called,

the method returns immediately. The Join method has an override, which lets you set the number of

milliseconds to wait on the thread to finish. If thread has not finished when the timer expires, Join exits and

returns control to the calling thread (and the joined thread continues to execute).

This method is quite useful if one thread depends on another thread.

Joining Threads When you tell a thread to stop processing and wait until a second

thread completes its work, you are said to be joining the first thread to the second.

It is as if you tied the tip of the first thread on to the tail of the second—hence "joining" them. To join thread 1 (t1) onto thread 2 (t2), write:

t2.Join( );

If this statement is executed in a method in thread t1, t1 will halt and wait until t2 completes and exits.

For example, we might ask the thread in which Main( ) executes to wait for all our other threads to end before it writes its concluding message.

In this next code snippet, assume you've created a collection of threads named myThreads.

Iterate over the collection, joining the current thread to each thread in the collection in turn: foreach (Thread myThread in myThreads)

{

myThread.Join( );

}

Console.WriteLine("All my threads are done.");

Sleep The static Thread.Sleep method available on the

Thread class is fairly simple, it simply Suspends the current thread for a specified time.

Consider the following example, where 2 threads are started that run 2 seperate counter methods, the 1st thread (T1) counts from 0-50 and the 2nd thread (T2) counts from 51-100.

Thread T1 will go to sleep for 1 second when it reaches 10, and thread T2 will go to sleep for 5 seconds when it reaches 70.

Suspending Threads At times, you want to suspend your thread for a short while. You might, for example, like your clock thread to suspend for

about a second in between testing the system time. This lets you display the new time about once a second without

devoting hundreds of millions of machine cycles to the effort. The Thread class offers a public static method, Sleep, for just this

purpose. The method is overloaded; one version takes an int, the other a

timeSpan object. Each represents the number of milliseconds you want the thread suspended for, expressed either as an int (e.g., 2000 = 2000 milliseconds or 2 seconds) or as a timeSpan.

To cause your thread to sleep for one second, you can invoke the static method of Thread. Sleep, which suspends the thread in which it is invoked: Thread.Sleep(1000);

Interrupt

When a thread is put to sleep, the thread goes into the WaitSleepJoin state.

If the thread is in this state it may be placed back in the scheduling queue by the use of the Interrupt method.

Calling Interrupt when a thread is in the WaitSleepJoin state will cause a ThreadInterruptedException to be thrown, so any code that is written needs to catch this.

If this thread is not currently blocked in a wait, sleep, or join state, it will be interrupted when it next begins to block.

Interrupts Processes don't need to know about each other to be scheduled

correctly. That's really the job of the operation system, even OS have a main

thread sometimes called the system thread, which schedules all other threads.

It does this by using interrupts. An interrupt is a mechanism that causes the normal execution flow

to branch somewhere else in the computer memory without the knowledge of the execution program. the OS determines how much time the thread has to execute and places and places an instruction in the current threads execution sequence.

Since the interrupt is within the instruction set its a software interrupt, which isn't the same as a hardware interrupt.

Interrupts are a feature used in all but the simplest microprocessors to allow hardware devices to request attention.

When an interrupt is received, a microprocessor will temporarily suspend execution of the code it was running and jump to a special program called an interrupt handler.

The interrupt handler will typically service the device needing attention and then return to the previously-executing code.

Thread Sleep And Clock Interrupts A thread may decide to yield its CPU time to wait for a resource,

but this could be 10 or 20 minutes, so the programmer may choose to make the thread sleep, which results in the thread being packed in the TLS.

But it doesn't go to the run able queue it goes to a sleep queue. In order for threads in the sleep queue to run again they need a

different kind of interrupt, called a clock interrupt. When a thread enters the sleep queue a new clock interrupt is

scheduled for the time that the thread when the thread should be awoken.

When a clock interrupt occurs that matches an entry on the sleep queue the thread is moved back to the runnable queue.

Abort

A blocked thread can also be forcibly released via its Abort method.

This has an effect similar to calling Interrupt, except that a ThreadAbortException is thrown instead of a ThreadInterruptedException.

Furthermore, the exception will be re-thrown at the end of the catch block (in an attempt to terminate the thread for good) unless Thread.

ResetAbort is called within the catch block. In the interim, the thread has a ThreadState of

AbortRequested. The big difference, though, between Interrupt and Abort, is

what happens when it's called on a thread that is not blocked.

While Interrupt waits until the thread next blocks before doing anything,

Abort throws an exception on the thread right where it's executing – maybe not even in your code.

Aborting a non-blocked thread can have significant consequences"

Killing Threads

Typically, threads die after running their course. You can, however, ask a thread to kill itself by calling its Abort( ) method.

You might wish to kill a thread in reaction to an event, such as the user pressing the Cancel button.

t1.Abort( );

Synchronization Three synchronization mechanisms:

the Interlock class, the C# lock statement, and the Monitor class.

Wait Handles

Allows threads to wait on a particular WaitHandle, and only proceed when the WaitHandle tells the waiting thread it is ok to proceed.

This mechanism is know as signalling and waiting.

When a thread is waiting on a WaitHandle it is blocked until such a time that the WaitHandle is signalled, which allows the waiting thread to be unblocked and proceed with its work.

Wait Handles

Wait Handles

Wait Handles The following classes are provided for us System.Threading.WaitHandle

System.Threading.EventWaitHandle

System.Threading.Mutex

System.Threading.Semaphore

As can be seen in this heirachy,

System.Threading.WaitHandle is the base class for a bunch of other

System.Threading.WaitHandle derived classes.

SignalAndWait

There are several overloads for this method, but the basic idea is that one System.Threading.WaitHandle will be signalled whilst another System.Threading.WaitHandle will be waited on to receive a signal.

WaitAll (Static method on WaitHandle)

There are several overloads for this method, but the basic idea is that an array of System.Threading.WaitHandles is passed into to the WaitAll method, and ALL of these System.Threading.WaitHandle will be waited on to receive a signal.

WaitAny (Static method on WaitHandle)

There are several overloads for this method, but the basic idea is that an array of System.Threading.WaitHandles is passed into to the WaitAny method, and ANY of these System.Threading.WaitHandle will be waited on to receive a signal.

WaitOne

There are several overloads for this method, but the basic idea is the current System.Threading.WaitHandle will be waited on to receive a signal.

Let us now concentrate on System.Threading.EventWaitHandle

EventWaitHandle

The EventWaitHandle is a WaitHandle and has 2 more specific classes, ManualResetEvent and AutoResetEvent, that inherit from it that are used more commonly.

As such it is these 2 sub classes that I will spend time discussing. All that you need to note is that an EventWaitHandle object, is able to act just like either of its subclasses by using one of the 2 EventResetMode Enumeration values which may be used when constructing a new EventWaitHandle object.

AutoResetEvent "A thread waits for a signal by calling WaitOne on

the AutoResetEvent. If the AutoResetEvent is in the nonsignaled state, the thread blocks, waiting for the thread that currently controls the resource to signal that the resource is available by calling Set.

Calling Set signals AutoResetEvent to release a waiting thread. AutoResetEvent remains signaled until a single waiting thread is released, and then automatically returns to the non-signaled state. If no threads are waiting, the state remains signaled indefinitely."

In lamens terms when using a AutoResetEvent, when the AutoResetEvent is set to signalled, the first thread that stops blocking (stop waiting) will cause the AutoResetEvent to be put into a reset state. Such that any other threads that are waiting on the AutoResetEvent MUST wiat for it to be signalled again.

ManualResetEvent "When a thread begins an activity that must

complete before other threads proceed, it calls Reset to put ManualResetEvent in the non-signaled state. This thread can be thought of as controlling the ManualResetEvent. Threads that call WaitOne on the ManualResetEvent will block, awaiting the signal. When the controlling thread completes the activity, it calls Set to signal that the waiting threads can proceed. All waiting threads are released.

Once it has been signaled, ManualResetEvent remains signaled until it is manually reset. That is, calls to WaitOne return immediately."

Semaphores A Semaphore inherits from

System.Threading.WaitHandle, as such it has the WaitOne() method. You are also able to use the static System.Threading.WaitHandle, WaitAny(), WaitAll(), SignalAndWait() methods for more complex tasks.

Mutex A Mutex works in much the same way as lock

statement. But the main advantage the Mutex has over lock statements and the Monitor object, is that is can work across multiple processes, which provides a computer wide lock rather than application wide.

Synchronization The Interlock class,

Incrementing and decrementing a value is such a common programming pattern, and one which so often needs synchronization protection, that C# offers a special class, Interlocked, just for this purpose.

Interlocked has two methods, Increment and Decrement, which not only increment or decrement a value, but also do so under synchronization control. public void Incrementer( )

{

try

{

while (counter < 1000)

{

int temp = Interlocked.Increment(ref counter);

// simulate some work in this method

Thread.Sleep(1);

// assign the decremented value

// and display the results

Console.WriteLine( "Thread {0}. Incrementer: {1}", Thread.CurrentThread.Name, temp);

}

}

}

Synchronization Using Locks

Although the Interlocked object is fine if you want to increment or decrement a value, there will be times when you want to control access to other objects as well. What is needed is a more general synchronization mechanism. This is provided by the .NET Lock object.

A lock marks a critical section of your code, providing synchronization to an object you designate while the lock is in effect. The syntax of using a Lock is to request a lock on an object and then to execute a statement or block of statements. The lock is removed at the end of the statement block.

C# provides direct support for locks through the lock keyword. Pass in a reference object and follow the keyword with a statement block:public void Incrementer( )

Synchronizationpublic void Incrementer( )

{

try

{

while (counter < 1000)

{

int temp;

lock (this)

{

temp = counter; temp ++;

Thread.Sleep(1);

counter = temp;

}

// assign the decremented value

// and display the results

Console.WriteLine( "Thread {0}. Incrementer: {1}", Thread.CurrentThread.Name, temp);

}

}

}

Synchronization Using Monitors

The objects used so far will be sufficient for most needs. For the most sophisticated control over resources, you might

want to use a monitor. A monitor lets you decide when to enter and exit the

synchronization, and it lets you wait for another area of your code to become free.

A monitor acts as a smart lock on a resource. When you want to begin synchronization, call the Enter( )

method of the monitor, passing in the object you want to lock: Monitor.Enter(this);

If the monitor is unavailable, the object protected by the monitor is in use.

You can do other work while you wait for the monitor to become available and then try again.

You can also explicitly choose to Wait( ), suspending your thread until the moment the monitor is free.

Wait( ) helps you control thread ordering.

Synchronizationvoid Incrementer( )

{

try

{

while (counter < 10)

{

Monitor.Enter(this);

long temp = counter;

temp++;

Thread.Sleep(1);

counter = temp;

Console.WriteLine( "[{0}] In Incrementer. Counter: {1}", Thread.CurrentThread.Name, counter);

Monitor.Pulse(this);

Monitor.Exit(this);

} }

}

Problems of thread synchronization Race Conditions

A race condition exists when the success of your program depends on the uncontrolled order of completion of two independent threads.

Suppose, for example, that you have two threads—one is responsible for opening a file and the other is responsible for writing to the file.

It is important that you control the second thread so that it's assured that the first thread has opened the file.

If not, under some conditions, the first thread will open the file and the second thread will work fine; under other unpredictable conditions, the first thread won't finish opening the file before the second thread tries to write to it, and you'll throw an exception (or worse, your program will simply seize up and die).

This is a race condition, and race conditions can be very difficult to debug.

You cannot leave these two threads to operate independently; you must ensure that Thread1 will have completed before Thread2 begins.

To accomplish this, you might Join( ) Thread2 on Thread1. As an alternative, you can use a Monitor and Wait( ) for the

appropriate conditions before resuming Thread2.

Problems of thread synchronization Deadlock

When you wait for a resource to become free, you are at risk of deadlock, also called a deadly embrace.

In a deadlock, two or more threads are waiting for each other, and neither can become free.

Suppose you have two threads, ThreadA and ThreadB. ThreadA locks down an Employee object and then tries to get a lock on a row in

the database. It turns out that ThreadB already has that row locked, so ThreadA waits. Unfortunately, ThreadB can't update the row until it locks down the Employee

object, which is already locked down by ThreadA. Neither thread can proceed, and neither thread will unlock its own resource. They

are waiting for each other in a deadly embrace. As described, the deadlock is fairly easy to spot—and to correct. In a program running many threads, deadlock can be very difficult to diagnose, let

alone solve. One guideline is to get all the locks you need or to release all the locks you have. That is, as soon as ThreadA realizes that it can't lock the Row, it should release its

lock on the Employee object. Similarly, when ThreadB can't lock the Employee, it should release the Row. A second important guideline is to lock as small a section of code as possible and

to hold the lock as briefly as possible.

Unidad IV Interfaz Gráfica de Usuario (GUI)

4.1 Creación de interfaz gráfica para usuarios. 4.1.1 Librería de interfaz gráfica (API’s). 4.1.2 Aplicaciones GUI.

4.2 Computación gráfica. 4.2.1 Área de dibujo. 4.2.2 Primitivas de dibujo (línea, arco, circulo, colores, rellenos, imágenes).

Controls You may not notice it, but when you work with Windows Forms, you are working with the

System .Windows.Forms namespace. This namespace is included in the using directives in one of the files that holds the Form class. Most controls in .NET derive from the System.Windows.Forms.Control class. This class defines the basic functionality of the controls, which is why many properties and

events in the controls you ’ ll see are identical. Many of these classes are themselves base classes for other controls, as is the case with the

Label and TextBoxBase classes .

Properties All controls have a number of properties that are used to manipulate the behavior of the control. The base class of most controls, System.Windows.Forms.Control , has several properties that

other controls either inherit directly or override to provide some kind of custom behavior.

Events The Control class defines a number of events that are common to the controls you use in this chapter. The following table describes a number of these events. Again, this is just a selection of the most common events; to see the entire list, refer to the .NET

Framework SDK documentation.

The Button Control The System.Windows.Forms namespace provides three

controls that derive from ButtonBase : Button , CheckBox , and RadioButton .

The Label and LinkLabel Controls The Label control is probably the most frequently used control of

them all. Look at any Windows application and you see a label on just about every dialog you find. Label is a simple control with one purpose only — to display text on the form.

The .NET Framework includes two label controls that present themselves in two distinct ways: Label , the standard Windows label . LinkLabel , a label similar to the standard one (and derived from it) but that

presents itself as an Internet link (a hyperlink) .

The TextBox Control Text boxes should be used whenever you want users to enter text

that you have no knowledge of at design time (e.g., the user ’ s name).

The primary function of a text box is for users to enter text, but any characters can be entered, and you can force users to enter numeric values only.

The .NET Framework comes with two basic controls to take text input from users: TextBox and RichTextBox .

Both controls are derived from a base class called TextBoxBase , which itself is derived from Control .

TextBoxBase provides the base functionality for text manipulation in a text box, such as selecting text, cutting to and pasting from the clipboard, and a wide range of events.

The RadioButton and CheckBox Controls Radio buttons traditionally display themselves as a label with a tiny

circle to the left of it, which can be either selected or not. You should use the radio buttons when you want to give users a choice

between several mutually exclusive options. To group radio buttons together so they create one logical unit you

must use a GroupBox control or some other container. When you first place a GroupBox onto a form and then place the

RadioButton controls you need within the borders of the GroupBox , the RadioButton controls will automatically change their state to reflect that only one option within the group box can be selected.

If you do not place the controls within a GroupBox , only one RadioButton on the form can be selected at any given time.

A CheckBox control traditionally displays itself as a label with a small box on its immediate left.

Use a check box when you want to enable users to choose one or more options — for example, a questionnaire asking which operating systems the user has tried (e.g., Windows XP, Windows Vista, Linux, and so on).

The GroupBox Control The GroupBox control is often used to logically group a set of controls such as the

RadioButton and CheckBox , and to provide a caption and a frame around this set. Using the group box is as simple as dragging it onto a form and then dragging the

controls it should contain onto it (but not the reverse — that is, you can ’ t lay a group box over preexisting controls).

The effect of this is that the parent of the controls becomes the group box, rather than the form, so it is possible to have more than one radio button selected at any given time.

Within the group box, however, only one radio button can be selected. The relationship between parent and child probably needs to be explained a bit more. When a control is placed on a form, the form is said to become the parent of the

control, and hence the control is the child of the form. When you place a GroupBox on a form, it becomes a child of a form. Because a group box can itself contain controls, it becomes the parent of these

controls. The effect of this is that moving the GroupBox control moves all of the controls placed

on it. Another effect of placing controls on a group box is that it enables you to affect the

contained controls by setting the corresponding property on the group box. For instance, if you want to disable all the controls within a GroupBox control, you can

simply set the Enabled property of the GroupBox to false .

The RichTextBox Control Like the normal TextBox , the RichTextBox control is derived from

TextBoxBase . Because of this, it shares a number of features with the TextBox , but is

much more diverse. Whereas a TextBox is commonly used for the purpose of obtaining short text

strings from the user, the RichTextBox is used to display and enter formatted text (e.g., bold , underline , and italic ). It does so using a standard for formatted text called Rich Text Format, or RTF.

The ListBox and CheckedListBox Controls List boxes are used to show a list of strings from which one or more can be

selected at a time. Just like check boxes and radio buttons, the list box provides a way to ask users to make one or more selections.

You should use a list box when at design time you don ’ t know the actual number of values the user can choose from (e.g., a list of co - workers).

Even if you know all the possible values at design time, you should consider using a list box if there are a large number of values.

The ListBox class is derived from the ListControl class, which provides the basic functionality for list - type controls that ship with the .NET Framework.

Another kind of list box available is called CheckedListBox . Derived from the ListBox class, it provides a list just like the ListBox does, but in addition to the text strings it provides a check for each item in the list.

The ListView Control The list view is usually used to present data for which the

user is allowed some control over the detail and style of its presentation.

It is possible to display the data contained in the control as columns and rows much like in a grid, as a single column, or with varying icon representations.

The most commonly used list view is like the one shown earlier, which is used to navigate the folders on a computer.

The ListView control is easily the most complex control you encounter in this chapter, and covering all of its aspects is beyond the scope of this book.

The ListView Control The list view is usually used to present data for which the

user is allowed some control over the detail and style of its presentation.

It is possible to display the data contained in the control as columns and rows much like in a grid, as a single column, or with varying icon representations.

The most commonly used list view is like the one shown earlier, which is used to navigate the folders on a computer.

The ListView control is easily the most complex control you encounter in this chapter, and covering all of its aspects is beyond the scope of this book.

The ImageList Control The ImageList control provides a collection that can be used to store images used

in other controls on your form. You can store images of any size in an image list, but within each control every

image must be of the same size. In the case of the ListView , this means that you need two ImageList controls to be able to display both large and small images.

The ImageList is the first control you visit in this chapter that does not display itself at runtime.

When you drag it to a form you are developing, it is not placed on the form itself, but below it in a tray, which contains all such components.

This nice feature is provided to prevent controls that are not part of the user interface from cluttering up the Forms Designer.

The control is manipulated in exactly the same way as any other control, except that you cannot move it onto the form.

You can add images to the ImageList at both design time and runtime. If you know at design time what images you want to display, then you can add the

images by clicking the button at the right side of the Images property. This will bring up a dialog in which you can browse to the images you want to

insert. If you choose to add the images at runtime, you add them through the Images

collection.

The TabControl Control The TabControl control provides an easy way to organize a dialog

into logical parts that can be accessed through tabs located at the top of the control. A TabControl contains TabPages that essentially work like a GroupBox control, in that they group controls together, although they are somewhat more complex.

Using the MenuStrip Control In addition to the MenuStrip control, several additional controls are

used to populate a menu. The three most common of these are the ToolStripMenuItem ,

ToolStripDropDown , and the ToolStripSeparator . All of these controls represent a particular way to view an item in a

menu or toolbar. The ToolStripMenuItem represents a single entry in a menu, the

ToolStripDropDown represents an item that when clicked displays a list of other items, and the ToolStripSeparator represents a horizontal or vertical dividing line in a menu or toolbar.

There is another kind of menu that is discussed briefly after the discussion of the MenuStrip — the ContextMenuStrip .

A context menu appears when a user right - clicks on an item, and typically displays information relevant to that item.

Toolbars While menus are great for providing access to a multitude of functionality in

your application, some items benefit from being placed in a toolbar as well as on the menu.

A toolbar provides one - click access to such frequently used functionality as Open, Save, and so on.

A button on a toolbar usually displays a picture and no text, though it is possible to have buttons with both.

In addition to buttons, you will occasionally see combo boxes and text boxes in the toolbars too.

If you let the mouse pointer hover above a button in a toolbar, it will often display a tooltip, which provides information about the purpose of the button, especially when only an icon is displayed.

The ToolStrip , like the MenuStrip , has been made with a professional look and feel in mind.

When users see a toolbar, they expect to be able to move it around and position it wherever they want it.

The ToolStrip enables users to do just that — that is, if you allow them to.

StatusStrip The last of the small family of strip controls is the StatusStrip . This control represents the bar that you find at the bottom of the

dialog in many applications. The bar is typically used to display brief information about the

current state of the application — a good example is Word ’ s display of the current page, column, line, and so on in the status bar as you are typing.

The StatusStrip is derived from the ToolStrip , and you should be quite familiar with the view that is presented as you drag the control onto your form.

Three of the four possible controls that can be used in the StatusStrip — ToolStripDropDownButton , ToolStripProgressBar , and ToolStripSplitButton — were presented earlier.

That leaves just one control that is specific to the StatusStrip : the StatusStripStatusLabel , which is also the default item you get.

SDI and MDI Applications Traditionally, three kinds of applications can be programmed for

Windows: Dialog - based applications : These present themselves to the

user as a single dialog from which all functionality can be reached. Single - document interfaces (SDI) : These present themselves

to the user with a menu, one or more toolbars, and one window in which the user can perform some task.

Multiple - document interfaces (MDI) : These present themselves to the user in the same manner as an SDI, but are capable of holding multiple open windows at one time.

SDI and MDI Applications Dialog - based applications are usually small, single - purpose applications

aimed at a specific task that needs a minimum of data to be entered by the user or that target a very specific type of data.

Single - document interfaces are each usually aimed at solving one specific task because they enable users to load a single document into the application to be worked on. This task, however, usually involves a lot of user interaction, and users often want the capability to save or load the result of their work. Good examples of SDI applications are WordPad) and Paint, both of which come with Windows.

However, only one document can be open at any one time, so if a user wants to open a second document, then a fresh instance of the SDI application must be opened, and it will have no reference to the first instance. Any configuration you do to one instance is not carried over into the other. For example, in one instance of Paint you might set the drawing color to red, and when you open a second instance of Paint, the drawing color is the default, which is black.

Multiple - document interfaces are much the same as SDI applications, except that they are able to hold more than one document open in different windows at any given time.

Common Dialogs A dialog is a window that is displayed within the context of another window. With a dialog, you can ask the user to enter some data before the flow of

the program continues. A common dialog is one that is used to get information from the user that

most applications typically require, such as the name of a file, and is a part of the Windows operating system.

File Dialogs With a file dialog, the user can select a drive and browse

through the file system to select a file. From the file dialog, all you want returned is a filename from the user.

The OpenFileDialog enables users to select by name the file they want to open. The SaveFileDialog , in contrast, enables users to specify a name for a file they want to save.

These dialog classes are similar because they derive from the same abstract base class, though there are some properties unique to each class.

In this section, you look first at the features of the OpenFileDialog , then at how the SaveFileDialog differs, and you develop a sample application that uses both of them.

OpenFileDialog The OpenFileDialog class enables users to select a file to

open. As shown in the preceding example, a new instance of the OpenFileDialog class is created before the ShowDialog() method is called:OpenFileDialog dlg = new OpenFileDialog();

dlg.ShowDialog();

SaveFileDialog The SaveFileDialog class is very similar to the

OpenFileDialog , and they have a set of common properties. This section focuses on the properties specific to the Save dialog, and explains how the application of the common properties differs.

Printing With printing there are many things to worry about, such as

the selection of a printer, page settings, and how to print multiple pages.

By using classes from the System.Drawing.Printing namespace, you can get a lot of help with these challenges, and print documents from your own applications with ease.

Before looking at the PrintDialog class that makes it possible to select a printer, take a quick look at how .NET handles printing.

The foundation of printing is the PrintDocument class, which has a Print() method that starts a chain of calls culminating in a call to OnPrintPage() , which is responsible for passing the output to the printer.

However, before learning how to implement printing code, first consider the .NET printing classes.

Printing Architecture

Printing Architecture Let ’ s look at the functionality of these classes:

The PrintDocument class is the most important class. In Figure 17 - 18 , you can see that nearly all other classes are related to this class. To print a document, an instance of PrintDocument is required. The following section looks at the printing sequence initiated by this class.

The PrintController class controls the flow of a print job. The print controller has events for the start of the printing, for each page, and for the end of the printing. The class is abstract because the implementation of normal printing is different from that of print preview. Concrete classes that derive from PrintController are StandardPrintController and PreviewPrintController .

You will not find the methods Print() and PrintLoop() in the documentation because these methods are internal to the assembly and can be invoked only by other classes in the same assembly, such as the PrintDocument class. However, these methods help you understand the printing process, which is why they are shown here.

The PrinterSettings class can get and set the printer configurations, such as duplex printing, landscape or portrait, and number of copies.

Printing Architecture Let ’ s look at the functionality of these classes:

The PrintDocument class is the most important class. In Figure 17 - 18 , you can see that nearly all other classes are related to this class. To print a document, an instance of PrintDocument is required. The following section looks at the printing sequence initiated by this class.

The PrintController class controls the flow of a print job. The print controller has events for the start of the printing, for each page, and for the end of the printing. The class is abstract because the implementation of normal printing is different from that of print preview. Concrete classes that derive from PrintController are StandardPrintController and PreviewPrintController .

You will not find the methods Print() and PrintLoop() in the documentation because these methods are internal to the assembly and can be invoked only by other classes in the same assembly, such as the PrintDocument class. However, these methods help you understand the printing process, which is why they are shown here.

The PrinterSettings class can get and set the printer configurations, such as duplex printing, landscape or portrait, and number of copies.

The PrintDialog class contains options for selecting which printer to print to and how the PrinterSettings should be onfigured. This class is derived from CommonDialog like the other dialog classes already described.

The PageSettings class specifies the sizes and boundaries of a page, and whether the page is in black and white or color. You can configure this class with the PageSetupDialog class, which is a CommonDialog .

Printing Sequence Now that you know about the roles of the classes in the

printing architecture, let ’ s look at the main printing sequence. Figure shows the major players — your application, an instance of the PrintDocument class, and a PrintController , in a timely sequence.

GDI+ Namespaces The following table provides an overview of the main namespaces you will

need to explore to find the GDI+ base classes.

GDI+ Namespaces The following table provides an overview of the main namespaces you will

need to explore to find the GDI+ base classes.

Coordinate Systems By default, the origin of all three coordinate systems is at point (0, 0), which

is located at the upper left corner of the drawing area. The X coordinate represents the distance from the left edge of the drawing

area to the point, and the Y coordinate represents the distance from the top edge of the drawing area to the point.

Figure shows how the X and Y coordinates of a point relate to the drawing area.

The default unit for all three of these coordinate systems is pixels. The coordinate system can be customized by shifting the origin to another location in the client area, and by setting a different unit of measure.

Coordinate Systemsusing System;

using System.Drawing;

using System.Windows.Forms;

namespace Example1_1

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

this.SetStyle(ControlStyles.ResizeRedraw, true);

this.BackColor = Color.White;

}

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

// Following codes draw a line from (0, 0) to (1, 1) in unit of inch:

g.PageUnit = GraphicsUnit.Inch;

Pen blackPen = new Pen(Color.Black, 1 / g.DpiX);

g.DrawLine(blackPen, 0, 0, 1, 1);

}

}

}

Coordinate Systems Let’s now move the origin to the centre of the

client area and draw the line again. This can be done by changing the OnPaint method of Example1_1 to the following:

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

// Following codes shift the origin to the center of the client area, and

// then draw a line from (0,0) to (1,1):

g.PageUnit = GraphicsUnit.Inch;

g.TranslateTransform((ClientRectangle.Width / g.DpiX) / 2,

(ClientRectangle.Height / g.DpiY) / 2);

Pen greenPen = new Pen(Color.Green, 1 / g.DpiX);

g.DrawLine(greenPen, 0, 0, 1, 1);

}

Custom Coordinates An application can define its own coordinate system. This coordinate system is independent of the unit of your realworld graphics objects,

and its Y-axis points from bottom to top as it does in most chart applications. In this system, the page coordinate system is identical to the device system, and the unit for both systems is in pixels.

Inside the Client Area, a drawing area is defined with an offset margin. The conventional X-Y coordinate system can be defined within the drawing area. Here we will demonstrate how to achieve this with C#.

Custom Coordinates Create a new Visual C# Windows Application project, and

name it Example1-2. The following is

the code listing of Form1.cs:

using System;

using System.Drawing;

using System.Windows.Forms;

namespace Example1_2

{

public partial class Form1 : Form

{

// Define the drawing area

private Rectangle PlotArea;

// Unit defined in world coordinate system:

private float xMin = 0f;

private float xMax = 10f;

private float yMin = 0f;

private float yMax = 10f;

// Define the offset in pixel:

private int offset = 30;

public Form1()

{

InitializeComponent();

this.SetStyle(ControlStyles.ResizeRedraw, true);

this.BackColor = Color.White;

}

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

// Calculate the location and size of the drawing area

// within which we want to draw the graphics:

Rectangle rect = ClientRectangle;

PlotArea = new Rectangle(rect.Location, rect.Size);

PlotArea.Inflate(-offset, -offset);

//Draw ClientRectangle and PlotArea using Pen:

g.DrawRectangle(Pens.Red, rect);

g.DrawRectangle(Pens.Black, PlotArea);

// Draw a line from point (3,2) to Point (6, 7)

// using a Pen with a width of 3 pixels:

Pen aPen = new Pen(Color.Green, 3);

g.DrawLine(aPen, Point2D(new PointF(3, 2)), Point2D(new PointF(6, 7)));

aPen.Dispose();

g.Dispose();

}

private PointF Point2D(PointF ptf)

{

PointF aPoint = new PointF();

aPoint.X = PlotArea.X + (ptf.X - xMin) *

PlotArea.Width / (xMax - xMin);

aPoint.Y = PlotArea.Bottom - (ptf.Y - yMin) *

PlotArea.Height / (yMax - yMin);

return aPoint;

}

}

}

Zooming The size and position of the “Window” determine which part of the graphics

object is drawn. The relative size of the Window and viewport determine the scale at which

the graphics object is displayed on the screen. For a given viewport or PlotArea, a relatively large Window produces a small

graphics object, because you are drawing a large piece of the custom coordinate space into a small viewport (PlotArea).

On the other hand, a relatively small Window produces a large graphics object.

Therefore, you can increase the size of the Window (specified by the X and Y axis limits) to see the “zooming out” effect by changing the parameters: xMin, xMax, yMin, and yMax in Example1_2, discussed in the previous section:private float xMin = -10f;

private float xMax = 20f;

private float yMin = 0f;

private float yMax = 20f;

ZoomingOn the other hand, if you decrease the Window size, the line

appears larger on the screen; basically, you have a “zoom in” effect. Change the parameters in Example to the following:

private float xMin = 2f;

private float xMax = 7f;

private float yMin = 2f;

private float yMax = 8f;

Panning Panning is defined as the moving of all graphics objects in the scene by shifting the

Window. In a panning process, the Window size is kept unchanged. For example, you can move the Window to the left by changing the code in Example// Moving original window left 3 units:

private float xMin = -3f ;

private float xMax = 7;

private float yMin = 0f;

private float yMax = 10f;

This produces the result shown in Figure which is equivalent to moving the line toward the right side of the drawing area. On the other hand, if we move the Window to the right by use of the following code:// Moving original Window right in 3 units:

private float xMin = 3f ;

private float xMax = 13;

private float yMin = 0f;

private float yMax = 10f;

Panning Here we will use a Panel control to achieve

this goal. Let’s start off by creating a new C# Windows Application project and calling it Example1_3. Select a Panel control from the Toolbox, drag it over the empty Form1, and rename the panel control to drawingPanel. The following is the code listing of Form1.cs:using System;

using System.Drawing;

using System.Windows.Forms;

namespace Example1_3

{

public partial class Form1 : Form

{

// Unit defined in world coordinate system:

private float xMin = 0f;

private float xMax = 10f;

private float yMin = 0f;

private float yMax = 10f;

// Unit in pixel:

private int offset = 30;

public Form1()

{

InitializeComponent();

this.SetStyle(ControlStyles.ResizeRedraw, true);

this.BackColor = Color.White;

// Subscribing to a paint eventhandler to drawingPanel:

drawingPanel.Paint += new PaintEventHandler(drawingPanelPaint);

drawingPanel.BorderStyle = BorderStyle.FixedSingle;

drawingPanel.Anchor = AnchorStyles.Bottom;

drawingPanel.Anchor = AnchorStyles.Left;

drawingPanel.Anchor = AnchorStyles.Right;

drawingPanel.Anchor = AnchorStyles.Top;

}

private void drawingPanelPaint(object sender, PaintEventArgs e)

{

drawingPanel.Left = offset;

drawingPanel.Top = offset;

drawingPanel.Width = ClientRectangle.Width - 2 * offset;

drawingPanel.Height = ClientRectangle.Height - 2 * offset;

Graphics g = e.Graphics;

Pen aPen = new Pen(Color.Green, 3);

g.DrawLine(aPen, Point2D(new PointF(2, 3)),

Point2D(new PointF(6, 7)));

aPen.Dispose();

g.Dispose();

}

private PointF Point2D(PointF ptf)

{

PointF aPoint = new PointF();

aPoint.X = (ptf.X - xMin) * drawingPanel.Width / (xMax - xMin);

aPoint.Y = drawingPanel.Height - (ptf.Y - yMin) *

drawingPanel.Height / (yMax - yMin);

return aPoint;

}

}

}

Pen and Brush Graphics objects provide an interface between the

application program and the display device (the computer screen).

After creating a Graphics object, you can use it to draw lines and fill shapes.

However, even though the Graphics class provides the platform to draw on, you still need a tool to draw with.

Two basic tools you will often use are the Pen and Brush.

The GDI+ library provides the Pen and Brush through the Pen and Brush classes respectively.

You use the Pen class to draw lines, curves, and outlines of shapes.

You use the Brush class to fill shapes with colors and patterns.

Pen Class You use the Pen class to create custom pens with specified color

and width properties. The line drawn by a Pen object can be filled in a variety of fill

styles, including solid colors and textures. The fill style depends on the brush or texture that is used as the fill

object. There are four different types of constructors for the Pen class: two

constructors allow you to specify a Brush object instead of color, and two constructors give you the option of specifying the pen’s width.

These four constructors are as follows: Creates a new instance of the Pen class with the specified Color:

public Pen(color); Creates a new instance of the Pen class with the specified Brush:

public Pen(brush); Creates a new instance of the Pen class with the specified Brush and width:

public Pen(brush, float); Creates a new instance of the Pen class with the specified Color and width:

public Pen(color, float);

Pen Class The Pen class has a number of properties, offering you a large

amount of control over how your Pen object draws graphics elements. The most commonly used properties include:

• Alignment – Gets or sets the alignment for the Pen object. • Brush – Gets or sets the Brush object that determines the

attributes of the Pen object. • Color – Gets or sets the color of the Pen object. • DashStyle – Gets or sets the style used for dashed lines drawn

with the Pen object. • Width – Gets or sets the width of the Pen object.

Brush Class The brushes are used to fill shapes with colors, patterns, and

images. The Brush class is an abstract base class and cannot be instantiated. In order to create a Brush object, you must use its derived classes, which include:

• SolidBrush – This class defines a brush made of a single color. • TextureBrush – This class defines a brush that uses an image to

fill the interior of a shape. • HatchBrush – This class defines a rectangle brush with a hatch

style, a foreground color, and a background color. • LinearGradientBrush – This class encapsulates both two-color

gradients and custom multicolor gradients. • PathGradientBrush – This class encapsulates a Brush object that

fills the interior of a GraphicsPath object with a gradient.

Brush Class The following code snippet creates various brush objects:

// Create a SolidBrush with red color:

SolidBrush sb = new SolidBrush(Color.Red);

// Create a TextureBrush with an image file (myImage.gif):

Bitmap bmp = new Bitmap(“myImage.gif”);

TextureBrush tb = new TextureBrush(bmp);

// Create a HatchBrush with a Cross pattern:

HatchBrush hb = new HatchBrush(HatchStyle.Cross,

Color.Black, Color.White);

// Create a LinearGradientBrush with a Gradient described by two points:

LinearGradientBrush lgb = new LinearGradientBrush(New Point(10, 10),

new Point(100, 30), Color.Red, Color.Black);

// Create a PathGradientBrush for a Graphics path:

PathGradientBrush pgb = new PathGradientBrush(graphicsPath);

pgb.CenterColor = Color.Red;

pgb.SurroundColors = new Color[] {Color.Black};

Points In C# and GDI+, there are two point structures: Point and

PointF. The Point structure represents an ordered pair of integer X-

and Y- coordinates that define a point in a 2D plane. The Point constructor includes three overloaded methods

that allow you to create a Point object from an integer, a size object, or two integers as follows: • Point() – Creates a Point object and initializes the X- and Y-data

members to zeros. This is the default constructor. • Point(Size) – Creates a Point object using a Size object to initialize the

X- and Y-data members. • Point(int, int) – Creates a Point object using two integers to initialize the

X- and Y-data members.

The following code snippet creates Point objects using all three types of the constructors: Point pt1 = new Point(); Point pt2 = new Point(new Size(10, 100)); Point pt3 = new Point(20, 200);

Points The PointF structure is similar to the Point structure, but

uses floating-point values instead of integers. Unlike the Point structure, PointF cannot take a Size or SizeF

object. PointF has only two constructors PointF() and PointF(float, float).

Both the Point and PointF defines three properties: IsEmpty, X, and Y.

The IsEmpty property returns true if a point is empty, which means that both X and Y values are zero; otherwise it returns false.

The constructors, Point()and PointF()create an empty field with X and Y values set to zero.

Lines and Curves Line objects include straight lines and curves. A straight line can be created using the DrawLine method,

which connects two points specified by coordinate pairs. The following code snippet creates a straight line:

Graphics g = new Graphics(); g.DrawLine(Pens.Black, x1, y1, x2, y2 ); g.DrawLine(Pens.Black, point1, point2);

where (x1, y1) is the starting point of the line and (x2, y2) is the endpoint of the line.

It is also possible to directly specify the start- and end-points using point1 and point2.

The coordinates or the points can be integers or float values.

Lines and Curves The DrawCurve method creates a spline that passes through

each point in a point array, and connects all points in a smooth way: Graphics g = new Graphics(); g.DrawCurve(Pens.Black, new Point[]);

In these cases, only solid lines and curves are drawn. However, lines and curves can have many different styles. For example, you can draw a dash-line with a diamond

starting cap and an arrow ending cap, as illustrated in Figure .

This shows that a line can have three parts: the line body, starting cap, and ending cap.

Lines and Curvesusing System;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Windows.Forms;

namespace Example1_4

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

This.BackColor = Color.White;

}

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

// Create a pen object:

Pen aPen = new Pen(Color.Blue, 4);

// Set line caps and dash style:

aPen.StartCap = LineCap.DiamondAnchor;

aPen.EndCap = LineCap.ArrowAnchor;

aPen.DashStyle = DashStyle.DashDot;

aPen.DashOffset = 50;

//draw straight line:

g.DrawLine(aPen, 50, 30, 200, 30);

// define point array to draw a curve:

Point point1 = new Point(50, 200);

Point point2 = new Point(100, 75);

Point point3 = new Point(150, 60);

Point point4 = new Point(200, 160);

Point point5 = new Point(250, 250);

Point[] Points ={ point1, point2, point3, point4, point5};

g.DrawCurve(aPen, Points);

aPen.Dispose();

g.Dispose();

}

}

}

Rectangles, Ellipses, and Arcs The Rectangle and RectangleF structures represent a rectangle in

C# and GDI+. A Rectangle structure stores the top-left corner as well as the

width and height of a rectangle region. You can create a Rectangle object from the Point and Size objects

or by using four integers or float values as the coordinates of the rectangle.

The Rectangle and RectangleF structures also provide properties which can be used to obtain the width, height, and position of the rectangle.

An ellipse is a circular shape defined by its bounding rectangle. The DrawEllipe method will draw an empty ellipse within the

bounding rectangle. While DrawEllipse method draws a closed curve around the whole

boundary of the ellipse, the DrawArc method draws part of the ellipse.

Which part is drawn is specified by a StartAngle and a SweepAngle.

The method DrawPie is also closely related to the ellipse. You specify an ellipse by supplying the enclosing rectangle. In addition, you specify a StartAngle and a SweepAngle to define

where the pie starts, and how large of a section of the ellipse it spans.

Rectangles, Ellipses, and Arcsusing System;

using System.Drawing;

using System.Windows.Forms;

namespace Example1_5

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

SetStyle(ControlStyles.ResizeRedraw, true);

}

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

// Create a pen object:

Pen aPen = new Pen(Color.Blue, 2);

// Create a brush object with a transparent red color:

SolidBrush aBrush = new SolidBrush(Color.Red);

// Draw a rectangle:

g.DrawRectangle(aPen, 20, 20, 100, 50);

using // Draw a filled rectangle:

g.FillRectangle(aBrush, 20, 90, 100, 50);

// Draw ellipse:

g.DrawEllipse(aPen, new Rectangle(20, 160, 100, 50));

// Draw filled ellipse:

g.FillEllipse(aBrush, new Rectangle(170, 20, 100, 50));

// Draw arc:

g.DrawArc(aPen, new Rectangle(170, 90, 100, 50),

-90, 180);

g.FillPie(aBrush, new Rectangle(170, 160, 100, 100),

-90, 90);

g.FillPie(Brushes.Green,

new Rectangle(170, 160, 100, 100), -90, -90);

}

}

}

Polygons The polygon is one of the most important graphics objects we deal with

when we render 2D and 3D graphics or process computational geometry. The Graphics.DrawPolygon method draws a polygon defined by an array of

point structures. Every pair of two consecutive points in the array specifies a side of the

polygon. In addition, if the last point and the first point of the array do not coincide,

it specifies the last side of the polygon. The Graphics.FillPolygon method fills the interior of a polygon defined by an

array of points specified by point structures. In the following example, we will create a US flag object that contains fifty

star polygons. First we need to define the coordinates of a star. As illustrated in Figure, we will assume that the center coordinates of the

star are at (xc, yc), r1 is the radius of the inner circle, and r is the radius of the outer circle.

The angles α = 72 degrees and β = 36 degrees. From this figure, we can easily determine the coordinates of points 0 to 9:

Polygons

Polygonsusing System;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Windows.Forms;

namespace Example1_6

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

SetStyle(ControlStyles.ResizeRedraw, true);

this.Width = 500;

this.Height = 310;

this.BackColor = Color.LightGreen;

}

protected override void OnPaint(PaintEventArgs e)

{

Graphics g = e.Graphics;

g.SmoothingMode = SmoothingMode.AntiAlias;

DrawFlag(g, 20, 20, this.Width - 50);

g.Dispose();

}

private void DrawFlag(Graphics g, float x0, float y0, float width)

{

SolidBrush whiteBrush = new SolidBrush(Color.White);

SolidBrush blueBrush = new SolidBrush(Color.FromArgb(0, 0, 128));

SolidBrush redBrush = new SolidBrush(Color.Red);

float height = 10 * width / 19;

// Draw white rectangle background:

g.FillRectangle(whiteBrush, x0, y0, width, height);

// Draw seven red stripes.

for (int i = 0; i < 7; i++)

{g.FillRectangle(redBrush, x0,y0 + 2 * i * height / 13, width, height

/ 13);

}

// Draw blue box.

// Size it so that it covers two fifths of the flag width

// and the top four red stripes vertically.

RectangleF blueBox = new RectangleF(x0, y0,

2 * width / 5, 7 * height / 13);

g.FillRectangle(blueBrush, blueBox);

// Draw fifty stars in the blue box.

// Divide the blue box into a grid of 11 x 9 squares and

Polygons// place a star in every other square.

float offset = blueBox.Width / 40;

float dx = (blueBox.Width - 2 * offset) / 11;

float dy = (blueBox.Height - 2 * offset) / 9;

for (int j = 0; j < 9; j++)

{float yc = y0 + offset + j * dy + dy /

2;for (int i = 0; i < 11; i++){

float xc = x0 + offset + i * dx + dx / 2;

if ((i + j) % 2 == 0){

DrawStar(g, this.Width/55, xc, yc);

}}

}

whiteBrush.Dispose();

blueBrush.Dispose();

redBrush.Dispose();

}

private void DrawStar(Graphics g, float r, float xc, float yc)

{

// r: determines the size of the star.// xc, yc: determine the location of the star.float sin36 = (float)Math.Sin(36.0 * Math.PI / 180.0);float sin72 = (float)Math.Sin(72.0 * Math.PI / 180.0);float cos36 = (float)Math.Cos(36.0 * Math.PI / 180.0);float cos72 = (float)Math.Cos(72.0 * Math.PI / 180.0);float r1 = r * cos72 / cos36;// Fill the star:PointF[] pts = new PointF[10];pts[0] = new PointF(xc, yc - r);pts[1] = new PointF(xc + r1 * sin36, yc - r1 * cos36);pts[2] = new PointF(xc + r * sin72, yc - r * cos72);pts[3] = new PointF(xc + r1 * sin72, yc + r1 * cos72);pts[4] = new PointF(xc + r * sin36, yc + r * cos36);pts[5] = new PointF(xc, yc + r1);pts[6] = new PointF(xc - r * sin36, yc + r * cos36);pts[7] = new PointF(xc - r1 * sin72, yc + r1 * cos72);pts[8] = new PointF(xc - r * sin72, yc - r * cos72);pts[9] = new PointF(xc - r1 * sin36, yc - r1 * cos36);g.FillPolygon(Brushes.White, pts);

}}

}

Polygons

Color In C# and GDI+, color is specified as Color structures from

the System.Drawing namespace. It is easy to create a color object using these color structures. There are several different ways of creating color in C#, including: • An ARGB (alpha, red, green, blue) color value. You specify each value

as an integer in the range [0, 255]. • An environment setting from the current color scheme. You choose the

correspondingly named property from the system Color class. • A predefined .NET color name. You choose the correspondingly named

property from the Color class. • An HTML color name. You specify this value as a string using the

ColorTranslator class. • A Win32 color code. You specify this value as an integer (representing a

hexadecimal value) using the ColorTranslator class. • An OLE color code. You specify this value as an integer (representing a

hexadecimal value) using the ColorTranslator class. • A ColorDialog. You pick a color from the color palette.

System Colors In C#, a color is represented by a 32-bit structure made up

of four components: alpha (A), red (R), green (G), and blue (B), referred to as ARGB mode.

The components’ values range from 0 to 255. The alpha component of the color represents transparency,

which determines how such a color is blended with the background.

A zero alpha value represents a fully transparent color, while a value of 255 represents a fully opaque color.

System Colors// Create a color from an ARGB value

int alpha = 100;

int red = 255;

int green = 0;

int blue = 0;

this.BackColor = Color.FromARGB(alpha, red, green, blue);

// Create a color from an environment setting:

this.BackColor = SystemColors.HighlightText;

// Create a Color using a .NET name

this.BackColor = Color.LightGray;

// Create a color from an HTML code:

this.BackColor = ColorTranslator.FromHTML(“Red”);

// Create a color from a Win32 color code:

this.BackColor = ColorTranslator.FromWin32(0xA000);

// Create a color from an OLE color code:

this.BackColor = ColorTranslator.FromOle(0xFF00);

// Create a color from a ColorDialog():

ColorDialog cdl = new ColorDialog();

cdl.ShowDialog();

this.BackColor = cdl.Color;

System Colors// Create a color from an ARGB value

int alpha = 100;

int red = 255;

int green = 0;

int blue = 0;

this.BackColor = Color.FromARGB(alpha, red, green, blue);

// Create a color from an environment setting:

this.BackColor = SystemColors.HighlightText;

// Create a Color using a .NET name

this.BackColor = Color.LightGray;

// Create a color from an HTML code:

this.BackColor = ColorTranslator.FromHTML(“Red”);

// Create a color from a Win32 color code:

this.BackColor = ColorTranslator.FromWin32(0xA000);

// Create a color from an OLE color code:

this.BackColor = ColorTranslator.FromOle(0xFF00);

// Create a color from a ColorDialog():

ColorDialog cdl = new ColorDialog();

cdl.ShowDialog();

this.BackColor = cdl.Color;

System Colorsusing System;

using System.Drawing;

using System.Windows.Forms;

namespace Example1_7

{

public partial class Form1 : Form

{

ColorDialog cdl = new ColorDialog();

public Form1()

{

InitializeComponent();

}

private void Form1_Load(object sender, EventArgs e)

{

string[] colorNames = Enum.GetNames(typeof(KnownColor));

listBox1.Items.AddRange(colorNames);

}

private void listBox1_SelectedIndexChanged(object sender,

EventArgs e)

{

KnownColor selectedColor =

(KnownColor)Enum.Parse(typeof(KnownColor), listBox1.Text);

panel1.BackColor = Color.FromKnownColor(selectedColor);

ColorInfo();

}

private void button1_Click(object sender, EventArgs e)

{

cdl.ShowDialog();

panel1.BackColor = cdl.Color;

ColorInfo();

}

private void ColorInfo()

{

// Show color information on the labels:

// Brightness info:

lblBrightness.Text = "Brightness = " +

panel1.BackColor.GetBrightness().ToString();

lblHue.Text = "Hue = " +

panel1.BackColor.GetHue().ToString();

// HUE Info:

lblSaturation.Text = "Saturation = " +

panel1.BackColor.GetSaturation().ToString();

System Colors// RGB Hex info:

string strRGBHex = string.Format("0x{0:X8}",

panel1.BackColor.ToArgb());

strRGBHex = "RGB = #" + strRGBHex.Substring(

strRGBHex.Length - 6, 6);

lblRGBHex.Text = strRGBHex;

// ARGB value info:

string strRGBValue = "ARGB = [" +

panel1.BackColor.A.ToString() + ", " +

panel1.BackColor.R.ToString() + ", " +

panel1.BackColor.G.ToString() + ", " +

panel1.BackColor.B.ToString() + "]";

lblRGBValue.Text = strRGBValue;

}

}

}

System Colors// RGB Hex info:

string strRGBHex = string.Format("0x{0:X8}",

panel1.BackColor.ToArgb());

strRGBHex = "RGB = #" + strRGBHex.Substring(

strRGBHex.Length - 6, 6);

lblRGBHex.Text = strRGBHex;

// ARGB value info:

string strRGBValue = "ARGB = [" +

panel1.BackColor.A.ToString() + ", " +

panel1.BackColor.R.ToString() + ", " +

panel1.BackColor.G.ToString() + ", " +

panel1.BackColor.B.ToString() + "]";

lblRGBValue.Text = strRGBValue;

}

}

}

Unidad V Multimedia.

5.1 Introducción a la multimedia. 5.2 Componentes de un sistema multimedia. 5.3 Formatos de archivo multimedia. 5.4 Creación y manipulación de objetos con formatos de archivo

gráfico comunes (GIF, TIFF, JPEG, WMF). 5.5 Creación y manipulación de objetos con formatos de

animación y video comunes (AVI, QUICKTIME, MPEG, GIF animado).

5.6 Creación y manipulación de objetos con formatos de audio (compresión de sonido, formato MIDI, MP3).

5.7 Integración de los elementos multimedia. 5.8 Interactividad.

Multimedia Es cualquier combinación de texto, arte gráfico, sonido, animación

y vídeo que llega a nosotros por computadora u otros medios electrónicos.

Es un tema presentado con lujos de detalles. Cuando conjuga los elementos de multimedia - fotografías y

animación deslumbrantes, mezclando sonido, vídeo clips y textos informativos - puede electrizar a su auditorio; y si además le da control interactivo del proceso, quedarán encantado.

Multimedia estimula los ojos, oídos, yemas de los dedos y, lo más importante, la cabeza.

Multimedia se compone, como ya se describió, de combinaciones entrelazadas de elementos de texto, arte gráfico, sonido, animación y vídeo.

Multimedia 1.1. Multimedia Interactiva:

Es cuando se le permite al usuario final - el observador de un proyecto multimedia - controlar ciertos elementos de cuándo deben presentarse.

1.1.1. Hipermedia: Es cuando se proporciona una estructura ligados a través de los cuales el usuario

puede navegar, entonces, multimedia interactiva se convierte en Hipermedia. Aunque la definición de multimedia es sencilla, hacer que trabaje puede ser

complicado. No sólo se debe comprender cómo hacer que cada elemento se levante y baile,

sino también se necesita saber cómo utilizar la herramientas computacionales y las tecnologías de multimedia para que trabajen en conjunto.

Las personas que tejen los hilos de multimedia para hacer una alfombra esplendorosa son desarrolladores de multimedia.

Un proyecto de multimedia no tiene que ser interactivo para llamarse multimedia: los usuarios pueden reclinarse en el asiento y verlo como lo hacen en el cine o frente al televisor.

En tales casos un proyecto es lineal, pues empieza y corre hasta el final, cuando se da el control de navegación a los usuarios para que exploren a voluntad el contenido, multimedia se convierte en no - lineal e interactiva, y es un puente personal muy poderoso hacia la información.

Multimedia Multimedia En Los Negocios:

Las aplicaciones de multimedia en los negocios incluyen presentaciones, capacitaciones, mercadotecnia, publicidad, demostración de productos, bases de datos, catálogos y comunicaciones en red.

El correo de voz y vídeo conferencia, se proporcionan muy pronto en muchas redes de área local (LAN) u de área amplia (WAN).

La mayoría de los programas de presentación permiten agregar clips de audio y vídeo a las presentaciones de "diapositivas" pantalla por pantalla (slide shows) de gráficas y textos.

Multimedia se ha vuelto muy popular en la capacitación. Los sobre cargos de aviación aprender a manejar situaciones de terrorismo internacional y

seguridad a través de la simulación. Los mecánicos aprenden a reparar motores, los vendedores aprenden acerca de las líneas de productos y ofrecen a sus clientes

programas de capacitación. Los pilotos de combate practican ejercicios de asalto antes de arriesgarse a una situación

real. Multimedia se ha vuelto muy común en la oficina. La Flex Can de Video Labs, un aditamento

económico para agregar una cámara de video y un micrófono estéreo. Este equipo de captura de imagen puede utilizarse para construir bases de datos de

identificación de empleados. A medida que las compañías se actualizan en multimedia, y el costo de instalación y el costo

de capacidad de multimedia disminuye, se desarrollan más aplicaciones dentro de las mismas empresa y por terceros para hacer que los negocios se administren más fácil y efectivamente.

Multimedia Multimedia En Las Escuelas:

Las escuelas son quizás los lugares donde más se necesita multimedia.

Multimedia causará cambios radicales en el proceso de enseñanza en la próximas décadas, en particular cuando los estudiantes inteligentes descubran que pueden ir más allá de los límites de los métodos de enseñanza tradicionales.

Proporciona a los médicos más de cien casos y da a los cardiólogos, radiólogos, estudiantes de medicina y otras personas interesadas, la oportunidad de profundizar en nuevas técnicas clínicas de imágenes de percusión cardíaca nuclear.

Los discos láser traen actualmente la mayoría de los trabajos de multimedia al salón de clases, en 1994 estában disponibles más de 2.500 títulos educativos para diferentes grados escolares, la mayoría dirigidos a la enseñanza de las ciencias básicas y ciencias sociales.

El uso de discos láser será muy probablemente sustituido por CD - ROM y después, cuando aquellas lleguen a ser parte de la Infraestructura Nacional de Información (NII), multimedia llegará por medio de fibra óptica y red.

Multimedia Multimedia En El Hogar:

Finalmente, la mayoría de los proyectos de multimedia llegarán a los hogares a través de los televisores o monitores con facilidades interactivas, ya sea en televisores a color tradicionales o en los nuevos televisores de alta definición, la multimedia en estos televisores probablemente llegará sobre una base pago - por - uso a través de la autopista de datos.

Actualmente, sin embargo, los consumidores caseros de multimedia poseen una computadora con una unidad de CD-ROM, o un reproductor que se conecta a la televisión, muchos hogares ya tienen aparatos de videojuego Nintendo, Sega o Atari conectados a su televisor; los nuevos equipos de videojuegos incluyen unidades de CD-ROM y proporcionan mayores capacidades de multimedia.

La convergencia entre la multimedia basada en computadoras y los medios de diversión y juego descritos como "dispárenles", es cada vez mayor.

Sólo Nintendo ha vendido más de cien millones de aparatos de videojuegos en el mundo y más de 750 millones de juegos.

La casa de futuro será muy diferente cuando los costos de los aparatos y televisores para multimedia se vuelvan accesible al mercado masivo, y la conexión a la autopista de datos más accesible.

Cuando el número de hogares multimedia crezca de miles a millones, se requerirá de una vasta selección de títulos y material para satisfacer a este mercado y, también, se ganarán enormes cantidades de dinero produciendo y distribuyendo esos productos.

Multimedia Multimedia En Lugares Públicos:

En hoteles, estaciones de trenes, centros comerciales, museos y tiendas multimedia estará disponible en terminales independientes o quioscos para proporcionar información y ayuda.

Estas instalaciones reducen la demanda tradicional de personal y puestos de información, agregan valor y pueden trabajar las 24 horas, aun a medianoche, cuando la ayuda humana está fuera de servicio.

Los quioscos de los hoteles listan los restaurantes cercanos, mapas de ciudad, programación de vuelos y proporcionan servicios al cliente, como pedir la cuenta del hotel.

A menudo se conectan impresoras para que los usuarios puedan obtener una copia impresa de la información.

Los quioscos de museos se utilizan no sólo para guiar a los visitantes a través de las exposiciones, sino también dar más profundidad a cada exhibición, permitiendo a los visitantes revisar información detallada específica de cada vitrina.

El poder de multimedia en lugares públicos es parte de la experiencia de muchos miles de años: los cantos místicos de los monjes, cantores y chamanes acompañados por potentes estímulos visuales, iconos en relieve y persuasivos textos han sido conocidos para producir respuestas efectivas.

Multimedia Realidad Virtual:

En multimedia, donde la tecnología y la invención creativa convergen, se encuentra la realidad virtual, o VR (Virtual Realy).

Los lentes cascos, guantes especiales y extrañas interfaces humanas intentan colocarlo dentro de una experiencia parecida a la vida misma.

La realidad virtual requiere de grandes recursos de computación para ser realista. En ella, su ciberespacio está hecho de miles de objetos geométricos dibujados en

un espacio tridimensional: entre más objetos y más puntos describan los objetos, mayor será la resolución y su visión será más realista.

A medida que se mueve, cada movimiento o acción requiere que la computadora recalcule su posición, ángulo, tamaño y forma de todos los objetos que conforman su visión, y muchos cientos de cálculos deben hacerse a una velocidad de 30 veces por segundo para que parezca fluida.

La mayoría de los actuales programas de diseño asistidos por computadora (CAD) ofrecen capacidades de tercera dimensión; muchos incluso proporcionan facilidades para crear recorridos en formato de película digital.

Recientemente se han construido videojuegos públicos especializados para ofrecer experiencias de vuelo y combate de realidad virtual por cierta tarifa.

Del Virtual World Entertainment en Walnut CreeK, California, y Chicago, Illinois, por ejemplo, Battle Tech es un encuentro en video interactivo de diez minutos con robots hostiles.

La realidad virtual es una extensión de multimedia que utiliza los elementos básicos de ésta década, como imágenes, sonido y animación.

Puesto que requiere de retroalimentación por medio de cables conectados a una persona, la realidad virtual es tal vez multimedia interactiva en su máxima expresión.

INTERFACE DE CONTROL DE MEDIOS Como se muestra en la Figura, Windows proporciona a la interface de control de

medios ( Media Control Interface, MCI) un método de software unificado, manejado por órdenes para comunicarse con dispositivos periféricos de multimedia.

Utilizando los controladores apropiados (normalmente suministrados por el fabricante del dispositivo), puede manejar el dispositivo con cadenas simples de órdenes o códigos enviados al MCI.

Elementos de un Sistema Multimedia Ordenadores

En términos informáticos, ya quedan lejos los tiempos en los que la multimedia significaba un hardware altamente específico y tremendamente caro.

El advenimiento de la informática personal ha acercado las posibilidades multimedia a los usuarios domésticos.

Es curioso, sin embargo, que los inventores del GUI (Graphical User Interface), el PARC de Xerox, no se dieran cuenta de la potencialidad que tenía aquél innovador medio gráfico de manejar el ordenador con un ratón y abstracciones visuales y transmitieran la tecnología a Apple.

A partir de esa primera integración de gráficos que incorporaba un fantástico complemento al texto probablemente nació lo que hoy entendemos por multimedia.

Elementos de un Sistema Multimedia

7.1.1. Macintosh Al ser el primer ordenador que incorporaba un GUI de forma nativa en

su sistema operativo, también es el primero que empieza a incorporar posibilidades multimedia: · Sonido. Desde el primer Mac de 1984 la reproducción de sonido

está incorporada en el ordenador, sin hardware adicional. Los modelos de los últimos años (powermacs, quadras, performas) pueden también digitalizarlo.

· Gráficos. El hecho de que el Mac sea una plataforma tradicionalmente elegida por grafistas no es casualidad. Una serie de rutinas gráficas llamadas QuickDraw está incluida en ROM en el sistema operativo, y por tanto de una forma extremadamente rápida. Tras distintas versiones de QuickDraw desde la monocromo hasta la de 32 bits de color, a finales de 1995 apareció QuickDraw 3-D con la posibilidad de gestionar gráficos 3d.

· Vídeo. En 1991 Apple incorporó la tecnología QuickTime que permite la incorporación de vídeo y sincronización, completando el compromiso multimedia de los Macintosh. El formato QuickTime se comenta con más amplitud en el capítulo "Otros Medios". Las compañías multimedia de software originalmente empezaron a trabajar con Macs. No sólo el hardware, sino también los programas de desarrollo multimedia se realizaron para Macintosh.

Elementos de un Sistema Multimedia

7.1.2. PC Los PCs empezaron con retraso en el mundo de la multimedia con

respecto a los Macintosh, pero la velocidad de evolución existente tanto en hardware como en software ha posibilitado que en los últimos tiempos la velocidad de reproducción multimedia se haya igualado con los Macintosh, si no superado a costes similares, y del mismo modo el software de desarrollo multimedia, originalmente existente sólo para Mac, se encuentra ya también para PC (y a veces sólo para PC).

El tímido inicio del mundo multimedia en los PCs fue con la versión 3.1 de Windows, que incorporaba el interfaz de control de medios (MCI, Media Control Interface) que permite controlar los dispositivos multimedia mediante comandos estándar. Así, cualquier dispositivo con un controlador MCI (CD-ROMs, tarjetas de sonido, etc.) puede ser utilizado desde un programa de un modo sencillo. El hardware multimedia en el mundo PC siempre ha sido adicional, en modo de tarjetas de expansión, a la arquitectura básica del PC.

Dispositivos de Entrada Teclado

No hay mucho que comentar de los teclados, aunque realmente hay mucha investigación de ergonomía detrás del diseño de los teclados: ángulo de las teclas, resistencia a la pulsación, recorrido, etc.; tiene que ser así dados los cientos de denuncias interpuestas en los EEUU por causa de lesiones de mano y muñeca producidas por el uso contínuo del teclado.

Los últimos años empiezan a ver cambios más significativos en el teclado como la posibilidad de partirlo por la mitad para girar un ángulo la parte de cada mano, teclas especiales para Windows, inclusión de otros dispositivos como touchpads o trackballs en el mismo teclado; incorporación de lectores de bandas magnéticas, etc.

Dispositivos de Entrada Ratón

Del mismo modo que en los teclados, la funcionalidad básica de los ratones no ha cambiado significativamente, pero sí su ergonomía y los aditamentos que se han ido añadiendo.

En tecnología la mayoría de los ratones trabajan de forma mecánica, comunicando el giro de la bola situada en su parte inferior a unos sensores que captan el movimiento sobre el plano.

Hay sin embargo otros ratones de tecnología óptica, que captan el reflejo de una luz emitida por un pequeño LED sobre un tablero de ratón reflectante. Al tener menos partes móviles, este tipo de ratón tiene más vida útil, pero está menos impuesto en el mercado y por ello resulta mucho más caro, además de la obligación de mantener un tablero especial y de mantenerlo limpio (dentro de unos límites).

Otra variante interesante es la transmisión de datos realizada por infrarrojos en lugar de cable, lo que evita la dependencia de la distancia y el eterno problema de los enredos.

Entre los añadidos a los ratones está la funcionalidad de sus botones. Originalmente con dos botones, a menudo se usa ya un tercero intermedio que puede programarse por software para funcionar de la manera más adecuada para cada usuario (por ejemplo, como doble click o como botón de confirmación o de cancelación).

También empieza a ser habitual la rueda (wheel) que permite ser girada en vertical (arriba o abajo) para permitir un desplazamiento arriba o abajo en páginas Web, en procesadores de texto o en cualquier aplicación que normalmente necesitaba un desplazamiento del ratón sobre la barra de desplazamiento vertical. La rueda puede funcionar también como tercer botón.

En las versiones más modernas, existen ya ratones que con giróscopos pueden determinar desplazamientos en el espacio.

Dispositivos de Entrada Trackball

Es fundamentalmente como un ratón al revés ;-) con la ventaja de que no necesita espacio en la mesa para desplazarse.

Son bastante habituales por eso en los portátiles. Además no se enredan, no dan problemas para

desplazamientos de toda la pantalla (esos momentos en los que parece que al ratón se le ha "acabado la mesa") y posibilitan más precisión.

Joystick Históricamente se ha utilizado para juegos, de hecho en el

mundo real su concepto se ha utilizado desde el principio de los tiempos de la aviación.

Una interesante variante es el TrackPoint que incorporan algunos portátiles (IBM y Toshiba, por ejemplo) que es un mini-joystick con sensibilidad situado entre las teclas

Dispositivos de Entrada Tableta gráfica y Touchpad

Las tabletas gráficas se empezaron a utilizar en aplicaciones de CAD/CAM. Suelen ser tablas planas más o menos cuadradas que se sitúan en la mesa y reconocen la posición de un apuntador electrónico situado, a modo de bolígrafo, sobre ellas.

Su principal ventaja es la sencilla adaptación del usuario, ya que realmente es como escribir o dibujar a mano alzada en papel, algo a lo que los humanos estamos acostumbrados, con la única limitación del tamaño de la superficie de dibujo y que el dibujo se ve en la pantalla en lugar de en la misma tableta.

Por eso es el dispositivo que permite más precisión gráfica y es el elegido para aplicaciones que necesitan alta precisión como el CAD o el grafismo computarizado.

Tocar sobre la superficie puede ser interpretado de la misma forma que los clicks de ratón. El apuntador puede además tener varios botones que funcionan como los del ratón. Algunas tabletas funcionan como vectorizadores permitiendo poner un papel ya dibujado por encima de ellas y trazar con el puntero su contorno digitalizando los puntos que lo determinan.

En los últimos años las tabletas tienen además sensibilidad a la presión, con lo que por ejemplo con una presión leve se puede conseguir una línea fina y con una presión mayor se consigue un trazo más grueso.

Los touchpads no son más que tabletas manejables con el dedo, sin necesidad de un puntero especial.

Dispositivos de Entrada Scanner

Inicialmente los scanners fueron utilizados junto con software de reconocimiento de caracteres OCR y en aplicaciones de archivo digital.

Hoy también se utilizan extensivamente para captación de imágenes color y es fundamentalmente por eso por lo que han llegado a la informática doméstica, encontrándose ya a precios muy accesibles con calidades suficientes.

Hay multitud de tipos diferentes de scanners. Los más extendidos son los de mano (manualmente hay que

desplazar el scanner sobre el papel), de rodillo (el papel se introduce y el rodillo que gira va captándolo, como si fuera una impresora pero al revés) y de mesa (como una fotocopiadora, el papel se introduce por completo y se digitaliza internamente).

Dispositivos de Entrada 7.2.9. Otros dispositivos

Digitalizador de vídeo Digitalizador de audio Cámara digital Teclado MIDI y otros instrumentos OCR, eyetracking, control remoto infrarrojos, reconocimiento de

voz, dataglove... Pantalla táctil Lápiz electrónico

Dispositivos de Salida Monitor

Características: · Tamaño: pequeños (12" a 15"), medios (16" y 17") y grandes (19" a 21"). · Resoluciones permitidas (640x480, 800x600, 1024x768, 1280x1024...). · Profundidad de color permitida. · Velocidad de refresco (si no es suficiente ocurre el parpadeo). · Distancia de punto (dot pitch), la proximidad entre dos píxels contiguos de

pantalla. · Convergencia (convergence), precisión de alineamiento de los tres haces de

electrones en cada punto de pantalla. · Curvatura del monitor. · Distorsión de la imagen (¿es una circunferencia realmente circular? Todo píxel

debería ser cuadrado y las distancias verticales y horizontales entre píxels contiguos deberían ser las mismas).

· Calibrado (ajuste de color mostrado con respecto al que debería mostrar). · Control de agudeza (sharpness), brillo, contraste

Dispositivos de Salida Tarjetas aceleradoras de vídeo

Cuando se manejan 24 bits de color y pantallas de alta resolución, o se intentan visualizar 20 cuadros por segundo, la exigencia al sistema de vídeo es muy grande, y conlleva un refresco de pantalla mucho más lento que lo deseado.

Para evitar este problema, la CPU no es el único cuello de botella, y hay que recurrir a reforzar otras partes del hardware.

Es habitual entonces recurrir a tarjetas aceleradoras de vídeo que por ejemplo libran

Proceso Compresión y Codecs

Dado que muchos de los medios digitales (imagen, sonido, vídeo) son grandes consumidores de espacio, una de las claves para que, hoy por hoy, la multimedia sea posible en la práctica, es la necesidad de la compresión.

Los compresores engloban dos partes, compresión y decompresión. Usualmente la compresión es más costosa que la descompresión, si es así el algoritmo de compresión se llama asimétrico; si ambas se pueden realizar en el mismo tiempo entonces se llama simétrico.

Algunos compresores son únicamente software, aunque los más eficientes y por ello costosos suelen necesitar hardware, al menos si se quiere permitir el proceso en tiempo real.

Pérdida de información La compresión siempre funciona eliminando alguna información del medio. Si la información que se elimina es redundante o no es detectable por los

sentidos humanos, se dice que la compresión es sin pérdida (lossless compression).

Si la calidad se degrada, la compresión es con pérdida (lossy compression). · El primer tipo de compresión mantiene toda la calidad del medio

original. Por ejemplo, la técnica Animation establecida a la mayor calidad comprime vídeo sin pérdida.

· El segundo, por el contrario, pierde datos del soporte original al comprimir. Por esto sólo se suelen usar una vez (y suele ser al final), si no tienden a acumularse los defectos. Una técnica de compresión de vídeo ejemplo es Cinepak.

Proceso Tipos de Compresión

Los soportes temporales, especialmente el vídeo, admiten dos tipos de compresión:

· Espacial (Intraframe, Spatial), que trabaja con cada fotograma (frame) independientemente del resto. Esta es la técnica que se usa con medios fijos (gráficos, fotografía). ¿Cómo se reduce el tamaño de una imagen? Por ejemplo, · Una técnica para esto es la codificación de longitud y recorrido, que

sustituye áreas de color plano por una especie de fórmula. Por supuesto, esto funciona bastante mal con los sombreados.

· Otra técnica mejor a menudo es hacer compresión en base a diferencias mínimas de color y a áreas cercanas de pantalla (como hace JPEG) con cada cuadro.

· Temporal (Interframe, Temporal), usado fundamentalmente en vídeo, que busca diferencias entre cuadros. A veces esta técnica se conoce como diferenciación de cuadros (frame differencing). Para esto se toma un cuadro de referencia, cuadro clave (key frame), y los subsiguientes almacenan sólo sus diferencias con él. Esto es especialmente favorable cuando el enfoque es fijo y el fondo

no cambia. Por supuesto a menudo hay cambios de enfoque, zooms, travellings, etc.; el software de compresión debe detectar eso (reconociendo que la mayoría del frame cambia) para determinar la aparición de un nuevo cuadro clave.

Proceso Codec

Los codecs son los módulos de software que comprimen y descomprimen multimedia digital. Así, si queremos comprimir o descomprimir formato JPEG tenemos que añadir a nuestro sistema un codec jpeg. · La efectividad de un codec se mide con dos variables:

· La razón de compresión (compression rate, tamaño original / comprimido).

· El tiempo de compresión/descompresión. (dependiendo de la simetría del codec).

QuickTime incluye en la versión 2.5 los siguientes codecs: · Animation. Usa un algoritmo que es muy eficiente para animaciones generadas por

computadora, o secuencias de imágenes de pantalla (demos o tutoriales de programas, p. ej.) · CinePak. Es muy lento en compresión, por lo demás todo son ventajas. Trabaja en 16 o 24

bits . Es el formato ideal si no se puede utilizar MPEG. · Component Video. Tiene un ratio de compresión bajo (2:1). Por eso se utiliza sólo en fases

de archivo usualmente, o para edición de vídeo. · Graphics. Es preferible al Animation sólo si es más importante el espacio que el tiempo

(trabaja bastante más lento en la codificación pero produce ficheros más comprimidos, sobre la mitad). La decompresión es aproximadamente el doble de lenta.

· Indeo. Parece ligeramente inferior a CinePak; sólo lo mejora en vídeo tipo "cabeza parlante", con fondos grandes y constantemente fijos.

· None. Parece una tontería pero no hace ninguna compresión. Se puede utilizar, eso sí, para cambiar el número de bits por píxel (pixel depth). Básicamente se usa para primeros almacenamientos (rara vez para obtener el formato final).

· Photo (JPEG). Es mejor para fotos del mundo real (sombras, variación de colores), sin bordes contrastados. Los ratios de compresión suelen estar entre 5:1 y 50:1 (resultados decentes entre 10:1 y 20:1)

Almacenamiento Discos y RAID

Los discos en multimedia deben ser grandes y rápidos, para soportar la necesidad de almacenamiento de datos, y para poder almacenar o leer esos datos sobre la marcha.

En multimedia es usual utilizar un RAID (Redundant Array of Inexpensive Disks), un agrupamiento de discos que funcionan en conjunción.

Tiene al menos dos discos y puede configurarse para repartirse la carga de modo que se reduce el tiempo de acceso y se acelera la velocidad de transferencia.

También se puede hacer que unos discos repliquen a otros para que, en caso de fallo en un disco, los datos no se pierdan y se pueda seguir funcionando.

Las tres ventajas fundamentales del RAID son: · Mejorar la tolerancia a fallos y facilitar la recuperación de

datos · Aumentar la capacidad de almacenamiento (sin elevar el

costo tecnológico) · Mejorar el rendimiento conjunto (sin elevar el costo)

Almacenamiento RAID no es una idea nueva, realmente existía desde hace tiempo en mainframes. Hay varios tipos de

sistemas RAID: · RAID Nivel 0 - Disk Striping (segmentos sin redundancia)

· La velocidad de transferencia se multiplica. · No aporta seguridad de datos (redundancias): si un disco falla el sistema completo falla.

· RAID Nivel 1 - Disk mirroring (redundancia total) · Además de striping hay duplicados de cada fichero en discos separados · Si un disco falla, su imagen se utiliza en su lugar

· RAID Nivel 2 - Bit interleaving of data · Se separan los bits en distintos discos. · La controladora es especial, en uno o varios canales SCSI (array controller). · Los discos funcionan sincronizados, pista a pista (lógicamente son como un único disco). · Algunos discos almacenan códigos de detección y corrección de error (hamming error correction

code), por ejemplo 3 discos de detección para 8 de datos. · Si un disco falla, los datos se pueden reconstruir partiendo de los discos de corrección. · Si falla el de detección de error, se reconstruye partiendo de los datos.

· RAID Nivel 3 - Bit interleaving with dedicated parity drives · Como RAID 2. Puede estar separada en bits o bytes. · Pero sólo paridad (un único disco), no corrección de error.

· RAID Nivel 4 - Sector interleaving of data with dedicated parity drive (separación en sectores) · Separación en sectores (en lugar de bits), con un disco de paridad

· RAID Nivel 5 - Block interleaving of data · Separación en bloques. · Sin disco de paridad dedicado, la paridad se reparte por los discos. · Pueden hacerse escrituras y lecturas paralelas (no hay un único disco de paridad que obligue a los

demás a "esperar").

Almacenamiento CD

El CD es uno de los motores de la multimedia. Permite un almacenamiento de unos 650 Mb, los reproductores han llegado a ser

baratos y el soporte reduce al mínimo el costo por megabyte. Por ello se ha convertido en el soporte ideal no sólo para material multimedia, sino

para distribución de todo tipo de software. Es raro ver fabricantes de soft que sigan suministrando disquetes. La historia de los CDs, a pesar de su relativa juventud, es bastante intensa, y la

estandarización se adhiere a un grupo de colores: · El libro rojo define el soporte físico y el original CD de audio (70s). · El libro amarillo (80s) define el CD-ROM, con una extensión para CD-ROM XA

(eXtended Architecture). · El libro verde completa esta extensión definiendo el CD-i. · El libro naranja define discos magneto-ópticos como el minidisco, y el formato

de los CDs escribibles o multi-sesión. El Photo CD de Kodak utiliza esta norma. · El libro blanco especifica el Video-CD usando MPEG con la opción de

interacción simple. · El libro azul define una extensión multimedia al CD audio, el CD+ o CD

extendido. Hay otros estándares relacionados con los CDs, como el ISO 9660 (también

llamado CD-ISO), que especifica la estructura de ficheros, y puede ser leído en un gran número de plataformas.

El CD va a seguir siendo el mayor método soporte de multimedia por unos años. Al menos hasta el advenimiento del DVD, cuya lectura (todavía no la escritura) empieza a estar al costo del CD.

Almacenamiento CD

Capacidad:Un CD y sus 650 Mb. potenciales permiten aproximadamente:

· 250.000 páginas de texto A4. · 7.000 imágenes en color de calidad fotográfica. · 72 minutos de animaciones gráficas o vídeo a

pantalla completa con audio (con MPEG). · 74 minutos de audio con calidad digital (CD audio

normal) · 2 horas de audio estéreo comprimido. · 19 horas de audio mono comprimido con una

frecuencia de 8 KHz.

Almacenamiento DVD

DVD significó originalmente Disco de Vídeo Digital (Digital Video Disk), después Disco Digital Versátil (Digital Versatile Disk) aunque se suele obviar el significado de las siglas y simplemente decir "DVD"

DVD define discos y reproductores que usan un estándar de alta densidad de CD-ROM que está considerándose por un consorcio de diez grandes empresas de entretenimiento, electrónica de consumo y ordenadores.

El objetivo es obtener un estándar que soporte un grupo de posibilidades para entretenimiento doméstico y para el mundo de la computación, que finalmente puede reemplazar al CD-ROM, CD de audio, vídeo, etc.

Productos relativos al DVD El producto "bandera" del DVD para el mercado doméstico es el DVD-Vídeo, un

sistema con reproductor específico (de concepto similar al reproductor doméstico de CD audio) que permite reproducir contenido de vídeo con calidad digital en duración suficiente para contener una película. La capacidad del DVD permite almacenar adicionalmente varias pistas de audio e incluso información textual adicional.

Tan importante como él es el DVD-ROM, una especificación para aplicaciones de ordenador abierto a cualquier posibilidad de almacenamiento masivo de datos del estilo del CD-ROM.

Otras posibilidades están abiertas, como utilizarlo para música y sonido (DVD-Audio), permitir grabado simple y múltiple (DVD-Recordable, DVD-RAM), o DVD interactivo (DVD-i).

Almacenamiento DVD

Capacidad del DVD El DVD tiene más densidad de información que el CD en el mismo espacio. Puede tener hasta 4 capas de datos, dos en cada cara. La capacidad total máxima (DVD-ROM) es de 9,4 Gb (4,7 para una cara) para

una capa, 17 Gb (8,5) para dos. Todavía hay bastantes cuestiones abiertas y diferencia de formatos, lectoras

que no permiten leer CD-R, etc. La definición de DVD-ROM disminuye la capacidad de 4,7 a 3,6 Gb. El DVD-RAM lo hará a 2,6 Gb. Actualmente es normal que sólo se funcione por una cara, como es el caso del

CD. Compatibilidad

La compatibilidad con los CDs depende de los reproductores. Lógicamente el mercado preferirá elegir los más compatibles posibles, por lo

que los lectores de DVD-ROM usualmente permiten leer también CD-ROM. De la misma forma algunos reproductores de DVD-Vídeo permiten reproducir

VideoCD, o CD-i. Los productores de material audiovisual se han puesto de acuerdo para

proteger el DVD-Vídeo contra la piratería, por lo que las películas originales no pueden ser copiadas utilizando grabadoras normales de DVD (al menos de momento).

También se han definido regiones geográficas incompatibles de modo que, por ejemplo, un DVD-Vídeo producido en EEUU no será leido en reproductores europeos.

Almacenamiento DVD

Capacidad del DVD El DVD tiene más densidad de información que el CD en el mismo espacio. Puede tener hasta 4 capas de datos, dos en cada cara. La capacidad total máxima (DVD-ROM) es de 9,4 Gb (4,7 para una cara) para

una capa, 17 Gb (8,5) para dos. Todavía hay bastantes cuestiones abiertas y diferencia de formatos, lectoras

que no permiten leer CD-R, etc. La definición de DVD-ROM disminuye la capacidad de 4,7 a 3,6 Gb. El DVD-RAM lo hará a 2,6 Gb. Actualmente es normal que sólo se funcione por una cara, como es el caso del

CD. Compatibilidad

La compatibilidad con los CDs depende de los reproductores. Lógicamente el mercado preferirá elegir los más compatibles posibles, por lo

que los lectores de DVD-ROM usualmente permiten leer también CD-ROM. De la misma forma algunos reproductores de DVD-Vídeo permiten reproducir

VideoCD, o CD-i. Los productores de material audiovisual se han puesto de acuerdo para

proteger el DVD-Vídeo contra la piratería, por lo que las películas originales no pueden ser copiadas utilizando grabadoras normales de DVD (al menos de momento).

También se han definido regiones geográficas incompatibles de modo que, por ejemplo, un DVD-Vídeo producido en EEUU no será leido en reproductores europeos.

Estándares Multimedia Acrobat

Acrobat es un sistema de intercambio y distribución de documentos, desarrollado por Adobe Systems Inc. En junio de 1993.

Esta aplicación puede procesar cualquier tipo de documento, independientemente de qué gráficos y tipos de letra contiene.

Lo único necesario en el ordenador cliente es tener un visor Acrobat (y este visor se distribuye sin costo).

Acrobat es sencillo de manejar, ya que se configura como una impresora "virtual" que genera un documento con formato PDF (Portable Document File), realmente una variante compacta de PostScript nivel 2.

El sistema Acrobat incluye varios programas. Los más fundamentales son: · Acrobat Exchange, una aplicación que permite crear, ver, y navegar por ficheros PDF.

También genera thumbnails (versiones de baja resolución para transmisión y visualización rápida).

· Acrobat Distiller, un intérprete PostScript que convierte cualquier fichero PS o EPS a PDF. · Acrobat Reader, el navegador/visor/impresor de documentos PDF, que es el que se

distribuye gratuitamente. · PDF Writer, el driver de impresora para crear ficheros PDF desde cualquier aplicación.

Adicionalmente a un texto convencional (maquetación de texto y gráficos), el formato Acrobat permite enlaces de hipertexto.

En las últimas versiones el formato Acrobat está evolucionando hacia Internet, permitiendo soporte a documentos SGML estándar, o enlazar con documentos HTML en Internet.

La principal desventaja de Acrobat con respecto a otros sistemas de representación textual es que no soporta tipos de letra TrueType (Windows).

Sin embargo, su relación con PostScript y la importancia de Adobe en el mundo de la composición gráfica y de texto ha hecho que se convierta en un estándar de hecho para la difusión de documentos electrónicos, especialmente en el mundo científico y técnico.

Es decir, allí donde se elabora un documento para formato impreso y se quiere una conversión sencilla y sin rescritura real a formato electrónico.

Estándares Multimedia DirectX

Microsoft® DirectX® es el grupo de tecnologías integradas en Windows para ampliar sus características multimedia nativas. DirectX forma parte de Windows 98 y Windows 2000.

DirectX ofrece una API (Application Programming Interface) que permite al programador acceso a facilidades multimedia del hardware (como aceleradoras de vídeo y tarjetas de sonido) de un modo estándar -simulando si es necesario algunas facilidades por software-, y posibilitando mejor rendimiento que con librerías tradicionales.

DirectX está formado por una serie de componentes independientes, que son: · Direct3D: Gestión de gráficos 3-d de bajo nivel. Permite, por ejemplo: Buffering (z-buffers o

w-buffers), sombreado, fuentes y tipos de luz múltiples, soporte de materiales y texturas, transformaciones 3-d...

· DirectDraw: Permite manipular la memoria de vídeo directamente. Esto es especialmente útil para juegos, animaciones, gráficos interactivos, etc.

· DirectInput: Posibilita la relación con distintos dispositivos de entrada: joysticks, ratón con varios botones, volantes, cascos de Realidad Virtual... Amplía la serie de dispositivos normalmente reconocidos y además la controlabilidad es mayor, especialmente en velocidad.

· DirectMusic: Maneja música estilo MIDI. · DirectPlay: Interfaz de alto nivel entre aplicaciones y servicios de comunicación,

especialmente pensado para juegos multijugador a través de Internet, un módem o una red local.

· DirectSound: Captura y reproduce sonido digital muestreado. Permite mezcla en reproducción, usar sonido 3-d, voz digitalizada, etc.

· DirectShow: Parte orientada a la multimedia dinámica. Permite capturar y reproducir streams de vídeo o audio en varios formatos.

Para posibilitar la estandarización, DirectX contiene una capa llamada HEL (hardware emulation layer) que contiene controladores software que simulan el hardware para el caso de que el ordenador específico no permita alguna característica (como uso de gráficos 3-d sin aceleración 3-d). También existe otra capa, HAL (hardware abstraction layer) que permite por software homogeneizar la relación con distintas tarjetas que hacen las mismas cosas de distintos modos.

Estándares Multimedia MPEG-4

MPEG-4 (ISO 14496) está parcialmente basado en las ideas de QuickTime, y permite integrar todo tipo de multimedia digital, soportando además streaming (reproducción progresiva) en tiempo real.

Es un estándar publicado a finales de 1998, con una revisión en octubre de 1999 de cara a la versión 2. Permite, entre otras cosas: · Representar unidades de contenido multimedia llamados objetos media (media objects). · Describir la composición de los objetos para formar escenas · Sincronizar los datos asociados con los distintos objetos · Transmitir y visualizar la composición de una forma independiente de máquina · Interactuar finalmente con la escena · Añadir información de propiedad intelectual

MPEG-4 está diseñado fundamentalmente para tres campos de aplicación: · Televisión digital · Aplicaciones gráficas interactivas · Multimedia interactiva (incluyendo la Web)

Permite integrar la producción, distribución y acceso al contenido en cualquiera de estos tres campos.

Para los autores, permite crear contenido muy reusable y flexible y proteger mejor los derechos de propiedad sobre los contenidos.

En la versión 2 del MPEG-4 se incluirán algunas otras cosas como: · Funcionalidades de multiusuario · Mayor compatibilidad con VRML y modelos 3-d · Formato de fichero específico de MPEG-4 (MP4) · MPEG-J para interactuar con el soporte MPEG-4 desde Java

Estándares Multimedia QuickTime

QuickTime es un estándar desarrollado por Apple Computer para gestionar información multimedia a nivel de ficheros y de sistema operativo.

Funciona con los sistemas Macintosh, Windows y SGI. Apareció en el mercado en 1991 y liberado a desarrolladores y demás en 1992. Con el tiempo, se ha convertido en el estándar multimedia fundamental, tanto en

Windows como en Macintosh. Tanto es así que QT es el punto de partida para la norma de vídeo ISO MPEG-4, con

la propuesta presentada por Apple, IBM, Netscape, Oracle, Silicon Graphics y Sun Microsystems.

Posibilidades En principio, QuickTime es software a nivel de sistema, o más bien una

extensión de sistema, que permite a los usuarios combinar y sincronizar animación, vídeo, gráficos y sonido, incorporando esto en aplicaciones Mac (y Windows) de todo tipo.

De hecho, permite editar y manipular información dinámica multimedia (time-based media) de forma que garantiza la compatibilidad a nivel de archivos entre distintas plataformas.

QT integra características estándares de interfaz, de reproducción y de compresión/descompresión en múltiples plataformas; es una tecnología madura (la multimedia en Apple tiene bastantes más años, y expertos, que en Windows) y actualmente es lo más cercano que existe a un estándar en multimedia.

Estándares Multimedia QuickTime

Qué incluye QuickTime Muchos conocen QT por el vídeo digital, pero en realidad incluye muchos más

medios, estructurados en dos grandes tipos de datos: Pictures (imágenes, datos estáticos) y Movies (datos temporales). Esto es: · Audio digital comprimido en IMA. · QuickTime MIDI. · Gráficos de 24 bits. · Realidad Virtual (QTVR). · Texto. · Gráficos en 3D. · Animación en 3D. · Animaciones basadas en cuadros y en sprites. · Vídeo digital. · Vídeo con streaming, etc.

Cada medio se almacena en una pista separada y pueden ser sincronizados para una reproducción consistente y casi independiente de plataforma. Aparte de haber muchos programas que los generan o importan directamente, existen multitud de conversores. Además, el diseño (teóricamente) es abierto, de modo

Estándares Multimedia SMIL

SMIL es uno de los próximos estándares más interesantes en multimedia. Diseñado por el W3C, el SMIL (Synchronized Multimedia Integration

Language, pronunciado como smile) permite realizar presentaciones estilo TV o cursos interactivos multimedia, especialmente en entornos Web.

El lenguaje SMIL es parecido al HTML, basado en etiquetas, y puede por ello ser fácilmente utilizado para la creación, con un simple editor de texto.

Una presentación SMIL puede contener audio, vídeo (progresivos), imágenes, texto o cualquier otro formato multimedia.

La sincronización se puede controlar de una forma precisa, así como el diseño de la presentación en la pantalla.

También se pueden asociar hiperenlaces con los distintos objetos. El lenguaje está definido con XML. Podríamos decir que SMIL es una manera declarativa de definir lo que se

expresa gráficamente con una herramienta de autor. Si instalamos un reproductor (player) SMIL pueden entonces reproducirse

esos ficheros de una forma independiente de plataforma.

Estándares Multimedia (8) SVG

SVG son las siglas de Gráficos Vectoriales Escalables (Scalable Vector Graphics), y es un lenguaje de descripción de gráficos vectoriales y bitmap 2-d, definido en XML.

Se define como un estándar abierto, y el grupo de trabajo de SVG integra a los más importantes fabricantes de software y hardware, como Adobe, Apple, Autodesk, HP, IBM, Macromedia, Microsoft, Netscape, Sun, Xerox y el W3C.

Esto lo hace un gran candidato a ser introducido en prácticamente todos los navegadores (por un lado) y en el software de diseño gráfico y multimedia (por otro).

SVG se integra en el resto de estándares en proceso desde el W3C, como DOM, CSS, XML, SMIL, etc.

El grupo de trabajo se creó para integrar los anteriores esfuerzos no concluidos en definición de lenguaje de definición vectorial, VML (Vector Markup Language) y PGML (Precision Graphics Markup Language).

SVG pretende paliar una de las graves carencias de HTML, la no integración de gráficos vectoriales.

SVG permite tres tipos de objetos gráficos: formas gráficas vectoriales, imágenes bitmap y texto.

Estos objetos gráficos se pueden agrupar, parametrizar, transformar y componer. Pueden usarse transparencias, trayectorias, efectos de filtro y plantillas. Los objetos pueden ser interactivos y dinámicos. Las animaciones pueden realizarse de forma declarativa (utilizando objetos de

animación SVG) o con scripting. Este lenguaje de script accede a través del modelo de objetos de documento

(DOM, Document Object Model) de SVG, que permite acceso total a todos los elementos y sus atributos y propiedades.

Video ¿Qué es la luz?

La luz es una forma de energía que tiene dos aspectos: un aspecto de onda electromagnética un aspecto corpuscular (fotones)

La luz emitida por el sol viaja a una velocidad de aproximadamente 300.000 km/s con una frecuencia de aproximadamente 600.000 GHz.

Video ¿ El concepto de color

El color de la luz depende de la frecuencia, que a su vez depende de la longitud de onda y la velocidad del frente de onda. La longitud de onda es un fenómeno oscilatorio que se caracteriza generalmente por la relación:

&#955; = CTdonde:

λ representa la longitud de onda C representa la longitud de los frentes de onda T indica el período de la onda (en segundos)

Video ¿ El concepto de color

La radiación que comprende una sola longitud de onda se llama radiación monocromática y la radiación que contiene varias longitudes de onda se llama radiación policromática.

La agrupación de todas las longitudes de onda que componen la radiación policromática (y sus intensidades luminosas respectivas) se denomina espectro.

No obstante, el ojo humano no es capaz de distinguir los diversos componentes de esta radiación y percibe solamente el resultado, que es una función de las diferentes longitudes de onda que comprende y la intensidad luminosa respectiva.

El ojo humano puede ver radiación con longitudes de onda entre 380 y 780 nanómetros.

La radiación con longitudes menores de 380 nm se denomina radiación ultravioleta, mientras que la radiación con longitudes de onda mayores de 780 nm se llama radiación infrarroja.

El rango de las longitudes de onda que es visible para el ojo humano se denomina "espectro visible":

Es posible separar los colores del espectro con un prisma de cristal.

Video El funcionamiento del ojo humano

Gracias a la córnea (la envoltura traslúcida del ojo) y el iris (que al cerrarse permite regular la cantidad de luz que se introduce en el ojo), se forma una imagen en la retina.

Esta última está formada por bastones y conos. Los bastones, que contienen un pigmento llamado rodopsina y

que se encuentran en la periferia de la retina, permiten la percepción de la luminosidad y el movimiento (visión escotópica), mientras que los conos, ubicados en una región llamada fóvea, hacen posible la diferenciación de los colores (visión fotópica).

En realidad, existen tres clases de conos: Los que son principalmente sensibles a la radiación roja (570 nm),

llamados rojos Los que son principalmente sensibles a la radiación verde (535 nm),

llamados verdes Los que son principalmente sensibles a la radiación azul (445 nm),

llamados azules

Video El funcionamiento del ojo humano

Es por esto que cuando falta un tipo de cono, la percepción de los colores no es perfecta.

Esta condición se conoce como daltonismo (o dicromasia). Según el tipo de cono defectuoso, las personas con esta anomalía de la visión se conocen como: Protanopes, que son sumamente insensibles al rojo Deuteranopes, que son sumamente insensibles al

verde Trinatopes, que son sumamente insensibles al azul

Video El funcionamiento del ojo humano

Además, debe tenerse en cuenta que la sensibilidad del ojo humano a las intensidades luminosas que están relacionadas con los tres colores primarios no es la misma:

Video Síntesis aditiva y sustractiva

Existen dos tipos de síntesis de color: La síntesis aditiva resulta de la adición de componentes de

la luz. Los componentes de la luz se agregan directamente a la emisión; éste es el caso de los monitores o los televisores a color. Cuando se agregan los tres componentes, rojo, verde, azul (RGB), se obtiene blanco. La ausencia de componentes produce negro. Los colores secundarios son cian, magenta y amarillo porque: verde combinado con azul produce cian azul combinado con rojo produce magenta verde combinado con rojo produce amarillo

Video Síntesis aditiva y sustractiva

Existen dos tipos de síntesis de color: La síntesis sustractiva permite restaurar un color mediante la sustracción,

comenzando de una fuente de luz blanca, con filtros para los colores complementarios: amarillo, magenta y cian. La adición de filtros para los tres colores produce el negro y su ausencia produce el blanco.

Cuando la luz ilumina un objeto, algunas longitudes de onda se sustraen porque son absorbidas por el objeto. Lo que vemos es la combinación de las longitudes de onda que son reflejadas o transmitidas (es decir, las que no son absorbidas). Este proceso se utiliza en fotografía y para la impresión de colores. Los colores secundarios son el azul, el rojo y el verde: El magenta (color primario) combinado con cian (color primario) produce

azul El magenta (color primario) combinado con amarillo (color primario) produce

rojo El cian (color primario) combinado con amarillo (color primario) produce

verde

Representación computarizada del color Las representaciones del color

Para poder procesar los colores de forma correcta e intercambiar información colorimétrica, es necesario contar con los medios necesarios para categorizarlos y seleccionarlos.

Por lo tanto, es común tener la opción de color de un producto, incluso antes de que haya sido fabricado.

En este caso, se muestra una paleta de la que se elige el color adecuado. En la mayoría de los casos, el color del producto (un vehículo, un edificio, etc.) corresponde al

color seleccionado. De la misma manera, en Informática es esencial contar con los medios para seleccionar un color

entre todos los disponibles. Sin embargo, la posible gama de colores es muy vasta y la cadena de procesamiento de

imágenes atraviesa varios dispositivos periféricos: por ejemplo, un digitalizador (escáner), luego un software editor de imágenes y finalmente una impresora.

Por lo tanto, es necesario poder representar los colores de manera fiable para poder asegurar una coherencia entre todos estos dispositivos periféricos.

Entonces a la representación matemática de un conjunto de colores se la denomina "espacio de colores".

Existen varios. Los más conocidos son: Codificación RGB (Rojo, Verde, Azul). Codificación HSL (Matiz, Saturación, Luminancia). Codificación CMYK. Codificación CIE. Codificación YUV.

Codificación YIQ. Al espectro de colores que un dispositivo periférico de visualización permite

mostrar se lo denomina gama o espacio colorimétrico. A los colores que no pertenecen a la gama se los llama colores fuera de gama.

El factor gama Al criterio que define el carácter no lineal de la intensidad lumínica de un elemento

se lo denomina factor gama. Por lo tanto, la luminancia de la pantalla de un ordenador es no lineal siempre y

cuando: la intensidad lumínica que emita no sea linealmente proporcional al voltaje

aplicado sino que corresponda a una curva funcional de la pantalla gama (generalmente oscila entre 2,3 y 2,6):

I ~ Vgama

la intensidad lumínica que perciba el ojo no sea proporcional a la cantidad de luz que se emite realmente

Para poder resolver esto y obtener una reproducción satisfactoria de la intensidad lumínica, se puede compensar la luminancia aplicando una ecuación denominada "corrección de gama".

Por lo tanto, hay una ecuación de gama que corresponde a cada dispositivo de visualización periférico, el cual puede adaptarse a la percepción del usuario.

La administración del color Resulta fácil comprender el interés con respecto a los colores de

las imágenes que atraviesan varios dispositivos periféricos (una cadena digital compuesta por ejemplo, por el escáner, el software editor de imágenes y luego la impresora) para asegurar que la imagen resultante mantenga colores similares a los de la imagen original.

A las operaciones necesarias para garantizar la buena conservación de los colores de una imagen se las denomina "administración del color ".

Para poder garantizar la coherencia de los colores, es esencial calibrar (o medir) todos los dispositivos o herramientas de la cadena digital.

Por lo tanto, la calibración (o medición) de un dispositivo o herramienta consiste en describir todos los colores que este dispositivo pueda adquirir o producir (es decir, su gama) en un espacio de color independiente (por ejemplo, CIE Lab o CIE XYZ) en un archivo llamado perfil ICC (Consorcio internacional del color, del inglés International Color Consortium).

El perfil ICC se integra a la imagen y transmite todo el conjunto de transformaciones que ésta sufrió durante la cadena de procesamiento de imágenes en un registro de seguimiento.

Codificación CIE / L*a*b Codificación CIE

Los colores pueden percibirse de forma diferente según cada individuo y pueden visualizarse de forma diferente según los dispositivos periféricos de visualización.

Por lo tanto, la Comisión Internacional de la Iluminación (Commission Internationale de l'Eclairage, CIE) definió los estándares que permiten definir el color, independientemente de los dispositivos periféricos que se utilicen.

Por este motivo, la CIE definió el criterio basándose en la percepción del color que tiene el ojo humano, gracias a un estímulo triple.

En 1931, la CIE desarrolló el sistema colorimétrico xyY que permite representar colores según su cromatismo (ejes X e Y) y su luminancia (eje Y).

El diagrama de cromatismo (o diagrama cromático) es el resultado de una ecuación matemática y muestra los colores puros en la periferia, es decir, la radiación monocromática correspondiente a los colores del espectro (los colores del arco iris), indicada por su longitud de onda.

A la línea que conecta los extremos del diagrama (por lo tanto, la que conecta los dos extremos del espectro visible) se la llama línea de púrpuras pues corresponde al color púrpura, que está compuesto por dos rayos monocromáticos, el azul (420 nm) y el rojo (680 nm).

Codificación CIE / L*a*b Codificación CIE

La gama de un dispositivo de visualización por lo general se representa al trazar en el diagrama cromático un polígono que contenga todos los colores que el dispositivo sea capaz de producir.

Sin embargo, este tipo de representación es puramente matemática y no tiene en cuenta factores fisiológicos, es decir, la percepción que tiene el ojo humano del color, que da como resultado un diagrama de cromatismo que deja demasiado espacio para la gama de los verdes.

En 1960, la CIE desarrolló el modelo Lu*v*. Finalmente, en 1976, para superar los problemas del modelo xyY, la CIE desarrolló

el modelo colorimétrico La*b* (también llamado CIELab), en el que se indican los colores según tres valores: L, luminancia, expresado como porcentaje (desde el 0, que indica negro, hasta

el 100, que indica blanco) a y b dos gamas de colores, desde el verde hasta el rojo y desde el azul hasta

el amarillo respectivamente, con valores que van del -120 al +120. Por lo tanto, el modo Lab abarca todo el espectro de visión del ojo humano y lo

representa de manera uniforme. Esto hace posible describir todos los colores visibles independientemente de cualquier tecnología gráfica.

Incluye todos los colores RGB (rojo, verde, azul) y CMKY (cian, magenta, amarillo, negro). Es por ello que, software como PhotoShop por ejemplo, utiliza este modo para pasar de un modelo de representación a otro.

Este modo es muy utilizado en la industria y a pesar de esto, no se ve muy favorecido por la mayor parte del software, ya que es difícil utilizarlo.

Los modelos CIE no son intuitivos, sin embargo, ¡su utilización garantiza que todos podamos ver un color creado por estos modelos de la misma manera!

Codificación CIE / L*a*b Codificación CIE

Código RGB Código RGB

El código RGB (rojo, verde, azul), desarrollado por la Comisión Internacional de Iluminación (Commission Internationale de l'Eclairage, CIE) consiste en la representación del espacio de color a partir de tres rayos monocromáticos, con los siguientes colores: rojo (con una longitud de onda de 700,0 nm), verde (con una longitud de onda de 546,1 nm), azul (con una longitud de onda de 435,8 nm).

Este espacio de color corresponde a la forma en que los colores generalmente se codifican en un equipo, o más precisamente, a la forma en que los tubos catódicos de la pantalla del equipo representan los colores.

El modelo RGB propone que cada componente de color se codifique en un byte, que corresponde a 256 intensidades de rojo (28), 256 intensidades de verde y 256 intensidades de azul. De esta manera, hay 16777216 posibilidades teóricas de colores diferentes, es decir, muchas más de las que el ojo humano puede distinguir (aproximadamente 2 millones). No obstante, este valor es sólo teórico porque depende en gran medida del dispositivo de visualización que se utilice.

Dado que el código RGB está basado en tres componentes con el mismo rango de valores propuesto, generalmente se representa en forma gráfica con un cubo del cual cada eje corresponde a un color primario:

Código HSL Código HSL

El modelo HSL (Matiz, Saturación, Luminosidad), basado en el trabajo del pintor Albert H.Munsell (quien creó el Munsell Atlas), es un modelo de representaciones considerado "natural", ya que se acerca bastante a la percepción fisiológica del color que tiene el ojo humano.

En efecto, el modelo RGB (rojo, verde, azul) puede resultar adecuado para la representación de colores en el equipo o para su presentación en dispositivos de visualización, pero no permite seleccionar los colores con facilidad.

Por lo general, el ajuste de colores RGB con herramientas informáticas se realiza mediante tres bloques deslizantes o tres celdas con los valores relativos de cada componente primario; no obstante, para aclarar un color se requiere que los valores respectivos de cada componente se incrementen de forma proporcional.

Para superar este problema del modelo RGB (rojo, verde, azul), se desarrolló el modelo HSL.

El modelo HSL consiste en descomponer el color según criterios fisiológicos: Matiz, que corresponde a la percepción del color (una camisa malva o

anaranjada), Saturación, que describe la pureza del color, es decir, la intensidad o

palidez del mismo (una camisa nueva o descolorida), Luminosidad, que indica la cantidad de luz del color, es decir, el

grado de claridad u oscuridad de un color (una camisa en el sol o en la sombra).

Código HSL Código HSL

El gráfico siguiente es una representación del modelo HSL, donde el color se representa mediante un círculo cromático, y la luminosidad y la saturación se representan mediante dos ejes:

El modelo HSL se desarrolló con el objetivo de permitir una rápida selección de colores interactiva; no obstante, no está adaptado para la descripción cuantitativa de un color.

Existen otros modelos de representación naturales estrechamente relacionados con el modelo HSL: HSB : Matiz, Saturación, Brillo. El brillo describe la percepción de la

luz emitida por una superficie. HSV : Matiz, Saturación, Valor. HSI : Matiz, Saturación, Intensidad. HCI : Matiz, Crominancia, Intensidad.

Codificación CMYK Codificación CMY

La codificación CMY (Cyan, Magenta, Yellow, o Cian, Magenta, Amarillo en español, CMA) es a la síntesis sustractiva lo que la codificación RGB es a la síntesis aditiva.

Este modelo consiste en dividir un color en valores de cian, magenta y amarillo.

La ausencia de estos tres componentes da como resultado blanco mientras que la suma de ellos da como resultado negro.

Sin embargo, como el negro que se obtiene a partir de la suma de los tres colores (cian, magenta y amarillo) es parcialmente negro en la práctica (y además es costoso), las impresoras agregan un componente de tinta denominado negro puro.

A este modelo se lo conoce como cuatricromía o modelo CMYK (Cian, Magenta, Amarillo, Negro, o en español CMAN).

Infografía El campo de la informática que se ocupa de la creación y el manejo de

imágenes digitales se denomina infografía. La infografía cubre varias áreas de conocimiento, incluyendo no sólo la

representación de elementos gráficos (texto, imagen o video) sino también sus transformaciones (rotación, traslación, zoom, etc.), por medio de algoritmos.

Tecnología de visualización La imagen se visualiza en una pantalla (también denominada monitor),

que es un dispositivo periférico de salida que permite mostrar representaciones visuales.

Esta información proviene del equipo, pero de forma "indirecta". De hecho, el procesador no envía la información directamente al monitor

sino que procesa la información que proviene de su memoria de acceso aleatorio (RAM) y la envía a la tarjeta gráfica que convierte la información en impulsos eléctricos, que después envía al monitor.

Los monitores de los equipos son, por lo general, tubos catódicos, es decir, tubos de vidrio en los que un cañón de electrones emite electrones que son dirigidos por un campo magnético hacia la pantalla en la que se encuentran elementos fosforescentes pequeños (luminóforos), constituyendo puntos (píxeles) que emiten luz cuando los electrones los tocan.

El concepto de píxel Una imagen consiste en un conjunto de puntos llamados píxeles (la

palabra píxel es la abreviación de PICture ELement o elemento de imagen). Por lo tanto, el píxel es el componente más pequeño de la imagen digital. Todo el conjunto de estos píxeles se encuentra en una tabla de dos

dimensiones que constituye la imagen: Como el barrido de pantalla se efectúa de izquierda a derecha y de arriba

hacia abajo, es común indicar el píxel que se encuentra en el extremo superior izquierdo de la imagen con las coordenadas [0,0].

Esto significa que las direcciones de los ejes de imagen son las siguientes: La dirección del eje X es de izquierda a derecha. La dirección del eje Y es de arriba hacia abajo, contrario a la notación

convencional de matemática, donde la dirección del eje Y es hacia arriba.

Definición y resolución El número de puntos (píxeles) que constituyen la imagen, es decir, sus

"dimensiones" (el número de columnas de la imagen multiplicado por el número de filas) se conoce como definición.

Una imagen de 640 píxeles de ancho y 480 píxeles de alto tiene una definición de 640 por 840 píxeles, que se representa 640 x 480.

Por otro lado, la resolución, un término muchas veces confundido con "definición", está determinada por el número de puntos por unidad de área, expresada en puntos por pulgada (DPI).

Una pulgada equivale a 2,54 cm. Por lo tanto, la resolución permite establecer la relación entre el número de

píxeles de una imagen y el tamaño real de su representación en un soporte físico.

Entonces una resolución de 300 ppp tiene 300 columnas y 300 líneas de píxeles en una pulgada cuadrada, lo que significa 90000 píxeles en una pulgada cuadrada.

La resolución de referencia de 72 dpi nos da un píxel de 1"/72 (una pulgada dividida por 72), es decir, 0,353 mm. Esto corresponde a una pica (unidad de medida tipográfica anglosajona).

Los modelos de color Por lo tanto, una imagen está representada en una tabla bidimensional en la que una

celda es un píxel. Para representar una imagen por medio del equipo, sólo es necesario crear una tabla de píxeles en la que cada celda contiene un valor. El valor almacenado en una celda se codifica en un determinado número de bits que determinan el color o la intensidad del píxel y se lo denomina profundidad de codificación (o a veces también profundidad de color). Existen varios estándares de profundidad de codificación:

mapa de bits blanco y negro: si se almacena un bit en cada celda, se pueden definir dos colores (negro o blanco).

Mapa de bits con 16 colores o 16 niveles de gris: si se almacenan 4 bits en cada celda, se pueden definir 2 4 intensidades por cada píxel, es decir, 16 grados de gris desde el negro al blanco o 16 colores diferentes.

Mapa de bits con 256 colores o 256 niveles de gris: si se almacena un byte en cada celda, se pueden definir 2 4 intensidades, es decir, 256 grados de gris desde el negro al blanco o 256 colores diferentes.

Mapa de colores de paleta de colores: gracias a este método, se puede definir una paleta, o tabla de colores, con todos los colores que puede contener la imagen, para los cuales hay un índice asociado en cada caso. El número de bits reservados para la codificación de cada índice de la paleta determina el número de colores que pueden utilizarse. Por lo tanto, cuando se codifican los índices en 8 bits, se pueden definir 256 colores disponibles; es decir, cada celda de la tabla bidimensional que representa la imagen contiene un número que indica el índice del color que se utilizará. A la imagen cuyos colores estén codificados según esta técnica se la denomina imagen de color indexado.

"Colores verdaderos" o "colores reales": esta representación permite que se represente una imagen al definir cada componente (RGB, por rojo, verde y azul). Cada píxel está representado por un conjunto de tres componentes, cada uno codificado en un byte, es decir, en total 24 bits (16 millones de colores). Es posible agregar un cuarto componente, para poder agregar información relacionada con la transparencia o la textura; en ese caso cada píxel estará codificado en 32 bits.

El peso de una imagen Para calcular el peso (en bytes) de una imagen, es necesario contar el número de

píxeles que contiene esa imagen, que equivale a calcular el número de celdas de la tabla, es decir, la altura de la tabla multiplicada por el ancho.

Entonces el peso de la imagen equivale al número de píxeles multiplicado por la altura de cada uno de esos elementos.

A continuación se indica la fórmula para una imagen de color verdadero de 640 x 480:

Cantidad de píxeles:

640 x 480 = 307200

Peso de cada píxel:

24 bits / 8 = 3 bytes

Entonces el peso de la imagen es igual a:

307200 x 3 = 921600 bytes 921600 / 1024 = 900 KB

(Para calcular el tamaño en KB, basta con dividirlo por 1024).

El peso de una imagen A continuación se indican algunos ejemplos (teniendo en cuenta que la imagen no

está comprimida): Esto muestra la cantidad de memoria de video que necesita la tarjeta gráfica según la

definición de la pantalla (el número de puntos visualizados) y el número de colores. Por lo tanto, el ejemplo demuestra que se necesita un cuadro que tenga al menos 4

MB de memoria de video para lograr una resolución de 1024 x 768 con colores verdaderos.

Transparencia La transparencia es la característica que permite definir el

nivel de opacidad de los elementos de una imagen, es decir, la posibilidad de mirar a través de una imagen los elementos gráficos que se encuentran detrás de ella.

Existen dos modalidades de transparencia: La transparencia simple, que se aplica a imágenes

indexadas y consiste en definir como transparente un color de entre los que hay en la paleta.

La transparencia de canal alfa consiste en agregar un byte que defina el nivel de transparencia (de 0 a 255) para cada píxel de la imagen. Al proceso de agregar una capa transparente a una imagen se lo denomina combinación alfa.

Imágenes vectoriales y de mapa de bits Existen dos categorías principales de imágenes:

imágenes de mapa de bits (también denominadas imágenes raster): son imágenes pixeladas, es decir que están formadas por un conjunto de puntos (píxeles) contenidos en una tabla. Cada uno de estos puntos tiene un valor o más que describe su color.

imágenes vectoriales: las imágenes vectoriales son representaciones de entidades geométricas tales como círculos, rectángulos o segmentos. Están representadas por fórmulas matemáticas (un rectángulo está definido por dos puntos; un círculo, por un centro y un radio; una curva, por varios puntos y una ecuación). El procesador "traducirá" estas formas en información que la tarjeta gráfica pueda interpretar.

Imágenes vectoriales y de mapa de bits Dado que una imagen vectorial está compuesta solamente por entidades matemáticas, se le pueden

aplicar fácilmente transformaciones geométricas a la misma (ampliación, expansión, etc.), mientras que una imagen de mapa de bits, compuesta por píxeles, no podrá ser sometida a dichas transformaciones sin sufrir una pérdida de información llamada distorsión.

La apariencia de los píxeles en una imagen después de una transformación geométrica (en particular cuando se la amplía) se denomina pixelación (también conocida como efecto escalonado).

Además, las imágenes vectoriales (denominadas clipart en el caso de un objeto vectorial) permiten definir una imagen con muy poca información, por lo que los archivos son bastante pequeños.

Por otra parte, una imagen vectorial sólo permite la representación de formas simples.

Si bien es verdad que la superposición de varios elementos simples puede producir resultados impresionantes, no es posible describir todas las imágenes con vectores; éste es particularmente el caso de las fotografías realistas.

La imagen "vectorial" es sólo la representación de lo que una imagen vectorial podría parecer, porque la calidad de la imagen depende del dispositivo utilizado para hacerla visible al ojo humano.

Probablemente su pantalla le permita ver esta imagen con una resolución de al menos 72 píxeles por pulgada.

El mismo archivo impreso en una impresora ofrecería una mejor calidad de imagen ya que la impresión se realizaría con al menos 300 píxeles por pulgada.

Formatos de archivos de gráficos(( ¿Qué es un formato de archivos?

En una sección anterior aprendimos de qué manera se codifica una imagen para que pueda ser visualizada en un monitor; sin embargo, cuando queremos almacenar una imagen en un archivo, ese formato no es el más práctico. De hecho, es posible que deseemos una imagen que ocupe menos espacio en la memoria o que no se pixele cuando se la agrande.

Por lo tanto, es posible almacenar la imagen, describiéndola con una ecuación, en un archivo con una estructura de datos que el procesador deberá decodificar antes de enviar la información a la tarjeta de gráficos:

Tipos de formatos de archivos Existe un gran número de formatos de archivos. Los formatos de

archivos de gráficos más utilizados son los siguientes:

El formato BMP El formato BMP es uno de los más simples. Fue desarrollado por Microsoft e IBM en forma conjunta, lo que

explica su uso particularmente amplio en plataformas Windows y OS/2.

Un archivo BMP es un archivo de mapa de bits, es decir, un archivo de imagen de gráficos, con píxeles almacenados en forma de tabla de puntos que administra los colores como colores reales o usando una paleta indexada.

El formato BMP ha sido estudiado de manera tal que permite obtener un mapa de bits independiente del dispositivo de visualización periférico (DIB, Mapa de bits independiente del dispositivo).

La estructura de un mapa de bits es la siguiente: Encabezado del archivo Encabezado de información del mapa de bits (también llamado

encabezado de información). Paleta (opcional) Cuerpo de la imagen

El formato BMP Encabezado del archivo

El encabezado del archivo proporciona información acerca del tipo de archivo (mapa de bits) y su tamaño, así como también indica dónde comienza realmente la información de la imagen.

El encabezado comprende cuatro campos: La firma (en 2 bytes), que indica que se trata de un archivo BMP con

dos caracteres BM, 424D en hexadecimal, que indica que se trata de un mapa de

bits de Windows BA que indica que se trata de un mapa de bits OS/2 CI que indica que se trata de un icono de color de OS/2 CP indica que es un puntero de color de OS/2 IC indica que es un icono de OS/2 PT indica que es un puntero de OS/2

El tamaño total del archivo en bytes (codificado en 4 bytes) Un campo reservado (en 4 bytes) El desajuste de la imagen (en 4 bytes), es decir, la ubicación del

comienzo de la información de la imagen en relación con el comienzo del archivo

El formato BMP Encabezado de información del mapa de bits

El encabezado de información del mapa de bits proporciona información acerca de la imagen, en especial las dimensiones y los colores.

La información del mapa de bits comprende cuatro campos: El tamaño del encabezado de información del mapa de bits en bytes (codificado en 4 bytes). Los

siguientes valores hexadecimales son posibles según el tipo de formato BMP: 28 para Windows 3.1x, 95, NT 0C para OS/2 1.x F0 para OS/2 2.x

El ancho de la imagen (en 4 bytes), es decir, el número de píxeles contados de forma horizontal La altura de la imagen (en 4 bytes), es decir, el número de píxeles contados de forma vertical El número de planos (en 2 bytes). Este valor es siempre 1 La profundidad del modelo de color (en 2 bytes), es decir, el número de bits usados para codificar el color.

Este valor puede ser equivalente a 1, 4, 8, 16, 24 ó 32 El método de compresión (en 4 bytes). Este valor es 0 cuando la imagen no está comprimida o 1, 2 ó 3

según el tipo de compresión usado: 1 para la codificación RLE de 8 bits por píxel 2 para la codificación RLE de 4 bits por píxel 3 para la codificación de campo de bits, lo que significa que el color fue codificado por una máscara

triple representada por la paleta El tamaño total de la imagen en bytes (en 4 bytes). La resolución horizontal (en 4 bytes), es decir, el número de píxeles por metro contado de forma

horizontal La resolución vertical (en 4 bytes), es decir, el número de píxeles por metro contado de forma vertical El número de colores de la paleta (en 4 bytes) El número de colores importantes de la paleta (en 4 bytes). Este campo puede equivaler a 0 cuando todos

los colores son importantes.

El formato BMP Paleta de imágenes

La paleta es opcional. Cuando se define la paleta, ésta contiene 4 bytes de forma sucesiva para cada una de las entradas, que representan: El componente azul (en un byte) El componente verde (en un byte) El componente rojo (en un byte) Un campo reservado (en un byte)

El formato BMP Codificación de imágenes

La codificación de imágenes se realiza escribiendo en forma sucesiva los bits que corresponden a cada píxel, línea por línea, comenzando por el píxel del extremo inferior izquierdo.

Las imágenes de 2 colores usan 1 bit por píxel, lo que significa que un byte permite codificar 8 píxeles

Las imágenes de 16 colores usan 4 bits por píxel, lo que significa que un byte permite codificar 2 píxeles

Las imágenes de 256 colores usan 8 bits por píxel, lo que significa que se necesita un byte para codificar cada píxel

Las imágenes de colores reales usan 24 bits por píxel, lo que significa que se necesitan 3 bytes para codificar cada píxel, respetando la alternancia del orden de los colores para el azul, el verde y el rojo.

Cada línea de la imagen debe comprender un número total de bytes que sea múltiplo de 4; si este esquema no se cumple, la línea se debe completar con todos los 0 necesarios para respetar el criterio.

Formato GIF El formato GIF (Graphic Interchange Format, Formato de

intercambio de gráficos) es un formato de archivos de gráficos de mapa de bits (una trama) desarrollado por Compuserve.

Existen dos versiones de este formato de archivos desarrolladas en 1987 y 1989 respectivamente: El GIF 87a, que es compatible con la compresión LZW, puede

entrelazar, (permitir la visualización progresiva) una paleta de 256 colores y tiene la posibilidad de crear imágenes animadas (llamadas GIF animados) almacenando varias imágenes en el mismo archivo.

El GIF 89a, que tiene como agregado la posibilidad de designar un color transparente para la paleta y especificar el tiempo de las animaciones.

Formato GIF Características del formato GIF

Una imagen GIF puede contener entre 2 y 256 colores (2, 4, 8, 16, 32, 64, 128 ó 256) entre 16,8 millones de su paleta.

Por lo tanto, dado que la paleta tiene un número de colores limitado (no limitado en cuanto a colores diferentes), las imágenes que se obtenían con este formato por lo general eran muy pequeñas.

Sin embargo, dado que el algoritmo de compresión LZW estaba patentado, todos los editores de software que usaban imágenes GIF debían pagarle regalías a Unisys, la compañía propietaria de los derechos.

Esta es una de las razones por las que el formato PNG se está volviendo cada vez más popular, en perjuicio del formato GIF.

El formato PCX El formato PCX fue desarrollado por ZSoft, difundiendo el

software PaintBrush con el que los sistemas operativos de Microsoft Windows estaban equipados de manera estándar desde la década de los ochenta.

El formato PCX es un formato de mapa de bits que admite imágenes, cuyas dimensiones pueden ser hasta 65536 por 65536 y que se pueden codificar en 1 bit, 4 bits, 8 bits ó 24 bits (que corresponden a 2, 16, 256 ó 16 millones de colores respectivamente).

La estructura de un archivo PCX es la siguiente: Un encabezado de información de mapa de bits con una

extensión de 128 bytes. Cuerpo de la imagen Información Paleta de colores (opcional). Este es un campo de 768

bytes que permite almacenar varios valores de rojo, verde y azul (RGB) por cada elemento de la paleta.

El formato PCX Encabezado de información del mapa de bits

El encabezado de información del mapa de bits contiene información acerca de la imagen, especialmente de las dimensiones y los colores.

El encabezado de información del mapa de bits comprende los siguientes campos: Firma del archivo (en un byte), que permite identificar el tipo de archivo. Valor hexadecimal 0A que indica

que se trata de un archivo PCX. Versión (en un byte):

0= Versión 2.5 2= Versión 2.8 con paleta 3= Versión 2.8 sin paleta 5= Versión 3.0

Formato (en un byte), es decir, el método de codificación utilizado. El valor de 1 indica codificación RLE. Cantidad de bits por píxel por plano (en un byte). Xmín (en dos bytes), la abscisa X del extremo superior izquierdo. Ymín (en dos bytes), la ordenada Y del extremo superior izquierdo. Xmáx (en dos bytes), la abscisa X del extremo inferior derecho. Ymáx (en dos bytes), la ordenada Y del extremo inferior derecho. Resolución horizontal (en dos bytes). Resolución vertical (en dos bytes). Paleta (en 48 bytes). Campo reservado (en un byte). Cantidad de planos de color (en un byte). Cantidad de bits por línea (en 2 bytes). Tipo de paleta (en 2 bytes). Relleno (58 bytes).

Es interesante notar que "Xmax - Xmin + 1" representa el ancho de la imagen y que "Ymax - Ymin + 1" representa la altura de ella.

El formato PCX Codificación de imagen

La codificación de imagen se realiza escribiendo en forma sucesiva los bits que corresponden a cada píxel, línea por línea, comenzando por el píxel del extremo superior izquierdo y siguiendo de izquierda a derecha y desde arriba hacia abajo.

Formato PNG El formato PNG (Portable Network Graphics, Gráficos de red

portátiles o formato Ping) es un formato de archivos de gráficos de mapa de bits (una trama).

Fue desarrollado en 1995 como una alternativa gratuita al formato GIF, que es un formato patentado cuyos derechos pertenecen a Unisys (propietario del algoritmo de compresión LZW), a quien todos los editores de software que usan este tipo de formato deben pagar regalías. \

Por lo tanto, PGN es un acrónimo recursivo de PNG No es GIF.

Formato PNG Características del formato PNG

El formato PNG permite almacenar imágenes en blanco y negro (una profundidad de color de 16 bits por píxel) y en color real (una profundidad de color de 48 bits por píxel), así como también imágenes indexadas, utilizando una paleta de 256 colores.

Además, soporta la transparencia de canal alfa, es decir, la posibilidad de definir 256 niveles de transparencia, mientras que el formato GIF permite que se defina como transparente sólo un color de la paleta. También posee una función de entrelazado que permite mostrar la imagen de forma gradual.

La compresión que ofrece este formato es (compresión sin pérdida) de 5 a 25% mejor que la compresión GIF.

Por último, el PNG almacena información gama de la imagen, que posibilita una corrección de gama y permite que sea independiente del dispositivo de visualización. Los mecanismos de corrección de errores también están almacenados en el archivo para garantizar la integridad.

Formato PNG Estructura de un archivo PNG

Un archivo PNG comprende una firma, que permite indicar que se trata de un archivo PNG, seguida de una serie de elementos denominados fragmentos. La firma de un archivo PNG (en notación decimal) es la siguiente: 137 80 78 71 13 10 26 10

La misma firma en notación hexadecimal es: 89 50 4E 47 0D 0A 1ª 0A

Cada fragmento comprende 4 partes:

el tamaño, un entero de 4 bytes no firmado, que describe el tamaño del fragmento

el tipo de fragmento: un código de 4 caracteres (4 bytes) comprendido por caracteres alfanuméricos ASCII (A-Z, a-z, 65 a 90 y 97 a 122) que permite establecer la naturaleza del fragmento

los datos del fragmento

la CRC (comprobación de redundancia cíclica), un código de corrección de 4 bytes que permite comprobar la integridad del fragmento

Los fragmentos pueden aparecer en cualquier orden excepto por el hecho de que el fragmento de encabezado debe ir adelante (fragmento IHDR) y el de cierre (fragmento IEND) detrás.

Los principales fragmentos (denominados fragmentos críticos) son:

IHDR Encabezado de información de mapa de bits

PLTE La paleta

IDAT Los datos de la imagen

IEND El cierre de la imagen

Los otros fragmentos (denominados fragmentos secundarios) son los siguientes:

bKGD El color de fondo

cHRM Las cromaticidades primarias y el punto blanco

gAMA La gama de la imagen

hIST El histograma de la imagen

pHYs Las dimensiones del píxel físico

sBIT Los bits importantes

tEXt Los datos de texto

tIME La hora de la última modificación

tRNS La transparencia

zTXt Los datos de texto comprimidos

El formato TIF El formato TIF (Formato de archivo de imágenes

con etiquetas) es un formato de archivo de gráficos de mapa de bits (una trama).

Fue desarrollado en 1987 por Aldus (ahora pertenece a Adobe).

Las últimas especificaciones (Revisión 6.0) se publicaron en 1992.

El formato TIF Características del formato TIF

El formato TIFF es un formato de gráficos antiguo, que permite almacenar imágenes de mapas de bits (trama) muy grandes (más de 4 GB comprimidos) pero perdiendo calidad y sin considerar las plataformas o periféricos utilizados (Mapa de bits independiente del dispositivo, reconocido como DIB).

El formato TIFF permite almacenar imágenes en blanco y negro, en colores verdaderos (hasta 32 bits por píxel) y también indexar imágenes utilizando una paleta.

Además, el formato TIF permite que se utilicen varios espacios de color: RGB (rojo, verde, azul) CMYK (cian, magenta, amarillo, negro) CIE L*a*b YUV / YCrCb

El formato TIF Estructura de un archivo TIFF

El principio del formato TIF consiste en definir etiquetas (de ahí el nombre Formato de archivo de imágenes con etiquetas) que describen las características de la imagen.

Las etiquetas permiten almacenar información acerca de las dimensiones de la imagen, la cantidad de colores utilizados, el tipo de compresión (pueden utilizarse varios algoritmos: Paquete de bits / CCITT G3y4 / RLE / JPEG / LZW / UIT-T) o la corrección de gama.

Por lo tanto, una descripción de imagen que utiliza etiquetas simplifica la programación del software permitiendo guardar información en formato TIFF.

Por otro lado, la cantidad de opciones es tan amplia que muchos editores de imágenes que admiten el formato TIFF no las integran todas.

Por ende, algunas veces, una imagen guardada que utiliza el formato TIFF no se puede leer por medio de otro editor.

La compresión de datos ¿Para qué se comprimen datos?

Actualmente, el poder de procesamiento de los procesadores se incrementa más rápido que la capacidad de almacenamiento y es más veloz que los anchos de banda de las redes, porque estos últimos requieren cambios enormes en las infraestructuras de telecomunicación.

Por lo tanto, para compensar esto, es más común el procedimiento de reducir el tamaño de los datos al explotar el poder de procesamiento de los procesadores, que incrementar la capacidad de almacenamiento y de transmisión de datos.

La compresión de datos ¿Qué es la compresión de datos?

La compresión consiste en reducir el tamaño físico de bloques de información.

Un compresor se vale de un algoritmo que se utiliza para optimizar los datos al tener en cuenta consideraciones apropiadas para el tipo de datos que se van a comprimir.

Por lo tanto, es necesario un descompresor para reconstruir los datos originales por medio de un algoritmo opuesto al que se utiliza para la compresión.

El método de compresión depende intrínsecamente del tipo de datos que se van a comprimir: no se comprime una imagen del mismo modo que un archivo de audio.

La compresión de datos Caracterización de la compresión

La compresión se puede definir por el factor de compresión, es decir, el número de bits de la imagen comprimida dividido por el número de bits de la imagen original.

El radio de compresión, que se utiliza con frecuencia, es lo contrario al factor de compresión; por lo general, se expresa como porcentaje.

Por último, la ganancia de compresión, que también se expresa como porcentaje, equivale a 1 menos el radio de compresión:

La compresión de datos La compresión física y lógica

La compresión física actúa directamente sobre los datos; por lo tanto, es cuestión de almacenar los datos repetidos de un patrón de bits a otro.

La compresión lógica, por otro lado, se lleva a cabo por razonamiento lógico al sustituir esta información por información equivalente.

La compresión de datos La compresión simétrica y asimétrica

En el caso de la compresión simétrica, se utiliza el mismo método para comprimir y para descomprimir los datos. Por lo tanto, cada operación requiere la misma cantidad de trabajo. En general, se utiliza este tipo de compresión en la transmisión de datos.

La compresión asimétrica requiere más trabajo para una de las dos operaciones. Es frecuente buscar algoritmos para los cuales la compresión es más lenta que la descompresión. Los algoritmos que realizan la compresión de datos con más rapidez que la descompresión pueden ser necesarios cuando se trabaja con archivos de datos a los cuales se accede con muy poca frecuencia (por razones de seguridad, por ejemplo), ya que esto crea archivos compactos.

La compresión de datos La compresión con pérdida

La compresión con pérdida, a diferencia de la compresión sin pérdida, elimina información para lograr el mejor radio de compresión posible mientras mantiene un resultado que es lo más cercano posible a los datos originales. Es el caso, por ejemplo, de ciertas compresiones de imágenes o de sonido, como por ejemplo los formatos MP3 o el Ogg Vorbis.

Como este tipo de compresión elimina información que está contenida en los datos que se van a comprimir, por lo general se habla de métodos de compresión irreversible.

Los archivos ejecutables, por ejemplo, no pueden comprimirse mediante este método, porque necesitan especialmente preservar su integridad para poder ejecutarse. De hecho, es inconcebible reconstruir un programa omitiendo y después agregando bits.

Por otro lado, los datos multimedia (audio, video) pueden tolerar un cierto nivel de degradación sin que los órganos sensoriales (el ojo, el tímpano, etc.) distingan alguna degradación importante.

La compresión de datos La codificación adaptativa, la semiadaptativa y la no

adaptativa Algunos algoritmos de compresión están basados en

diccionarios para un tipo específico de datos: éstos son codificadores no adaptativos.

La repetición de letras en un archivo de texto, por ejemplo, depende del idioma en el que ese texto esté escrito.

Un codificador adaptativo se adapta a los datos que va a comprimir. No parte de un diccionario ya preparado para un tipo de datos determinado.

Un codificador semiadaptativo crea un diccionario según los datos que va a comprimir: crea el diccionario mientras analiza el archivo y después lo comprime.

La compresión RLE El método de compresión RLE (Run Length Encoding, a veces escrito RLC por Run Length Coding) es

utilizado por muchos formatos de imagen (BMP, PCX, TIFF). Se basa en la repetición de elementos consecutivos.

El principio fundamental consiste en codificar un primer elemento al dar el número de repeticiones de un valor y después el valor que va a repetirse.

Por lo tanto, según este principio, la cadena “AAAAAHHHHHHHHHHHHHH” cuando está comprimida da como resultado "5A14H".

La ganancia de compresión es (19-5) / 19, es decir, aproximadamente 73,7%.

Por otro lado, para la cadena "CORRECTLY", donde hay poca repetición de caracteres, el resultado de la compresión es “1C1O2R1E1C1T1L1Y”.

Por lo tanto, la compresión genera un costo muy elevado y una ganancia de compresión negativa de (9-16) / 9, es decir, ¡-78%!

En realidad, la compresión RLE está regida por reglas particulares que permiten que se ejecute la compresión cuando sea necesario y que se deje la cadena como está cuando la compresión genere pérdida. Las reglas son las siguientes: Si se repiten tres o más elementos consecutivamente, se utiliza el método de compresión RLE. De lo contrario, se inserta un carácter de control (00) seguido del número de elementos de la

cadena no comprimida y después la última. ? Si el número de elementos de la cadena es extraño, se agrega el carácter de control (00) al

final. ? Finalmente, se definen los caracteres de control específicos según el código:

un final de línea (00 01) el final de la imagen (00 00) un desplazamiento de puntero sobre la imagen de XX columnas e YY filas en la dirección de

lectura (00 02 XX YY).

La compresión RLE Por lo tanto, no tiene sentido utilizar la compresión RLE

excepto para datos con diversos elementos repetidos de forma consecutiva, en imágenes particulares con áreas grandes y uniformes.

Sin embargo, la ventaja de este método es que es de fácil implementación.

Existen alternativas en las que la imagen está codificada en bloques de píxeles, en filas o incluso en zigzag.

Código Huffman En 1952, David Huffman propuso un método estadístico que

permitía asignar un código binario a los diversos símbolos a comprimir (píxeles o caracteres, por ejemplo).

La longitud de cada código no es idéntica para todos los símbolos: se asignan códigos cortos a los símbolos utilizados con más frecuencia (los que aparecen más a menudo), mientras que los símbolos menos frecuentes reciben códigos binarios más largos.

La expresión Código de Longitud Variable (VLC) se utiliza para indicar este tipo de código porque ningún código es el prefijo de otro.

De este modo, la sucesión final de códigos con longitudes variables será en promedio más pequeña que la obtenida con códigos de longitudes constantes.

Código Huffman El codificador Huffman crea una estructura arbórea

ordenada con todos los símbolos y la frecuencia con que aparecen.

Las ramas se construyen en forma recursiva comenzando con los símbolos menos frecuentes.

La construcción del árbol se realiza ordenando en primer lugar los símbolos según la frecuencia de aparición.

Los dos símbolos con menor frecuencia de aparición se eliminan sucesivamente de la lista y se conectan a un nodo cuyo peso es igual a la suma de la frecuencia de los dos símbolos.

El símbolo con menor peso es asignado a la rama 1, el otro a la rama 0 y así sucesivamente, considerando cada nodo formado como un símbolo nuevo, hasta que se obtiene un nodo principal llamado raíz. El código de cada símbolo corresponde a la sucesión de códigos en el camino, comenzando desde este carácter hasta la raíz.

De esta manera, cuanto más dentro del árbol esté el símbolo, más largo será el código.

Código Huffman Analicemos la siguiente oración: "COMMENT_CA_MARCHE".

Las siguientes son las frecuencias de aparición de las letras:

Éste es el árbol correspondiente:

Los códigos correspondientes a cada carácter son tales que los códigos para los caracteres más frecuentes son cortos y los correspondientes a los símbolos menos frecuentes son largos:

Las compresiones basadas en este tipo de código producen buenas proporciones de compresión, en particular, para las imágenes monocromáticas (faxes, por ejemplo). Se utiliza especialmente en las recomendaciones T4 y T5 utilizadas en ITU-T

Compresión LZW Abraham Lempel y Jakob Ziv son los creadores del compresor

LZ77, inventado en 1977 (de ahí su nombre). Este compresor se utilizó en ese momento para archivar (los formatos ZIP, ARJ y LHA lo utilizan).

En 1978 crearon el compresor LZ78 especializado en compresión de imágenes (o la compresión de cualquier tipo de archivo binario).

En 1984, Terry Welch de Unisys lo modificó para utilizarlo en controladores de disco duro; por lo tanto, se agregó la inicial de su apellido a la abreviatura LZ, lo que originó el término LZW. LZW es un algoritmo muy rápido tanto para la compresión como para la descompresión, basado en la multiplicidad de aparición de secuencias de caracteres en la cadena que se debe codificar. Su principio consiste en sustituir patrones con un código de índice y construir progresivamente un diccionario.

Además, funciona en bits y no en bytes, por lo tanto, no depende de la manera en que el procesador codifica información. Es uno de los algoritmos más populares y se utiliza particularmente en formatos TIFF y GIF. Dado que el método de compresión LZW ha sido patentado por Unisys, el que se utiliza en imágenes PNG es el algoritmo LZ77, por el que no se pagan derechos de autor.

Compresión LZW Construcción del diccionario

El diccionario comienza con los 256 valores de la tabla ASCII.

El archivo a comprimir se divide en cadenas de bytes (por lo tanto, para las imágenes monocromáticas codificadas en 1 bit, esta compresión no es muy eficaz), cada una de estas cadenas se compara con el diccionario y se agrega si no se encuentra ahí.

Compresión LZW Compresión

El algoritmo pasa por la cadena de información y la codifica. Si una cadena nunca es más corta que la palabra más larga del diccionario, ésta se transmite.

Descompresión Durante la descompresión, el algoritmo

reconstruye el diccionario en la dirección opuesta; por lo tanto, no necesita almacenarse.

Compresión JPEG La sigla JPEG (Joint Photographic Expert Group) surge de la

reunión que tuvo lugar en 1982 entre un grupo de expertos en fotografía, que trabajaban principalmente en las formas de transmitir información (imágenes fijas o animadas).

En 1986, el ITU-T desarrolló métodos de compresión destinados al envío de faxes.

Estos dos grupos se unieron para crear el Grupo Conjunto de Expertos en Fotografía (JPEG).

A diferencia de la compresión LZW, la compresión JPEG es una compresión dieléctrica, lo que le permite producir una de las mejores proporciones de compresión, a pesar de la ligera pérdida de calidad (20: 1; y 25:1 sin pérdida significativa de calidad).Este método de compresión es mucho más efectivo para las imágenes fotográficas (conformadas por muchos píxeles de colores diferentes) que para las imágenes geométricas (a diferencia de la compresión LZW) porque las diferencias de matiz producto de la compresión son muy visibles en esta última.

Compresión JPEG Las etapas de la compresión JPEG son las siguientes:

Remuestreo de crominancia, porque el ojo humano no puede distinguir diferencias de crominancia en un cuadrado de 2x2 puntos

División de la imagen en bloques de 8x8 puntos, luego la aplicación de la función DCT (Discrete Cosine Transform (Transformada de coseno discreta)), que descompone la imagen en una suma de frecuencias

Cuantificación de cada bloque, es decir, se aplica un coeficiente de pérdida (que hace posible determinar la relación tamaño/calidad) que "anulará" o disminuirá los valores altos de frecuencia a fin de atenuar los detalles, pasando de manera inteligente sobre el bloque con codificación RLE (en forma de zigzag para eliminar tantos valores cero como sea posible).

Codificación de imágenes después de la compresión mediante el método Huffman

En realidad, los formatos que guardan un flujo codificado en JPEG se llaman JFIF (JPEG File Interchange Format), pero el término generalmente se deforma a "archivo JPEG".

Debe tenerse en cuenta que existe una forma de codificación JPEG sin pérdidas. Aunque ésta no es muy utilizada por la comunidad de procesamiento de datos en general, se utiliza especialmente para la transmisión de imágenes médicas a fin de evitar que se produzcan artefactos en la imagen (meramente dependientes de la imagen y su digitalización) y confundirlos con signos patológicos reales. De esta manera, la compresión resulta mucho menos efectiva (factor 2 solamente).

Filtros gráficos Filtrado

El filtrado consiste en aplicar una transformación (llamada filtro) a una imagen digital completa, o a una parte de ella, por medio de un operador. Los tipos de filtro son los siguientes:

Los filtros de paso bajo consisten en atenuar los componentes de la imagen con alta frecuencia (píxeles oscuros). Este tipo de filtro generalmente se usa para atenuar el ruido de una imagen; por eso usualmente se lo denomina suavizado. Los filtros promedio son un tipo de filtros de paso bajo cuyo principio es sacar el promedio de los valores de los píxeles contiguos. Con este filtro se obtiene una imagen más borrosa.

Los filtros de paso alto, a diferencia de los filtros de paso bajo, atenúan los componentes de la imagen de frecuencia baja y en particular posibilitan acentuar los detalles y el contraste; por esa razón a veces se usa el término "filtro agudizador".

? Los filtros de paso de banda permiten que se obtenga la diferencia entre la imagen original y la que se logra aplicando un filtro de paso bajo.

Los filtros de dirección aplican una transformación según una dirección dada.

Las operaciones de filtrado tienen una etapa preliminar de selección de píxeles denominada filtrado adaptativo.

Filtros gráficos ¿Qué es un filtro?

Un filtro es una ecuación matemática (denominada producto de convolución) que permite modificar el valor de un píxel según los valores de los píxeles contiguos, con coeficientes por cada píxel de la región a la que se lo aplica.

El filtro se representa en una tabla (matriz) que se caracteriza por sus dimensiones y coeficientes, cuyo centro corresponde al píxel en cuestión. Los coeficientes de la tabla determinan las propiedades del filtro. El siguiente es un ejemplo de un filtro 3 X 3:

Por lo tanto, el producto de la matriz de la imagen, que por lo general es muy grande porque representa la imagen inicial (tabla de píxeles) por el filtro da como resultado una matriz que corresponde a la imagen procesada.

Filtros gráficos El concepto de ruido

El ruido caracteriza a las señales parásitas o de interferencia, es decir, las partes de la señal que han sido deformadas localmente. De este modo, el ruido de una imagen indica los píxeles de una imagen cuya intensidad es muy diferente de la de los píxeles adyacentes.

Hay varios factores que pueden generar ruido en una imagen: El medio que la rodea cuando se la adquiere La calidad del sensor La calidad de la muestra

Filtros gráficos Suavizado

La operación de filtrado que se usa para eliminar el ruido de una imagen es el "suavizado" (o filtro de ruidos).

La operación de suavizado específica que consiste en evitar el efecto escalonado que producen los píxeles en el borde de una figura geométrica se denomina antiescalonamiento.

Agudización La agudización es lo opuesto al suavizado; es una operación

cuyo fin es acentuar las diferencias entre los píxeles adyacentes. De este modo, la agudización permite resaltar los bordes entre

las regiones homogéneas de la imagen y se la denomina extracción de contorno (o definición de contornos).

Difuminado El difuminado (o procesamiento de medios tonos) es una técnica

que consiste en alternar los patrones geométricos usando pocos colores, llamados "medios tonos", para simular un color más elaborado.

Video digital ¿Qué es un video?

Un video es una sucesión de imágenes presentadas a cierta frecuencia.

El ojo humano es capaz de distinguir aproximadamente 20 imágenes por segundo.

De este modo, cuando se muestran más de 20 imágenes por segundo, es posible engañar al ojo y crear la ilusión de una imagen en movimiento.

La fluidez de un video se caracteriza por el número de imágenes por segundo (frecuencia de cuadros), expresado en FPS (cuadros por segundo).

Además, el video multimedia generalmente está acompañado de sonido, es decir, datos de audio.

Video digital Video digital y análogo

Las "imágenes animadas" generalmente se clasifican en diversas grandes familias:

El cine, que consiste en el almacenamiento de la sucesión de imágenes negativas en una película. La película se muestra mediante una fuente de luz que proyecta las imágenes sucesivas, de una copia positiva, en una pantalla.

El video análogo, que representa la información como un flujo continuo de datos análogos, para mostrarse en una pantalla de TV (en base al principio de escaneo). Existen diversas normas para el video análogo: Las tres principales son: PAL NTSC SECAM

El video digital, que consiste en la codificación del video en una sucesión de imágenes digitales.

PAL El formato PAL/SECAM (Phase Alternating Line/Sequential Colour with Memory),

utilizado en Europa para la televisión hertziana, permite la codificación de videos en 625 filas (sólo se muestran 576 porque el 8% de las filas se utiliza para sincronización), a una frecuencia de 25 imágenes por segundo con un formato 4:3 (es decir, con una proporción 4/3 de ancho/altura).

No obstante, a 25 imágenes por segundo, muchas personas perciben cierta intermitencia en la imagen.

Por lo tanto, como no era posible enviar más información debido a las limitaciones del ancho de banda, se decidió entrelazar las imágenes, es decir, enviar las filas pares en primer lugar y después las filas impares.

El término "campo" indica la "media imagen" formada por las filas pares o las filas impares.

La transmisión completa que comprende los dos campos se llama pantalla entrelazada.

Cuando no hay entrelazado, se utiliza el término pantalla progresiva. Gracias a este procedimiento llamado "entrelazado", un televisor PAL/SECAM

muestra 50 campos por segundo (es decir, a una frecuencia de 50 Hz), lo que significa 2 x 25 imágenes en dos segundos.

NTSC La norma NTSC (National Television Standards Committee), utilizada en los

Estados Unidos y Japón, utiliza un sistema de 525 filas entrelazadas a 30 imágenes por segundo (es decir, a una frecuencia de 60 Hz).

Como en el caso de la norma PAL/SECAM, el 8% de las filas se utiliza para sincronizar el receptor.

De esta manera, dado que la norma NTSC muestra un formato de imagen de 4:3, la resolución que se muestra en realidad es de 640 x 480.

El video digital consiste en mostrar una sucesión de imágenes digitales. Dado que estas imágenes digitales se muestran a una frecuencia

determinada, es posible saber la frecuencia de refresco, es decir, el número de bytes mostrados (o transferidos) por unidad de tiempo.

De esta manera, la frecuencia necesaria para mostrar un video (en bytes por segundo) equivale al tamaño de la imagen multiplicado por el número de imágenes por segundo.

Consideremos una imagen a color verdadero (24 bits) con una definición de 640 X 480 píxeles.

A fin de mostrar un video en forma correcta con esta definición, es necesario mostrar al menos 30 imágenes por segundo, es decir, a una frecuencia equivalente a:

900 KB * 30 = 27 MB/s

Video compuesto Video compuesto

El término "video compuesto" hace referencia a una señal de video dentro de la cual se mezclan los componentes de luminancia (luminosidad) y crominancia (color) y los pulsos de sincronización.

Las señales compuestas generalmente se transmiten por cables cuyos conectores son conectores RCA amarillos (CINCH):

El cable RCA que transmite la señal de video compuesto generalmente está acompañado por otros dos cables RCA, rojo y blanco, que llevan la señal de audio estéreo (izquierda y derecha).

Video compuesto Video compuesto

Desventajas Dado que los diversos componentes de una señal se mezclan, la señal de video

resultante es de mala calidad. Basta con comparar una señal de video que contiene texto, en forma compuesta, con el mismo video y texto codificado con componentes separados (RGB, YUV o S-Video) para comprobar que el texto en la señal compuesta se cortará.

Alternativas Las señales de video con componentes separados se desarrollaron para superar

las limitaciones de las señales de video compuesto, de manera que los diversos componentes de video pudieran circular por distintas rutas lógicas (códigos) y físicas (cables).

Las principales señales de video con componentes son: S-Video (Y/C) RGB (rojo, verde, azul) YCbCr (YUV)

S-Video (Y/C) El estándar S-Video (que significa "Sony Video"), a menudo denominado Y/C, es un

modo de transmisión de video con componentes separados que utiliza cables diferentes para transmitir información con respecto a la luminancia (luminosidad) y crominancia (color).

Una conexión S-Video permite ofrecer una calidad de video óptima al enviar en forma simultánea las 576 filas de la imagen, sin entrelazar (todas a la vez).

La señal S-Video se transmite generalmente con un cable que comprende un conector mini DIN de 4 clavijas (dos clavijas diferentes para cada componente de video):

Este tipo de conector se utiliza en cámaras de video de última generación o grabadoras de cinta de video S-VHS, cámaras Hi8 o simplemente en la mayoría de las tarjetas gráficas con salida de TV. No obstante, la señal S-Video sólo permite que se transmita la señal de video, por lo cual es necesario utilizar un cable de audio separado para la transmisión de los datos de audio.

Es preciso tener en cuenta que los conectores Peritel nuevos también permiten la transmisión de señales S-Video. Existen además adaptadores que permiten la conexión de un cable de audio S-Video y conectores RCA a un conector Peritel, si bien esto originará una degradación de la señal adicional.

Sin embargo, dado que la señal S-Video no era parte de las especificaciones del conector Peritel original, algunos equipos con estos conectores no admiten este tipo de señal.

El formato YUV (YCrCb) El estándar YUV (también llamado CCIR 601), conocido anteriormente

como YCrCb (Y Cr Cb), es un modelo de representación del color dedicado al video análogo.

Se basa en un modo de transmisión de video con componentes separados que utiliza tres cables diferentes para llevar información con respecto a los componentes de luminancia (luminosidad) y los dos componentes de crominancia (color). Es el formato utilizado en las normas PAL (Phase Alternation Line) y SECAM (Séquentiel Couleur À Mémoire).

El parámetro Y representa la luminancia (es decir, información en blanco y negro), mientras que U y V representan la crominancia (es decir, información con respecto al color). Este modelo se desarrolló para permitir la transmisión de información a color en televisores a color y a la vez garantizar que los televisores blanco y negro existentes continuaran mostrando una imagen en tonos de gris.

A continuación se muestran las relaciones entre Y y R, entre G y B, entre U, R y luminancia, y finalmente entre V, B y luminancia: Y = 0.299R + 0.587 G + 0.114 B U = -0.147R - 0.289 G + 0.436B = 0.492(B - Y) V = 0.615R -0.515G -0.100B = 0.877(R-Y)

Por lo tanto, U a veces se escribe como Cr y V a veces se escribe como Cb, de ahí la notación YCrCb.

El formato YUV (YCrCb) Cableado

Una conexión YUV se basa generalmente en el uso de tres cables RCA, uno verde, uno azul y uno rojo:

La conexión YUV permite ofrecer una calidad de video óptima al enviar en forma simultánea las 576 filas de la imagen, sin entrelazar (todas a la vez).

Formato YIQ El modelo YIQ está estrechamente relacionado con el modelo YUV.

Se utiliza particularmente en la norma de video NTSC (que se utiliza en los Estados Unidos y Japón, entre otros países) El parámetro Y representa la luminancia. I y Q representan Interpolación Cuadratura . Las relaciones entre estos parámetros y el modelo RGB son las siguientes: Y = 0.299 R + 0.587 G + 0.114 B I = 0.596 R - 0.275 G - 0.321 B Q = 0.212 R - 0.523 G + 0.311 B

La compresión de video (códecs) Una imagen de video no comprimida ocupa 1 MB

aproximadamente. Para obtener un video fluido, se necesita una frecuencia de al

menos 25 ó 30 imágenes por segundo, lo que genera un flujo de datos de 30 MB/s aproximadamente, es decir, más de 1,5 GB por minuto.

Es obvio que este tipo de flujo es muy poco compatible con el espacio de almacenamiento de los ordenadores personales o incluso con las conexiones de red domésticas o de compañías pequeñas o medianas.

Por lo tanto, para superar esta dificultad, se puede recurrir a algoritmos que permitan reducir de forma significativa el flujo de datos por medio de la compresión/descompresión de datos de video.

A estos algoritmos se los denomina CóDec (por COmpresión/DEsCompresión).

Formato MPEG En muchas secuencias de video, varias de las escenas son fijas o

varían muy poco; esto se denomina redundancia temporal. Cuando sólo se mueven los labios del actor, casi los únicos píxeles

que se van a modificar de una imagen a la otra son los de la boca; por lo tanto, es suficiente describir el cambio de una imagen a la otra.

Esta es la principal diferencia entre MPEG (Moving Pictures Experts Group, Grupo de expertos en imágenes en movimiento) y M-JPEG.

Sin embargo, este método tendrá mucho menos impacto en una escena de acción.

El grupo MPEG se creó en 1988 con el fin de desarrollar estándares internacionales de compresión, descompresión, procesamiento y codificación de imágenes animadas y datos de audio.

Formato MPEG MPEG-1, desarrollado en 1988, es un estándar de compresión de datos de

video y de los canales de audio asociados (hasta 2 canales para sonido estéreo). Permite almacenar videos a una velocidad de 1,5 Mbps con una calidad cercana a la de las cintas VHS en un soporte de CD denominado VCD (CD de video).

MPEG-2, un estándar dedicado originalmente a la televisión digital (HDTV, televisión de alta definición), ofrece alta calidad a una velocidad que puede llegar hasta los 40 Mbps y 5 canales de sonido envolvente. Además, MPEG-2 permite la identificación y la protección contra roturas. Es el formato que se usa para videos en DVD.

MPEG-4 es un estándar diseñado para permitir la codificación de datos multimedia en forma de objetos digitales para lograr una mejor interactividad, lo que lo hace especialmente adecuado para la web y para los dispositivos periféricos móviles.

MPEG-7 es un estándar que se emplea para brindar una representación de datos de audio y video estándar que permita la búsqueda de información en dichos flujos de datos. Por eso, este estándar también es conocido como Interfaz de Descripción de Contenido Multimedia.

MPEG-21, un estándar que todavía está en desarrollo, tiene como objetivo brindar un marco para todos los actores digitales (productores, consumidores, etc.) para estandarizar la gestión de estos contenidos, así como también los derechos de acceso, los derechos de autor, etc.

Audio digital Los sonidos son vibraciones del aire, es decir, una serie de

presiones ascendentes y descendentes en el aire con respecto a una media, la presión atmosférica.

Para probar esto, podemos colocar algo que suene alto (como un reloj despertador) dentro de una cámara al vacío: notaremos que, al no estar rodeado de aire, el objeto ya no hace ruido.

La manera más simple de crear un sonido es hacer que un objeto vibre.

De esta manera, un violín suena cuando el arco hace vibrar las cuerdas, y un piano toca una nota cuando se presiona una tecla ya que el percutor golpea una cuerda y hace que ésta vibre.

Por lo general, se utilizan altavoces para reproducir estos sonidos. Los altavoces se componen de una membrana conectada a un

electroimán; cuando una corriente eléctrica pasa rápidamente por delante y por detrás del imán causa vibraciones en el aire que lo rodea, ¡y la vibración es sonido!

Audio digital De esta forma se producen las ondas sonoras, que se pueden

representar en un diagrama como cambios en la presión de aire (o en el nivel de electricidad del imán) con relación al tiempo. Obtenemos la siguiente representación:

Este tipo de representación del sonido se denomina modulación de amplitud (modulación de la amplitud de un sonido a lo largo del tiempo). Un sonograma, por otro lado, representa las frecuencias de sonido en función del tiempo. Se debe observar que el sonograma muestra una frecuencia fundamental, por encima de la cual frecuencias más altas (denominadas armónicas) se superponen.

Audio digital Muestreo de sonido

Para reproducir sonido en un equipo informático debe convertirse a un formato digital, ya que este es el único tipo de información con el que pueden trabajar los ordenadores. Se trata de anotar pequeñas muestras de sonido (lo que equivale a anotar diferencias de presión) a intervalos temporales específicos.

Esto se denomina muestreo o digitalización del sonido . El período de tiempo entre dos muestras se denomina índice de muestreo. Para reproducir sonidos de audio que se escuchen de forma continua se requieren muestras que

suenen al menos una vez cada cienmilésima de segundo; por esto, resulta más práctico basarse en el número de muestras por segundos, expresadas en Hertz (Hz).

A continuación hay algunos ejemplos de los índices de muestreo más comunes, y de calidades de sonido asociadas:

El índice de muestreo de un CD de audio, por ejemplo, no es arbitrario. De hecho, proviene del teorema de Shannon. La frecuencia de muestreo debe ser lo suficientemente alta como para preservar la forma de la

señal. El teorema de Nyquist -Shannon estipula que el índice de muestreo debe ser igual o mayor al

doble de la frecuencia máxima contenida en la señal. Nuestros oídos pueden escuchar sonidos hasta 20.000 Hz aproximadamente. Por lo tanto, para obtener un nivel de calidad de sonido satisfactorio, el índice de muestreo debe

estar, al menos, en el orden de los 40.000 Hz. Se utilizan diversos índices estandarizados de muestreo: 32 kHz: para radios FM digitales (limitadas a una banda de 15 kHz) 44,1 kHz: para audio profesional y discos compactos. 48 kHz: para la grabación de pistas digitales grabadas por separado y equipos de grabación

de consumo (como DAT o MiniDisc)

Audio digital Memoria requerida para almacenar un archivo de sonido

Es fácil calcular el tamaño de una secuencia de audio no comprimida. Conociendo cuántos bits se utilizan para codificar una muestra, se puede saber su tamaño (ya que el tamaño de la muestra es el número de bits)

Para averiguar el tamaño de un canal, todo lo que necesita saber es el índice de muestreo (y, por lo tanto, el número de muestras por segundo) y, partir de ahí, la cantidad de espacio que ocupa un segundo de música. Llegamos a la siguiente operación: Índice de muestreo x Número de bits

Por lo tanto, para averiguar cuánto espacio ocupa un extracto de sonido que dura varios segundos, sólo se debe multiplicar el valor precedente por el número de segundos: Índice de muestreo x Número de bits x Número de segundos

Finalmente, para determinar el tamaño real del extracto, se debe multiplicar la cifra anterior por el número de canales (será el doble de grande para sonido estéreo que para mono). Por lo tanto, el tamaño en bits de un extracto de sonido será igual a:

Índice de muestreo x Número de bits x Número de segundos x Número de canales

Audio digital Representación informática del sonido

Cada muestra (que corresponde a un intervalo de tiempo) está asociada a un valor, que determina el valor de la presión de aire en ese momento. Por lo tanto, el sonido no se representa como una curva continua con variaciones, sino como una serie de valores para cada intervalo de tiempo:

Un ordenador trabaja con bits, por lo que se debe determinar el número posible de valores que puede tener una muestra. Esto equivale a establecer el número de bits en base al cual se codifican los valores de la muestra. Con una codificación de 8 bits, hay 28 (= 256) valores posibles. Con una codificación de 16 bits, hay 216 (= 65536) valores posibles.

La segunda opción ofrece claramente una fidelidad de sonido mayor, pero utiliza más memoria del equipo.

Finalmente, el sonido estéreo requiere dos canales, con sonido grabado individualmente para cada uno de ellos. Un canal alimentará el altavoz izquierdo, en tanto que el otro se transmitirá por el parlante derecho.

En el procesamiento informático, un sonido se representa por diversos parámetros: El índice de muestreo El número de bits de una muestra El número de canales (uno para mono, dos para estéreo, y cuatro para sonido cuadrofónico)

MP3 Introducción al formato MP3

MP3 (MPEG Audio layer 3) es un formato de compresión de datos de audio con pérdida, desarrollado por la Organización Internacional de Normalización (ISO).

Este formato se utiliza para comprimir formatos de audio normales (WAV o CD audio) en una relación de 1:12.

Permite almacenar el equivalente a 12 CD-ROM de álbumes de música en el espacio de un solo CD. Es más, el formato mp3 casi no altera la calidad del sonido para el oído humano.

Contexto La compresión MPEG Layer 3 consiste en quitar los datos que

corresponden a las frecuencias inaudibles bajo condiciones de audición normales.

Esta compresión analiza los componentes espectrométricos de una señal de audio, y les aplica un modelo psicoacústico para preservar solamente el sonido "audible".

El oído humano es capaz de discernir, sonidos entre 0,02 kHz y 20 kHz, con una sensibilidad máxima de frecuencias que oscila entre 2 y 5 kHz (la voz humana se sitúa entre 0,5 y 2 kHz), siguiendo la curva de la ley de Fletcher y Munson.

La compresión MPEG consiste en determinar aquellos sonidos que no oímos y suprimirlos, Por lo tanto es una "compresión con pérdida" donde se destruyen algunos datos.

MP3 El efecto de "enmascaramiento"

Gabriel Bouvigne explica:"Cuando miramos al sol y un pájaro pasa frente a nosotros, no podemos verlo porque la luz del sol brilla excesivamente. La acústica es similar. Cuando hay sonidos altos, no se pueden escuchar los bajos. Por ejemplo, el órgano: Cuando el músico no está tocando se puede escuchar el silbido en los tubos; sin embargo, cuando está tocando, no se escucha porque está enmascarado.

Por este motivo no es necesario grabar cada sonido, este es el principio que se utiliza en el formato MP3 para ahorrar espacio."

La reserva de bits A veces, ciertos pasajes de una grabación de música no se pueden codificar sin

cambiar la calidad del sonido. Por lo tanto, el formato mp3 utiliza una pequeña reserva de bits que se dedica a los pasajes que pueden codificarse en un índice de bits más bajo que el resto de los datos.

Codificación joint stereo La mayoría de los sistemas de alta fidelidad utilizan un "boomer" (que reproduce

los graves). Sin embargo, nos parece que el audio no proviene del boomer sino de los otros altavoces. Por debajo de una determinada frecuencia, el oído humano no puede distinguir de dónde provienen los sonidos. El formato mp3 puede, opcionalmente, tomar ventaja de este fenómeno utilizando el método joint stereo. Esto significa que ciertas frecuencias se graban en mono, pero incluyen datos adicionales para que suenen como una configuración de varios altavoces.

MP3 El código Huffman

El algoritmo Huffman es un algoritmo de codificación (no de compresión), que tiene su efecto al final del proceso de compresión, al crear códigos de longitud variable sobre un gran número de bits. Los códigos tienen la ventaja de aplicar un único prefijo, pero pueden ser decodificados correctamente a pesar de ser de longitud variable y esto se puede hacer rápidamente utilizando unas tablas. Este tipo de codificación ahorra, como promedio, algo menos del 20% del espacio que ocupa.

El algoritmo Huffman es muy efectivo cuando los sonidos son "puros" (cuando no hay enmascaramiento), ya que los sonidos digitalizados contienen muchos sonidos redundantes.

Resultados Con la compresión MP3, un minuto de un CD de audio (a una frecuencia de 44,1

kHz, 16 bits, estéreo) ocupa sólo 1 MB. Una canción ocupa de media 3 o 4 MB, esto permite su descarga incluso cuando se utiliza un módem.

La descompresión de un archivo MP3 (es decir, la reproducción) se realiza en tiempo real con una CPU Pentium 166, pero monopoliza los recursos del sistema. Por este motivo no se recomienda ejecutar otra aplicación que demande mucha memoria mientras se reproduce, a menos que se disponga de un equipo de gran rendimiento.

Ogg Vorbis Ogg Vorbis es un formato de compresión de datos de audio

desarrollado por Xiph.org. Como el formato MP3, es una forma de compresión que reduce

algunos de los datos de audio y se denomina "compresión con pérdida". (lossy compression)

Esto quiere decir que se eliminan algunos de los datos de audio (frecuencias inaudibles, por ejemplo), para obtener el mayor grado de compresión posible y generar un archivo de salida que suene lo más parecido posible al original.

Lo que distingue al formato Ogg Vorbis es que es un formato de código abierto, a diferencia de sus competidores principales como el formato MP3, WMA, Atrac y AAC.

Esto significa que el algoritmo de compresión se puede utilizar libremente por todos los productores de software, y es un recurso para el desarrollo y el lanzamiento de numerosas herramientas y librerías libres de derecho (open sources).

Ogg Vorbis Características técnicas

Ogg Vorbis utiliza una codificación variable de la frecuencia de bits (abreviado VBR), un método de codificación que modifica el número de bits utilizados por segundo para codificar datos de audio, en función de la complejidad de la transmisión de audio en un momento determinado. En otras palabras, esto significa que la cantidad de datos que se utiliza para codificar una porción determinada de audio no será igual para el silencio que para un concierto polifónico.

Mientras que el formato MP3 sólo puede grabar un máximo de dos canales (estéreo), Ogg Vorbis puede grabar polifónicamente (varios canales) y, por lo tanto, puede reproducir sonidos en sistemas que utilizan canales 4.5 (5.1) o 7 (7.1).

Como el formato Ogg Vorbis es más reciente que MP3 (la versión 1.0 de Ogg Vorbis salió al mercado el lunes 8 de mayo de 2000) ofrece una mejor fidelidad de sonido, en una escala de frecuencia de 8 kHz-48,0 kHz.

Finalmente, los archivos Ogg Vorbis son más pequeños que los MP3. Los archivos que se encuentran a continuación, cortesía de la fundación

Xiph.org, se pueden utilizar para comparar la calidad de varios formatos de compresión de audio:

Ogg Vorbis

AAC (m4a) AAC (Audio Advanced Coding) es un formato de compresión de

datos de audio desarrollado por el Instituto Fraunhofer conjuntamente con AT&T, Nokia, Sony y Dolby.

Como el formato MP3, el formato AAC aplica una forma de compresión que reduce algunos de los datos de audio, y que se denomina "compresión con pérdidas". Esto quiere decir que se eliminan algunos de los datos de audio (frecuencias inaudibles, por ejemplo) de manera que se pueda obtener el mayor grado de compresión posible, aunque se produce un archivo de salida que suena lo más parecido posible al original.

El formato AAC corresponde al estándar internacional "ISO/IEC 13818-7" como una extensión de MPEG-2: un estándar creado por MPEG (Moving Pictures Expert Group).

Apple ha elegido el formato AAC como formato principal de archivos para los iPods y para su software iTunes.

AAC (m4a) Características técnicas

El AAC utiliza una codificación variable de la frecuencia de bits (abreviado VBR), un método de codificación que adapta el número de bits utilizados por segundo para codificar datos de audio, en función de la complejidad de la transmisión de audio en un momento determinado. El algoritmo que se utiliza tiene un rendimiento superior al del MP3, que produce una mejor calidad en archivos pequeños y requiere menos recursos del sistema para codificar y decodificar.

A diferencia de los dos canales (estéreo) que, como máximo, puede admitir el formato MP3, AAC permite sonidos polifónicos con un máximo de 48 canales. El formato AAC también ofrece frecuencias de muestreo que varían de 8 Hz a 96,0 kHz, en contraposición con las frecuencias de mp3 que varían de 16 a 48 kHz.

Los archivos AAC, que tiene la extensión .mp4 (para MPEG-4), .m4a (para MPEG-4 Audio) o .m4p (para MPEG-4 protegido), son, al final, más pequeños que los archivos MP3.

AAC (m4a) Compatibilidad

El formato Ogg Vorbis no es compatible con el formato MP3. Esto significa que el usuario tiene que utilizar un reproductor de audio que admita el formato o instalar un codec específico para reproducir los archivos Ogg Vorbis.

Sin embargo, cada vez son más los programas de audio que pueden reproducir los archivos Ogg

Cine en casa El término "Home Cinema " se refiere a la habilidad de

recrear el sonido de una película de cine en casa, con la máxima fidelidad posible.

Para esto, se requiere lo siguiente: Un sistema de audio o video con audio multicanal, y dispositivos denominados amplificadores multicanales

para reproducir sonidos espaciales (audio 3D) a través de varios altavoces.

Sin embargo, existen muchos estándares para definir el número de altavoces y el tipo de formato de audio que se debe utilizar: Dolby Surround Dolby Surround Pro Logic Dolby Pro-Logic IIx Dolby Digital Dolby Digital EX (THX EX) DTS

Audio multicanal (5.1, 6.1, 7.1) El término "audio multicanal" se refiere al uso de

múltiples pistas de audio para reconstruir el sonido en un sistema de sonido de varios altavoces.

Se usan dos dígitos separados por un punto decimal (2.1, 5.1, 6.1, 7.1, etc.) para clasificar los diversos tipos de configuraciones de altavoces, dependiendo de la cantidad de pistas de audio que se utilicen.

El primer dígito muestra el número de canales primarios, cada uno de ellos se reproducen en un altavoz individual, en tanto que el segundo dígito se refiere a la presencia de un efecto de baja frecuencia (abreviado, LFE) que se reproduce en un altavoz para graves. Así, 1.0 corresponde al sonido mono (que significa un canal) y 2.0 corresponde al sonido estéreo.

Audio multicanal (5.1, 6.1, 7.1) Configuración del sonido Surround

Existe una configuración física óptima para los altavoces en función de la cantidad de canales de audio que se utilicen, de manera que produzcan el mejor efecto posible. Por este motivo, se encuentran iconos especiales en los equipos de sonido envolvente que simbolizan el número de canales y el espacio físico donde deben colocarse los altavoces. Se colocan pequeños cuadrados negros (uno para cada canal) en un recuadro que representa la habitación, indicando así la configuración:

Audio multicanal (5.1, 6.1, 7.1) Configuración 5.1

La configuración física de los altavoces en un sistema envolvente 5.1 es de suma importancia, ya que influye directamente en la calidad del sonido y en el realismo de los efectos de audio.

Para obtener mejores resultados, existen ciertas de reglas que se deben seguir para ubicar cada uno de los altavoces:

Los altavoces frontales se deben colocar, preferentemente, a la altura de los oídos de un oyente que se encuentre sentado. Los altavoces posteriores (surround) se deben colocar ligeramente por encima de esta altura.

Los altavoces frontales izquierdo y derecho se deben colocar a cada lado del televisor, ambos a la misma distancia. En la práctica, cada uno debe estar colocado en un ángulo de 25 a 45 grados del oyente.

El altavoz central se debe colocar directamente sobre o debajo del televisor, ya que se utiliza principalmente para transmitir los diálogos de los actores.

El altavoz para graves se puede colocar en cualquier lugar de la habitación, pero preferentemente en el piso, para transmitir mejor las vibraciones. Lo mejor es probar diferentes lugares en la habitación.

La posición óptima de los altavoces posteriores es situarlos a una corta distancia detrás del oyente, formando un ángulo de 90 a 110 grados con respecto a dicho oyente.

Audio multicanal (5.1, 6.1, 7.1) Configuración 6.1

La configuración 6.1 es similar a la configuración 5.1, ya que lo único que se añade es un altavoz central posterior para compensar el vacío entre los dos altavoces posteriores.

Audio multicanal (5.1, 6.1, 7.1) Configuración 7.1

La configuración 7.1 resuelve el vacío entre los dos altavoces posteriores, utilizando no uno, sino dos altavoces.

Dolby Surround Pro Logic Dolby Surround

El formato Dolby Surround, diseñado por los la sociedad Dolby Labs en 1982, es el primer sistema de codificación de audio digital que agrega un canal adicional a los dos canales utilizados en el sonido estéreo. Este canal adicional, denominado "envolvente", se utiliza para agregar una dimensión extra al sonido.

Los tres canales codificados en Dolby Surround viajan a través de dos canales estéreo tradicionales, de forma que mantienen la compatibilidad con el equipo de audio existente. Se necesita un decodificador para utilizar el tercer canal, mezclado discretamente con los otros dos canales.

El canal envolvente tiene una frecuencia límite superior de 7 kHz y un tiempo de demora de hasta 20 ms. para mejorar el realismo de los efectos.

Los dispositivos con un codificador Dolby Surround llevan el siguiente logotipo:

Dolby Surround Pro Logic Dolby Surround Pro Logic

Dolby Surround Pro Logic El formato Dolby Surround Pro Logic (normalmente denominado Dolby Pro Logic), que apareció en 1987, es una mejora de Dolby Surround, al que se agregó un cuarto canal: un canal central para reproducir las voces de los actores.

Por lo tanto, el sistema Dolby Pro Logic incluye: Dos altavoces laterales en el parte frontal Un altavoz central Dos altavoces envolventes posteriores (en mono) También añade mejoras en términos de calidad de restitución de

sonido y posibilidades de ajuste. Los dispositivos que pueden decodificar una fuente de audio

codificada Dolby Pro Logic llevan el siguiente logotipo:

Dolby Surround Pro Logic Dolby Pro Logic II

Dolby Pro Logic II, creado en agosto de 2000, puede reconstruir artificialmente un entorno acústico 5.1, aplicando procesamiento informático a una fuente estéreo (2.0) o Dolby Surround (3.0/4.0/4.1).

Los dispositivos que pueden decodificar una fuente de audio codificada Dolby Pro Logic II llevan el siguiente logotipo:

Los sistemas Dolby Surround y Dolby Pro Logic quedaron obsoletos con el surgimiento del Dolby Digital y del DTS. Sin embargo, todavía se utilizan para reproducir sonidos 3D desde una fuente estéreo.

Dolby Surround Pro Logic Dolby Pro Logic IIx

El estándar Dolby Pro Logic IIx,creado en 2003, puede reconstruir artificialmente entornos de sonido 6.1 o 7.1 de una fuente estéreo. Ofrece diversas configuraciones de sonido ambiente en función del uso de los altavoces: Movie para reproducir películas, Music para reproducir CD de audio, Game para videojuegos.

Los dispositivos que pueden decodificar una fuente de audio codificada Dolby Pro Logic IIx llevan el siguiente logotipo:

Dolby Digital / AC3 Introducción al formato Dolby Digital

El formato Dolby Digital, lanzado en 1987, es un estándar de codificación de audio digital desarrollado por los laboratorios Dolby Labs.

A diferencia de los sistemas Dolby ProLogic, las pistas de audio Dolby Digital son independientes (en ocasiones se utiliza el término "discretas"). En la electrónica de consumo, el formato Dolby Digital se basa en la compresión de un algoritmo denominado AC3 (Audio Coding 3) que puede comprimir los flujos de audio en un factor de 10 a 12, con un índice de muestreo de 16 bits a 48 kHz y una velocidad binaria global de 384 kbit/s. Por este motivo, el formato Dolby Digital se denomina, en algunos casos, Dolby AC3. Para los profesionales, en lugar de utilizar un decodificador AC3, el Dolby Digital utiliza un sistema denominado SR-D.

Dolby Digital es, probablemente, el sistema más utilizado en los sistemas home cinema (cine en casa). Para poder utilizar medios grabados en el formato Dolby Digital (video DVD o audio DVD, por ejemplo) se necesita un dispositivo con un decodificador AC3 integrado. Estos dispositivos se identifican normalmente por la presencia de este logotipo:

El formato Dolby Digital permite restituir el sonido en el espacio gracias a seis canales de audio independientes:

Un altavoz central colocado generalmente encima de la pantalla, para reproducir diálogos. Dos pistas de audio para los altavoces frontales, para acentuar el contexto de sonido que

proviene del altavoz central. Dos canales para los altavoces posteriores, utilizados para reproducir el ruido y el sonido

ambiente a fin de crear ambientación sonora. Un canal de frecuencias bajas (un altavoz para graves) para amplificar los efectos especiales (las

explosiones y los terremotos). El ancho de banda del formato Dolby Digital oscila entre los 20 Hz y los 20 kHz. Las cintas

grabadas Dolby Digital se pueden codificar en cualquiera de los siguientes formatos: en estéreo en 5.1. Se debe tener en cuenta que Dolby Digital muchas veces se confunde con el término

genérico "5.1".

Formato S/PDIF El estándar S/PDIF (Sony/Philips Digital Interface, o abreviado

SPDIF ) es un formato digital de transferencia de datos de audio. Es un estándar internacional conocido como "IEC-958 tipo II", que define tanto las especificaciones del hardware (características de las conexiones físicas) como el protocolo de transferencia de datos (codificación de 16 a 24 bits). El estándar S/PDIF se puede considerar la versión de gama baja de la interfaz profesional AES/EBU, a la que se le agregan algunas funciones de ahorro de energía.

S/PDIF se utiliza para almacenar sonido digitalmente en medios tales como DAT (Digital Audio Tape) o para manipularlo con dispositivos de manipulación de audio. La ventaja principal de S/PDIF reside en su capacidad para transferir sonidos entre dos dispositivos de audio digitales sin utilizar una conexión analógica que reduciría la calidad.

Sin embargo, una señal de audio S/PDIF codificada no sufre atenuación ni distorsión y se puede transferir sin pérdidas!

Formato S/PDIF Características

S/PDIF se utiliza para codificar datos de sonidos estéreo o multicanal (AC3, DTS, MPEG2, etc.)

El estándar S/PDIF admite los siguientes índices de muestreo:

44,1 Khz. de un CD 48 Khz. de una cinta DAT 32 Khz. de DSR

Formato S/PDIF Conectores

El estándar S/PDIF permite los siguientes métodos de conexión:

Cable asimétrico coaxial con una resistencia de 75 Ohms y conectores RCA. La distancia máxima recomendada para el cableado es de quince metros.

Cable de fibra óptica (1 mm de fibra plástica) con una conexión Toslink (TOShiba Link por Toshiba). Los datos se transfieren con el mismo formato, pero con señales de luces visibles emitidas por un LED (diodo emisor de luz) rojo. Teniendo en cuenta el deterioro de la señal óptica, el cable óptico no debe exceder los 10 m de largo.

Cable de fibra óptica con un mini-jack (o mini conector) de 3,5 mm. El mini-jack es idéntico a un enchufe normal mono audio (3,5 mm de diámetro), excepto que contiene en la punta una lente que le permite transmitir datos a través de un cable de fibra óptica.

En la práctica, la mayoría de los dispositivos (como tarjetas de sonido, reproductores de CD y DVD, amplificadores 5.1, etc.) vienen con un enchufe RCA (CINCH).

Unidad VI Programación de puertos einterrupciones.

6.1 Interrupciones. 6.2 Generalidades de los puertos. 6.3 Puerto serial y sus variantes.

6.3.1 USB. 6.3.2 Infrarrojo. 6.3.3 Fire wire.

6.4 Paralelo y sus variantes. 6.5 Interrupciones que intervienen en cada puerto.

6.5.1 Direcciones bases. 6.5.2 Registros.

6.6 Envío y recepción de los datos. 6.7 Ejemplos de programación entre puertos y dispositivos.

Interrupciones. Una interrupción es una señal de hardware, esta dice al

procesador que pare temporalmente lo que esta haciendo y que haga alguna otra cosa.

Sin interrupciones el procesador tendría que hacer un chequeo constante de eventos externos; con interrupciones el procesador puede trabajar sobre alguna otra cosa y responder a un evento tan pronto como este ocurra.

Invocación de Interrupciones. Las interrupciones del  procesador,  hardware  y software

son invocadas de diferente manera: Procesador: Las interrupciones del  procesador  o interrupciones 

lógicas  son  invocadas por el procesador como consecuencia de  un  resultado inusual del programa, tal como un intento de división por cero.

Hardware: Las interrupciones de hardware  son invocadas  por  mecanismos  periféricos   estos   fijan   sus  respectivas  líneas  de  petición  de  interrupción (IRQ).  Cada  vez  que  una  tecla es presionada, por  ejemplo, el  teclado genera   una interrupción. Las interrupciones  de hardware son vectoreadas a rutinas de servicio de interrupción  (ISRs) estas generalmente residen en el BIOS.

Software: Las  interrupciones  de  software  son  invocadas  a  través   de  la  instrucción  INT  del  8086.  La  mayoría de las interrupciones de software son  vectoreadas  a  (DSRs)  localizado en el BIOS, o en  programas de aplicación.

Generalidades de los puertos. Los puertos y conectores de E/S del panel posterior del

sistema son puertas de enlace a través de las cuáles el equipo se comunica con los dispositivos externos tales como el teclado, el mouse, la impresora y el monitor Conectores para teclado y mouse

Los equipos modernos utilizan un teclado estilo Personal System/2 (PS/2) y admite un Mouse compatible con el PS/2. Los cables de ambos dispositivos se conectan a conectores DIN (Deutsche Industrie Norm) miniatura de 6 patas en el panel posterior del equipo. Un Mouse compatible con el equipo PS/2 funciona de la misma manera que un Mouse serie convencional industrial o un Mouse de bus, a excepción de que tiene su propio conector dedicado, el cual evita la utilización de los puertos serie y no requiere una tarjeta de expansión.

Los circuitos dentro del mouse detectan el movimiento de una esfera pequeña y envían al equipo información sobre la dirección. El controlador de software del mouse le puede dar prioridad al mouse para ser atendido por el microprocesador activando la línea IRQ12 cada vez que ocurre nuevo movimiento del mouse. El controlador de software también transfiere los datos del mouse a la aplicación que se encuentra en control.

 Conector de vídeo  El equipo utiliza un conector D subminiatura de alta densidad de 15 patas en el

panel posterior para conectar al equipo un monitor compatible con el estándar VGA (Video Graphics Array [Arreglo de gráficos de vídeo]). Los circuitos de vídeo en la placa base sincronizan las señales que controlan los cañones de electrones rojo, verde y azul en el monitor.

Puerto serial y sus variantes. Puertos serie.

Los dos puertos serie integrados usan conectores tipo D-subminiatura de 9 patas en el panel posterior. Estos puertos son compatibles con dispositivos como módems externos, impresoras o los mouse que requieren transmisión de datos en serie (la transmisión de la información de un bit en una línea). La mayoría del software utiliza el término COM (derivado de comunicaciones) seguido de un número para designar un puerto serie (por ejemplo, COM1 ó COM2). Las opciones predeterminadas para los puertos serie integrados del sistema son COM1 y COM2.

Puerto serial y sus variantes. Puertos serie.

En informática, un puerto serie es una interfaz física de comunicación en serie a través de la cual se transfiere información mandando o recibiendo un bit. A lo largo de la mayor parte de la historia de las computadoras, la transferencia de datos a través de los puertos de serie ha sido generalizada. Se ha usado y sigue usándose para conectar las computadoras a dispositivos como terminales o módems. Los mouses, teclados, y otros periféricos también se conectaban de esta forma.

Mientras que otras interfaces como Ethernet, FireWire, y USB mandaban datos como un flujo en serie, el término "puerto serie" normalmente identifica el hardware más o menos conforme al estándar RS-232, diseñado para interactuar con un módem o con un dispositivo de comunicación similar.

A día de hoy 2009, en la mayoría de los periféricos la interfaz USB ha reemplazado al puerto serie puesto que es más rápida. La mayor parte de los ordenadores están conectados a dispositivos externos a través de USB y, a menudo, ni siquiera llegan a tener un puerto serie.

El puerto serie se elimina para reducir los costes y se considera que es un puerto heredado y obsoleto. Sin embargo, los puertos serie todavía se encuentran en sistemas de automatización industrial y algunos productos industriales y de consumo.

Los dispositivos de redes (como routers y switches) a menudo tienen puertos serie para modificar su configuración. Los puertos serie se usan a menudo en estas áreas porque son sencillos, baratos y permiten la interoperabilidad entre dispositivos. La desventaja es que configurar conexiones serie requiere, en la mayoría de los casos, el conocimiento y manejo por parte de un experto y el uso de comandos complejos si están mal implementados.

Puerto serial y sus variantes. Puerto serie asincrónico

A través de este tipo de puerto la comunicación se establece usando un protocolo de transmisión asíncrono. En esta caso, se envía en primer lugar una señal inicial anterior a cada byte, carácter o palabra codificada. Una vez enviado el código correspondiente se envía, inmediatamente, una señal de stop después de cada palabra codificada.

La señal de inicio sirve para preparar al mecanismo de recepción, o receptor, la llegada, y registro, de un símbolo, y la señal de stop sirve para predisponer al mecanismo de recepción para que tome un descanso y se prepare para la recepción del nuevo símbolo.

La típica transmisión star-stop es la que se usa en la transmisión de códigos ASCII a través del puerto RS-232, como la que se establece en las operaciones con teletipos.

El puerto serie RS-232 (también conocido como COM) es del tipo asincrónico, utiliza cableado simple desde 3 hilos hasta 25 y conecta ordenadores o microcontroladores a todo tipo de periféricos, desde terminales a impresoras y módems pasando por mouses.

La interfaz entre el RS-232 y el microprocesador generalmente se realiza mediante una UART 8250 (ordenadores de 8 y 16 bits, PC XT) o 16550 (IBM Personal Computer/AT y posteriores).

El RS-232 original tenía un conector tipo DB-25, sin embargo la mayoría de dichos pines no se utilizaban, por lo que IBM estandarizó con su gama IBM Personal System/2 el uso del conector DE-9 (ya introducido en el AT) que se usaba, de manera mayoritaria en ordenadores. Sin embargo, a excepción del mouses el resto de periféricos solían presentar el DB-25

En Europa la norma RS-422, similar al RS-232, es un estándar utilizado en el ámbito industrial.

Puerto serial y sus variantes. Tipos de comunicaciones seriales

Simplex En este caso el emisor y el receptor están perfectamente definidos y la comunicación es unidireccional. Este tipo de comunicaciones se emplean, usualmente, en redes de radiodifusión, donde los receptores no necesitan enviar ningún tipo de dato al transmisor.

Duplex, half duplex o semi-duplex En este caso ambos extremos del sistema de comunicación cumplen funciones de transmisor y receptor y los datos se desplazan en ambos sentidos pero no de manera simultánea. Este tipo de comunicación se utiliza habitualmente en la interacción entre terminales y un ordenador central.

Full Duplex El sistema es similar al duplex, pero los datos se desplazan en ambos sentidos simultáneamente. Para que sea posible ambos emisores poseen diferentes frecuencias de transmisión o dos caminos de comunicación separados, mientras que la comunicación semi-duplex necesita normalmente uno solo. Para el intercambio de datos entre computadores este tipo de comunicaciones son más eficientes que las transmisiones semi-dúplex.

Puerto serial y sus variantes. El estándar RS-232C

El puerto serie RS-232C, presente en todos los ordenadores actuales, es la forma mas comúnmente usada para realizar transmisiones de datos entre ordenadores. El RS-232C es un estándar que constituye la tercera revisión de la antigua norma RS-232, propuesta por la EIA (Asociaci¢n de Industrias Electrónicas), realizándose posteriormente un versión internacional por el CCITT, conocida como V.24. Las diferencias entre ambas son mínimas, por lo que a veces se habla indistintamente de V.24 y de RS-232C (incluso sin el sufijo "C"), refiriéndose siempre al mismo estándar.

El RS-232C consiste en un conector tipo DB-25 de 25 pines, aunque es normal encontrar la versión de 9 pines DB-9, mas barato e incluso mas extendido para cierto tipo de periféricos (como el ratón serie del PC). En cualquier caso, los PCs no suelen emplear mas de 9 pines en el conector DB-25. Las señales con las que trabaja este puerto serie son digitales, de +12V (0 lógico) y  -12V (1 lógico), para la entrada y salida de datos, y a la inversa en las señales de control. El estado de reposo en la entrada y salida de datos es -12V. Dependiendo de la velocidad de transmisión empleada, es posible tener cables de hasta 15 metros.

Puerto serial y sus variantes. El estándar RS-232C

Cada pin puede ser de entrada o de salida, teniendo una función especifica cada uno de ellos. Las mas importantes son: Pin Función TXD  (Transmitir Datos) RXD (Recibir Datos) DTR (Terminal de Datos Listo) DSR (Equipo de Datos Listo) RTS (Solicitud de Envío) CTS (Libre para Envío) DCD (Detección de

Portadora)

Puerto serial y sus variantes. El estándar RS-232C

Las señales TXD, DTR y RTS son de salida, mientras que RXD, DSR, CTS y DCD son de entrada. La masa de referencia para todas las señales es SG (Tierra de Señal). Finalmente, existen otras señales como RI (Indicador de Llamada), y otras poco comunes que no se explican en este artículo por rebasar el alcance del mismo.

Puerto serial y sus variantes. El puerto serie en el PC

El ordenador controla el puerto serie mediante un circuito integrado especifico, llamado UART (Transmisor-Receptor-Asíncrono Universal). Normalmente se utilizan los siguientes modelos de este chip: 8250 (bastante antiguo, con fallos, solo llega a 9600 baudios), 16450 (versión corregida del 8250, llega hasta 115.200 baudios) y 16550A (con buffers de E/S). A partir de la gama Pentium, la circuiteria UART de las placa base son todas de alta velocidad, es decir UART 16550A. De hecho, la mayoría de los módems conectables a puerto serie necesitan dicho tipo de UART, incluso algunos juegos para jugar en red a través del puerto serie necesitan de este tipo de puerto serie. Por eso  hay veces que un 486 no se comunica con la suficiente velocidad con un PC Pentium... Los portátiles suelen llevar otros chips: 82510 (con buffer especial, emula al 16450) o el 8251 (no es compatible).

Para controlar al puerto serie, la CPU emplea direcciones de puertos de E/S y líneas de interrupción (IRQ). En el AT-286 se eligieron las direcciones 3F8h (o 0x3f8) e IRQ 4 para el COM1, y 2F8h e IRQ 3 para el COM2. El estándar del PC llega hasta aquí, por lo que al añadir posteriormente otros puertos serie, se eligieron las direcciones 3E8 y 2E8 para COM3-COM4, pero las IRQ no están especificadas. Cada usuario debe elegirlas de acuerdo a las que tenga libres o el uso que vaya a hacer de los puertos serie (por ejemplo, no importa compartir una misma IRQ en dos puertos siempre que no se usen conjuntamente, ya que en caso contrario puede haber problemas). Es por ello que últimamente, con el auge de las comunicaciones, los fabricantes de PCs incluyan un puerto especial PS/2 para el ratón, dejando así libre un puerto serie.

Mediante los puertos de E/S se pueden intercambiar datos, mientras que las IRQ producen una interrupción para indicar a la CPU que ha ocurrido un evento (por ejemplo, que ha llegado un dato, o que ha cambiado el estado de algunas señales de entrada). La CPU debe responder a estas interrupciones lo mas rápido posible, para que de tiempo a recoger el dato antes de que el siguiente lo sobrescriba. Sin embargo, las UART 16550A incluyen unos buffers de tipo FIFO, dos de 16 bytes (para recepción y transmisión), donde se pueden guardar varios datos antes de que la CPU los recoja. Esto también disminuye el numero de interrupciones por segundo generadas por el puerto serie.

Puerto serial y sus variantes. El puerto serie en el PC

El RS-232 puede transmitir los datos en grupos de 5, 6, 7 u 8 bits, a unas velocidades determinadas (normalmente, 9600 bits por segundo o mas). Después de la transmisión de los datos, le sigue un bit opcional de paridad (indica si el numero de bits transmitidos es par o impar, para detectar fallos), y después 1 o 2 bits de Stop. Normalmente, el protocolo utilizado ser 8N1 (que significa, 8 bits de datos, sin paridad y con 1 bit de Stop).

Una vez que ha comenzado la transmisión de un dato, los bits tienen que llegar uno detrás de otro a una velocidad constante y en determinados instantes de tiempo. Por eso se dice que el RS-232 es asíncrono por caracter y sincrono por bit. Los pines que portan los datos son RXD y TXD. Las demás se encargan de otros trabajos: DTR indica que el ordenador esta encendido, DSR que el aparato conectado a dicho puerto esta encendido, RTS que el ordenador puede recibir datos (porque no esta ocupado), CTS que el aparato conectado puede recibir datos, y DCD detecta que existe una comunicación, presencia de datos.

Tanto el aparato a conectar como el ordenador (o el programa terminal) tienen que usar el mismo protocolo serie para comunicarse entre si. Puesto que el estándar RS-232 no permite indicar en que modo se esta trabajando, es el usuario quien tiene que decidirlo y configurar ambas partes. Como ya se ha visto, los parámetros que hay que configurar son: protocolo serie (8N1), velocidad del puerto serie, y protocolo de control de flujo. Este ultimo puede ser por hardware (el que ya hemos visto, el handshaking RTS/CTS) o bien por software (XON/XOFF, el cual no es muy recomendable ya que no se pueden realizar transferencias binarias). La velocidad del puerto serie no tiene por que ser la misma que la de transmisión de los datos, de hecho debe ser superior. Por ejemplo, para transmisiones de 1200 baudios es recomendable usar 9600, y para 9600 baudios se pueden usar 38400 (o 19200).

USB. Conectores USB  

En un principio teníamos la interfaz serie y paralelo, pero era necesario unificar todos los conectores creando uno más sencillo y de mayores prestaciones. Así nació el  USB (Universal Serial Bus) con una velocidad de 12Mb/seg. y como su evolución, USB 2.0, apodado USB de alta velocidad, con velocidades en este momento de hasta 480Mb/seg., es decir, 40 veces más rápido que las conexiones mediante cables USB 1.1.Un puerto USB puede llegar a transmitir a velocidades entre 1,5 Mb/segundo y 12 Mbps; un puerto paralelo entre 600 Kb/s a 1,5 Mb/s y un puerto serial puede llegar hasta 112 Kb/s.USB es una nueva arquitectura de bus o un nuevo tipo de bus desarrollado por un grupo de siete empresas(Compaq, Digital Equipment Corp, IBM PC Co., Intel, Microsoft, NEC y Northern Telecom) que forma parte de los avances plug-and-play y permite instalar periféricos sin tener que abrir la máquina para instalarle hardware, es decir, basta con que conectes dicho periférico en la parte posterior de tu computador y listo.

USB. ¿Qué es?.

USB Universal Serial Bus es una interfase plug&play entre la PC y ciertos dispositivos tales como teclados, mouses, scanner, impresoras, módems, placas de sonido, camaras, etc).Una característica importante es que permite a los dispositivos trabajar a velocidades mayores, en promedio a unos 12 Mbps, esto es más o menos de 3 a 5 veces más rápido que un dispositivo de puerto paralelo y de 20 a 40 veces más rápido que un dispositivo de puerto serial.

¿Cómo funciona?.Trabaja como interfaz para transmisión de datos y distribución de energía, que ha sido introducida en el mercado de PC´s y periféricos para mejorar las lentas interfaces serie (RS-232) y paralelo. Esta interfaz de 4 hilos, 12 Mbps y "plug and play", distribuye 5V para alimentación, transmite datos y está siendo adoptada rápidamente por la industria informática.Es un bus basado en el paso de un testigo, semejante a otros buses como los de las redes locales en anillo con paso de testigo y las redes FDDI. El controlador USB distribuye testigos por el bus. El dispositivo cuya direccióncoincide con la que porta el testigo responde aceptando o enviando datos al controlador. Este también gestiona la distribución de energía a los periféricos que lo requieran. Emplea una topología de estrellas apiladas que permite el funcionamiento simultáneo de 127 dispositivos a la vez. En la raíz o vértice de las capas, está el controlador anfitrión o host que controla todo el tráfico que circula por el bus. Esta topología permite a muchos dispositivos conectarse a un único bus lógico sin que los dispositivos que se encuentran más abajo en la pirámide sufran retardo. A diferencia de otras arquitecturas, USB no es un bus de almacenamiento y envío, de forma que no se produce retardo en el envío de un paquete de datos hacia capas inferiores.Como detalle sorprendente es que cada puerto utiliza una única solicitud de interrupción (IRQ) independientemente de los periféricos que tenga conectados (sea 1 ó 127) por lo tanto no hay riesgo de conflictos entre una cantidad de dispositivos que de otra forma no podrían ser conectados por falta de recursos; de la misma manera tampoco utilizan DMA (asignación de memoria).

USB. El sistema de bus serie universal USB consta de tres componentes:

Controlador. Hubs o Concentradores. Periféricos.

Diagrama de capas.

El software cliente se ejecuta en el host y corresponde a un dispositivo USB; se suministra con el sistema operativoo con el dispositivo USB. El software del sistema USB, es el que soporta USB en un determinado sistema operativo y se suministra con el sistema operativo independientemente de los dispositivos USB o del software cliente. El controlador anfitrión USB está constituido por el hardware y el software que permite a los dispositivos USB ser conectados al anfitrión. Como se muestra en la figura 3, la conexión entre un host y un dispositivo requiere la interacción entre las capas. La capa de interfaz de bus USB proporciona la conexión física entre el host y el dispositivo. La capa de dispositivo USB es la que permite que el software del sistema USB realice operaciones genéricas USB con el dispositivo.

La capa de función proporciona capacidades adicionales al host vía una adecuada capa de software cliente . Las capas de función y dispositivos USB tienen cada una de ellas una visión de la comunicación lógica dentro de su nivel, aunque la comunicación entre ellas se hace realmente por la capa de interfaz de bus USB .

USB. Controlador

El controlador reside dentro del PC y es responsable de las comunicaciones entre los periféricos USB y la CPUdel PC. Es también responsable de la admisión de los periféricos dentro del bus, tanto si se detecta una conexión como una desconexión. Para cada periférico añadido, el controlador determina su tipo y le asigna una dirección lógica para utilizarla siempre en las comunicaciones con el mismo. Si se producen errores durante la conexión, el controlador lo comunica a la CPU, que, a su vez, lo transmite al usuario. Una vez se ha producido la conexión correctamente, el controlador asigna al periférico los recursos del sistema que éste precise para su funcionamiento. El controlador también es responsable del control de flujo de datos entre el periférico y la CPU.

Concentradores o hubsSon distribuidores inteligentes de datos y alimentación, y hacen posible la conexión a un único puerto USB de 127 dispositivos. De una forma selectiva reparten datos y alimentación hacia sus puertas descendentes y permiten la comunicación hacia su puerta de retorno o ascendente. Un hub de 4 puertos, por ejemplo, acepta datos del PC para un periférico por su puerta de retorno o ascendente y los distribuye a las 4 puertas descendentes si fuera necesario. Los concentradores también permiten las comunicaciones desde el periférico hacia el PC, aceptando datos en las 4 puertas descendentes y enviándolos hacia el PC por la puerta de retorno. Además del controlador, el PC también contiene el concentrador raíz. Este es el primer concentrador de toda la cadena que permite a los datos y a la energía pasar a uno o dos conectores USB del PC, y de allí a los 127 periféricos que, como máximo, puede soportar el sistema. Esto es posible añadiendo concentradores adicionales. Por ejemplo, si el PC tiene una única puerta USB y a ella le conectamos un hub o concentrador de 4 puertas, el PC se queda sin más puertas disponibles. Sin embargo, el hub de 4 puertas permite realizar 4 conexiones descendentes. Conectando otro hub de 4 puertas a una de las 4 puertas del primero, habremos creado un total de 7 puertas a partir de una puerta del PC. De esta forma, es decir, añadiendo concentradores, el PC puede soportar hasta 127 periféricos USB. La mayoría de los concentradores se encontrarán incorporados en los periféricos. Por ejemplo, un monitorUSB puede contener un concentrador de 7 puertas incluido dentro de su chasis. El monitor utilizará una de ellas para sus datos y control y le quedarán 6 para conectar allí otros periféricos.

.

USB. Cables y conectores.

USB 1.1 transfiere señales y energía a los periféricos utilizando un cable de 4 hilos, apantallado para transmisiones a 12 Mbps y no apantallado para transmisiones a 1.5 Mbps. En la figura 6 se muestra un esquema del cable, con dos conductores para alimentación y los otros dos para señal, debiendo estos últimos ser trenzados o no según la velocidad de transmisión.El calibre de los conductores destinados a alimentación de los periféricos varía desde 20 a 26 AWG, mientras que el de los conductores de señal es de 28 AWG. La longitud máxima de los cables es de 5 metros. Por lo que respecta a los conectores hay que decir que son del tipo ficha (o conector ) y receptáculo, y son de dos tipos: serie A y serie B . Los primeros presentan las cuatro patillas correspondientes a los cuatro conductores alineadas en un plano. El color recomendado es blanco sucio y los receptáculos se presentan en cuatro variantes: vertical, en ángulo recto, panel y apilado en ángulo recto así como para montaje pasamuro. Se emplean en aquellos dispositivos en los que el cable externo, está permanentemente unido a los mismos, tales como teclados, ratones, y hubs o concentradores. Los conectores de la serie B presentan los contactos distribuidos en dos planos paralelos, dos en cada plano, y se emplean en los dispositivos que deban tener un receptáculo al que poder conectar un cable USB. Por ejemplo impresoras, scanner, y módems . Aplicaciones actuales y posibilidades a futuro. Discos duros de estado sólido portátiles. Adaptadores de video para monitores de PC. Grabadores de audio y video sobre bus USB. Conexiones de PC a PC a través de puertos USB. Sustitución de los puertos serie y paralelo.

Infrarrojo. El 28 de Junio de 1993, 50 compañías relacionadas con la

computación decidieron que era tiempo de desarrollar comunicación inalámbrica para computadoras, formando la Asociación de Desarrolladores de Infrarrojo (Infrared Developers Association, IrDA).

  La idea detrás del IrDA era crear un estándar para utilizar

rayos infrarrojos para unir una computadora y otros periféricos. Hasta este momento en la historia los rayos infrarrojos habían sido utilizados únicamente en controles remotos para dispositivos y algunas computadoras portátiles; sin embargo cada uno de los fabricantes creaba su propio esquema de comunicación haciendo poco compatible la comunicación entre dispositivos.

  Para finales de Junio de 1994, IrDA estableció el primer

estándar, conocido como IrDA versión 1.0 que era básicamente una forma óptica del puerto de comunicaciones RS-232. En Agosto de 1995 IrDA ajustó el estándar para comunicaciones infrarrojas extendiendo la velocidad de comunicación a 4 megabits por segundo.

Infrarrojo. Las comunicaciones infrarrojas están basadas en el principio

de la luz infrarroja, que es una radiación electromagnética cuya frecuencia la hace invisible al ojo humano, La luz visible viaja en ases de luz que van desde los  400 ángstrom, violeta oscuro, a 700 ángstrom, rojo oscuro. Las frecuencias del infrarrojo es de 700 a 1,000 ángstrom. Conforme a los estándares del IrDA la mayoría de las computadoras personales y equipo de comunicaciones se mantienen entre los 850 y 900 ángstrom

Infrarrojo. Aunque la comunicación infrarroja está basada en luz, utiliza pulsos para

transmitir datos. Estos pulsos varían con respecto a los digitales en que mientras los anteriores son constantes durante un ciclo de reloj los pulsos IrDA duran sólo una fracción del ciclo básico de reloj o celda estándar de bit. Estos pulsos son distribuidos ampliamente entre ellos, lo que los hace fáciles de recibir y distinguir en el receptor IrDA

  Los datos transmitidos por un dispositivo IrDA son transmitidos en un

formato de 8 bits, conforme al estándar de la IRDA, 8 bits de datos, bit de paridad, y bit de paro para un total de 10 bits por carácter.

  En 1997 los miembros de IrDA se reunieron para promover nuevos

dispositivos inalámbricos para el mercado de consumo y artilugios de comunicaciones que tomaban ventaja de la tecnología IrBUS.

IrBus es el nombre original para los estándares de la IrDA, que permitía comunicación bidireccional entre dispositivgos separados hasta por 24 pies, haciendo posible la creación de palancas de mano, tapetes de juegos y unidades de disco. IrBus también era capaz de comunicación simultánea con dos anfitriones y era capaz de soportar hasta 8 dispositivos. También se especulaba que futuros dispositivos IrBus pudieran ser integrados a objetos domésticos como hornos de microondas.

Fire wire. Puertos Firewire

Apple inventó el FireWire a mediados de los 90 y lo mimó hasta convertirlo en el estándar multiplataforma IEEE 1394. FireWire es una tecnología para la entrada/salida de datos en serie a alta velocidad y la conexión de dispositivos digitales como videocámaras o cámaras fotográficas digitales y ordenadores portátiles o de sobremesa. Ampliamente adoptado por fabricantes de periféricos digitales como Sony, Canon, JVC y Kodak, el FireWire se ha convertido en el estándar establecido tanto para consumidores como para profesionales.FireWire es uno de los estándares de periféricos más rápidos que se han desarrollado, característica que lo hace ideal para su uso con periféricos del sector multimedia (como cámaras de vídeo) y otros dispositivos de alta velocidad como, por ejemplo, lo último en unidades de disco duro e impresoras.Se ha convertido en la interfaz preferida de los sectores de audio y vídeo digital, reúne numerosas ventajas, entre las que se encuentran la elevada velocidad, la flexibilidad de la conexión y la capacidad de conectar un máximo de 63 dispositivos.Además de cámaras y equipo de vídeo digital, la amplia gama de productos FireWire comprende reproductores de vídeo digital, sistemas domésticos para el ocio, sintetizadores de música, escáneres y unidades de disco duro.

Fire wire. ¿Qué es?

Con un ancho de banda 30 veces mayor que el conocido estándar de periféricos USB 1.1, el FireWire 400 se ha convertido en el estándar más respetado para la transferencia de datos a alta velocidad. Apple fue el primer fabricante de ordenadores que incluyó FireWire en toda su gama de productos. Una vez más, Apple ha vuelto a subir las apuestas duplicando la velocidad de transferencia con su implementación del estándar IEEE 1394b FireWire 800.

¿Cómo funciona?FireWire 800 (Fireware 2 y/o IEEE1394b)La velocidad sobresaliente del FireWire 800 frente al USB 2.0 convierten al primero en un medio mucho más adecuado para aplicaciones que necesitan mucho ancho de banda, como las de gráficos y vídeo, que a menudo consumen cientos o incluso miles de megabytes de datos por archivo. Por ejemplo, una hora de vídeo en formato DV ocupa unos 13.000 megabytes (13 GB). Otras de sus ventajas son, por ejemplo: Arquitectura altamente eficiente. IEEE 1394b reduce los retrasos en la negociación, mientras la 8B10B (8 bits se codifican en 10 bits. Este códigofue desarrollado por IBM y permite suficientes transiciones de reloj, la codificación de señales de control, detección de errores. El código 8B10B es similar a 4B5B de FDDI, el que no fue adoptado debido al pobre equilibrio de corriente continua) reduce la distorsión de señal y aumenta la velocidad de transferencia.Mejor vivencia como usuario. Da igual cómo conectes tus dispositivos entre ellos, FireWire 800 funciona a la perfección. Por ejemplo, puedes incluso enlazar a tu Mac la cadena de dispositivos FireWire 800 por los dos extremos para mayor seguridad durante acontecimientos en directo.Compatibilidad retroactiva. Los fabricantes han adoptado el FireWire para una amplia gama de dispositivos, como videocámaras digitales, discos duros, cámaras fotográficas digitales, audio profesional, impresoras, escáneres y electrodomésticos para el ocio. Los cables adaptadores para el conector de 9 contactos del FireWire 800 te permiten utilizar productos FireWire 400 en el puerto FireWire 800.FireWire 800 comparte las revolucionarias prestaciones del FireWire 400:Flexibles opciones de conexión. Conecta hasta 63 ordenadores y dispositivos a un único bus: puedes incluso compartir una cámara entre dos Mac’s o PC’s.Distribución en el momento. Fundamental para aplicaciones de audio y vídeo, donde un fotograma que se retrasa o pierde la sincronización arruina un trabajo, el Firewire puede garantizar una distribución de los datos en perfecta sincronía. Alimentación por el bus. Mientras el USB 2.0 permite la alimentación de dispositivos sencillos y lentos que consumen un máximo de 2,5 W, como un ratón, los dispositivos Firewire pueden proporcionar o consumir hasta 45 W, más que suficiente para discos duros de alto rendimiento y baterías de carga rápida.Conexiones de enchufar y listo. No tienes más que enchufar un dispositivo para que eche a andar.

Fire wire. Ventajas de Firewire

Alcanzan una velocidad de 400 megabits por segundo. es hasta cuatro veces más rápido que la red Ethernet 100Base-T y 40 veces más rápido que la red Ethernet 10-Base-T.

Soporta la conexión de hasta 63 dispositivos con cables de una longitud máxima de 425 cm.

No es necesario apagar un escáner o una unidad de CD antes de conectarlo o desconectarlo, y tampoco requiere reiniciar la computadora.

Los cables FireWire se conectan muy fácilmente: no requieren números de identificación de dispositivos, conmutadores DIP, tornillos, cierres de seguridad ni terminadores.

FireWire funciona tanto con Macintosh como con PC. FireWire 400 envía los datos por cables de hasta 4,5 metros de

longitud. Mediante fibra óptica profesional, FireWire 800 puede distribuir información por cables de hasta 100 metros, lo que significa que podrías disparar ese CD hasta la otra punta de un campo de fútbol cada diez segundos.

ni siquiera necesitas ordenador o dispositivos nuevos para alcanzar estas distancias. Siempre que los dispositivos se conecten a un concentrador FireWire 800, puedes enlazarlos mediante un cable de fibra óptica súpereficiente.

 

Paralelo y sus variantes. Puertos paralelo  

El puerto paralelo integrado usa un conector tipo D-subminiatura de 25 patas en el panel posterior del sistema. Este puerto de E/S envía datos en formato paralelo (ocho bits de datos, formando un byte, se envían simultáneamente sobre ocho líneas individuales en un solo cable). El puerto paralelo se utiliza principalmente para impresoras.

La mayoría del software usa el término LPT más un número para designar un puerto paralelo (por ejemplo, LPT1). La opción predeterminada del puerto paralelo integrado del sistema es LPT1.

 

Interrupciones que intervienen en cada puerto. Para ganar la atención de la CPU, se utilizan líneas de solicitud de

interrupción (IRQ-Interrupt Request). El bus de la PC ofrece las líneas 2 a 7. Respetan prioridades, siendo la línea 2 más importante que la línea 7. Cuando se activa una línea, el procesador deja todo lo demás y carga una subrutina especial para encargarse de (dar servicio a ) esa línea de interrupción en particular. 

  Usos mas comunes de las IRQ en la PC

IRQ 0=Timer IRQ 1=Teclado IRQ 2=Interrupción del 8259 esclavo IRQ 3=Puerto serial 2 ( COM2 ) IRQ 4=Puerto serial 1 ( COM1 ) IRQ 5=Puerto paralelo 2 ( LPT2 ) IRQ 6=Controlador de disco flexible IRQ 7=Puerto paralelo 1 ( LPT1 ) IRQ 8=Timer IRQ 9=Adaptador de LAN IRQ 10=Reservada IRQ 11=Reservada IRQ 12=Reservada IRQ 13=Cooprocesador 80287 IRQ 14=Controlador de disco duro IRQ 15=Reservada

 

Pasos para el procesamiento de una IRQ: 1) Terminar la ejecución en curso.   2) Salva el valor de contador de programa, PC, en la pila, de manera que en

la CPU, al terminar el proceso, pueda seguir ejecutando el programa a partir de la última instrucción.

  3) La CPU salta a la dirección donde esta almacenada la rutina de

interrupción (RSI) y ejecuta esa rutina que tiene como objetivo atender al dispositivo que género la interrupción.

  4) Una vez que la rutina de la interrupción termina el procesador vuelve a

tomar el control, este va a la pila donde están todos los registros para retomar la ejecución del programa que se estaba usando anteriormente.  

Direcciones bases. Las I/O Address (Input/Output Address, direcciones de entrada/salida) son unas direcciones de

memoria en las cuales se almacenan los datos obtenidos desde un periférico, tarjeta, etc.  Para la correcta comprensión, por ejemplo una vez que el ratón ha solicitado la IRQ y que esta ha sido atendida, los valores del ratón (al moverse, al pulsar un botón, etc.) son colocados en una posición de memoria fija, a la cual el CPU puede acceder para procesar la información, o bien para mandarla al programa, o donde corresponda.  Esa dirección es la I/O Address.

 

En un principio, cualquier dirección de memoria base puede ser una I/O Address, siempre y cuando no interfiera con nada.  Las I/O Address pueden ser necesarias para la transferencia de datos desde un scanner, una capturadora, etc.

 

Lo que sucede es que ya hay una serie de direcciones standard para determinados dispositivos, los que siempre acompañan al ordenador, y el software debe saber que se usan para esos dispositivos y nada más.  Las más comunes son:

1F0: Primer disco duro.

1F8: Segundo disco duro.

170: Tercer disco duro.

178: Cuarto disco duro.

3F8: COM1.

2F8: COM2.

3E8: COM3.

2E8: COM4.

378: LPT1.

278: LPT2.

3BC: LPT3.

Existen otras direcciones I/O, pero estas son las más importantes.

 

Registros. Los registros del procesador se emplean para controlar instrucciones en ejecución, manejar

direccionamiento de memoria y proporcionar capacidad aritmética. Los registros son direccionables por medio de un nombre.

Registros de Propósito General

Los registros de propósito general AX, BX, CX y DX son los caballos de batalla del sistema. Son únicos en el sentido de que se les puede direccionar como una palabra o como un byte. Registro AX: El registro AX es el registro acumulador, es utilizado para operaciones que implican

entrada/salida y la mayor parte de la aritmética. Registro BX: El registro BX es el registro base, y es el único registro de propósito general que puede ser

un índice para direccionamiento indexado. También es común emplear el BX para cálculos. Registro CX: El registro CX es conocido como el registro contador. Puede contener un valor para

controlar el número de veces que un ciclo se repite o un valor para corrimiento de bits. Registro DX: El registro DX es el registro de datos. Algunas operaciones de entrada/salida requieren su

uso, y las operaciones de multiplicación y división con cifras grandes suponen al DX y AX trabajando juntos.

Registros Índice: Los registros SI y DI están disponibles para direccionamiento indexado y para sumas y restas.

Registro SI: El registro índice fuente de 16 bits es requerido por algunas operaciones con cadenas de caracteres. El SI está asociado con el registro DS.

Registro DI: El registro índice destino también es requerido por algunas operaciones con cadenas de caracteres. El DI está asociado con el registro ES.

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

Registro SP: El apuntador de pila de 16 bits está asociado con el registro SS y proporciona un valor de desplazamiento que se refiere a la palabra actual que está siendo procesada en la pila. El sistema maneja de manera automática este registro.

Registro BP: El apuntador base de 16 bits facilita la referencia de parámetros, los cuales son datos y direcciones transmitidos vía la pila.

Registro de Banderas: Es un registro de 16 bits, de los cuales nueve sirven para indicar el estado actual de la máquina y el resultado del procesamiento. Muchas instrucciones aritméticas y de comparación cambian el estado de las banderas y apoyándose de ellas determinan la acción subsecuente.

 

Registros. Los bits de las banderas son las siguientes:

OF (overflow, desbordamiento): Indica desbordamiento del bit de mayor orden después de una operación aritmética de números signados (1=existe overflow; 0=no existe overflow). Para operaciones sin signo, no se toma en cuenta esta bandera.

DF (dirección): Controla la selección de incremento o decremento de los registros SI o DI en las operaciones con cadenas de caracteres (1=decremento automático; 0=incremento). La bandera DF se controla con las instrucciones STD y CLD.

IF (interrupción): Indica que una interrupción externa sea procesada o ignorada (1=habilita la interrupción; 0=deshabilita la interrupción). El estado de la bandera IF se controla con las instrucciones STI y CLI.

TF (trampa): Permite la operación del procesador en modo de depuración (paso a paso)

SF (signo): Contiene el signo resultante de una operación aritmética (0=positivo; 1=negativo).

ZF (cero): Indica el resultado de una operación aritmética o de comparación (0=resultado diferente de cero; 1=resultado igual a cero).

AF (acarreo auxiliar): Contiene un acarreo externo del bit 3 en un dato de 8 bits, para aritmética especializada. Esta bandera se prueba con las instrucciones DAA y DAS para ajustar el valor de AL después de una suma o resta BCD.

PF (paridad): Indica paridad par o impar en una operación de datos de ocho bits (0=paridad impar; 1=paridad par).

CF (acarreo): Contiene el acarreo de los bits de mayor orden después de una operación aritmética; también almacena el contenido del último bit en una operación de corrimiento o de rotación.

 

Registros. Registros de Segmento Un registro de segmento tiene 16 bits de longitud y

facilita un área de memoria para direccionamiento conocida como el segmento actual.

Registro CS: El DOS almacena la dirección inicial del segmento de código de un programa en el registro CS. Esta dirección de segmento, más un valor de desplazamiento en el registro apuntador de instrucción (IP), indica la dirección de una instrucción que es buscada para su ejecución. Para propósitos de programación normal, no se necesita referenciar el registro CS.

Registro DS: La dirección inicial de un segmento de datos de programa es almacenada en el registro DS. Esta dirección, más un valor de desplazamiento en una instrucción, genera una referencia a la localidad de un byte específico en el segmento de datos.

Registro SS: El registro SS permite la colocación en memoria de una pila, para almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio del segmento de pila de un programa en el registro SS. Esta dirección de segmento, más un valor de desplazamiento en el registro del apuntador de la pila (SP), indica la palabra actual en la pila que está siendo direccionada. Para propósitos de programación normal, no se necesita referenciar el registro SS.

Registro ES: Algunas operaciones con cadenas de caracteres utilizan el registro extra de segmento para manejar el direccionamiento de memoria. El registro ES está asociado con el registro DI (Índice). Un programa que requiere el uso del registro ES puede inicializarlo con una dirección de segmento apropiada.

Registro Apuntador de Instrucciones El registro IP de 16 bits contiene el desplazamiento de dirección de la siguiente instrucción que se ejecuta. El IP está asociado con el registro CS en el sentido de que el IP indica la instrucción actual dentro del segmento de código que se está ejecutando actualmente.

Envío y recepción de los datos. Para el envió y recepción de datos se debe utilizar un socket de cliente

asincrónico o sincrono. Un socket de cliente asincrónico no suspende la aplicación mientras espera a que concluyan las operaciones de red. En su lugar, utiliza el modelo de programación asincrónica estándar de .NET Framework para procesar la conexión de red en un subproceso mientras la aplicación se sigue ejecutando en el subproceso original. Los sockets asincrónicos son adecuados para aplicaciones que utilizan la red de manera intensiva o que no pueden esperar a que concluyan las operaciones de red antes de continuar.

  La clase Socket sigue el modelo de nomenclatura de .NET Framework para

métodos asincrónicos; por ejemplo, el método sincrónico Receive se corresponde con los métodos asincrónicos BeginReceive y EndReceive.

  Las operaciones asincrónicas requieren un método de devolución de

llamada para devolver el resultado de la operación. Si la aplicación no necesita saber el resultado, no se requiere el método de devolución de llamada.

   

Envío y recepción de los datos. Los sockets asincrónicos utilizan subprocesos del grupo de subprocesos del

sistema para procesar conexiones con la red. Un subproceso se encarga de iniciar el envío o la recepción de datos; otros subprocesos concluyen la conexión al dispositivo de red y envían o reciben los datos. En los siguientes ejemplos se utilizan instancias de la clase System.Threading.ManualResetEvent para suspender la ejecución del subproceso principal e indicar cuándo puede continuar la ejecución.

  La lectura de datos de un socket de cliente requiere un objeto de estado

que pase valores entre llamadas asincrónicas. El método Receive configura el objeto de estado y después llama al método BeginReceive para leer los datos del socket de cliente de forma asincrónica.

El método de devolución de llamada a la recepción ReceiveCallback implementa el delegado de AsyncCallback. Recibe los datos del dispositivo de red y genera una cadena de mensaje Lee uno o más bytes de datos de la red en el búfer de datos y después vuelve a llamar al método BeginReceive hasta que se completen los datos enviados por el cliente. Una vez que el cliente haya leído todos los datos, ReceiveCallback indica al subproceso de aplicación que los datos están completos mediante el establecimiento de ManualResetEvent sendDone.

 

Ejemplos de programación entre puertos y dispositivos.

El siguiente código de ejemplo demuestra el uso de la clase SerialPort para permitir a dos usuarios chatear en dos ordenadores conectados por un cable null módem. En este ejemplo, a los usuarios se les pregunta por la configuración del puerto y un nombre de usuario antes de chatear. Ambos equipos deben estar ejecutando el programa para lograr la plena funcionalidad de este ejemplo.

Ejemplos de programación entre puertos y dispositivos.

using System;

using System.IO.Ports;

using System.Threading;

 

public class PortChat

{

static bool _continue;

static SerialPort _serialPort;

 

Ejemplos de programación entre puertos y dispositivos.public static void Main()

{

string name;

string message;

StringComparer stringComparer = StringComparer.OrdinalIgnoreCase;

Thread readThread = new Thread(Read);

 

// Create a new SerialPort object with default settings.

_serialPort = new SerialPort();

 

// Allow the user to set the appropriate properties.

_serialPort.PortName = SetPortName(_serialPort.PortName);

_serialPort.BaudRate = SetPortBaudRate(_serialPort.BaudRate);

_serialPort.Parity = SetPortParity(_serialPort.Parity);

_serialPort.DataBits = SetPortDataBits(_serialPort.DataBits);

_serialPort.StopBits = SetPortStopBits(_serialPort.StopBits);

_serialPort.Handshake = SetPortHandshake(_serialPort.Handshake);

 

// Set the read/write timeouts

_serialPort.ReadTimeout = 500;

_serialPort.WriteTimeout = 500;

 

Ejemplos de programación entre puertos y dispositivos. _serialPort.Open();

_continue = true;

readThread.Start();

Console.Write("Name: ");

name = Console.ReadLine();

Console.WriteLine("Type QUIT to exit");

while (_continue)

{

message = Console.ReadLine();

if (stringComparer.Equals("quit", message))

{

_continue = false;

}

else

{

_serialPort.WriteLine(

String.Format("<{0}>: {1}", name, message) );

}

}

readThread.Join();

_serialPort.Close();

}

 

Ejemplos de programación entre puertos y dispositivos.public static void Read()

{

while (_continue)

{

try

{

string message = _serialPort.ReadLine();

Console.WriteLine(message);

}

catch (TimeoutException) { }

}

}

 

Ejemplos de programación entre puertos y dispositivos.public static string SetPortName(string defaultPortName)

{

string portName;

 

Console.WriteLine("Available Ports:");

foreach (string s in SerialPort.GetPortNames())

{

Console.WriteLine(" {0}", s);

}

 

Console.Write("COM port({0}): ", defaultPortName);

portName = Console.ReadLine();

 

if (portName == "")

{

portName = defaultPortName;

}

return portName;

}

 

Ejemplos de programación entre puertos y dispositivos.public static int SetPortBaudRate(int defaultPortBaudRate)

{

string baudRate;

 

Console.Write("Baud Rate({0}): ", defaultPortBaudRate);

baudRate = Console.ReadLine();

 

if (baudRate == "")

{

baudRate = defaultPortBaudRate.ToString();

}

 

return int.Parse(baudRate);

}

 

Ejemplos de programación entre puertos y dispositivos.public static Parity SetPortParity(Parity defaultPortParity)

{

string parity;

 

Console.WriteLine("Available Parity options:");

foreach (string s in Enum.GetNames(typeof(Parity)))

{

Console.WriteLine(" {0}", s);

}

 

Console.Write("Parity({0}):", defaultPortParity.ToString());

parity = Console.ReadLine();

 

if (parity == "")

{

parity = defaultPortParity.ToString();

}

 

return (Parity)Enum.Parse(typeof(Parity), parity);

}

 

Ejemplos de programación entre puertos y dispositivos.public static int SetPortDataBits(int defaultPortDataBits)

{

string dataBits;

 

Console.Write("Data Bits({0}): ", defaultPortDataBits);

dataBits = Console.ReadLine();

 

if (dataBits == "")

{

dataBits = defaultPortDataBits.ToString();

}

 

return int.Parse(dataBits);

}

 

Ejemplos de programación entre puertos y dispositivos.public static StopBits SetPortStopBits(StopBits defaultPortStopBits)

{

string stopBits;

 

Console.WriteLine("Available Stop Bits options:");

foreach (string s in Enum.GetNames(typeof(StopBits)))

{

Console.WriteLine(" {0}", s);

}

 

Console.Write("Stop Bits({0}):", defaultPortStopBits.ToString());

stopBits = Console.ReadLine();

 

if (stopBits == "")

{

stopBits = defaultPortStopBits.ToString();

}

 

return (StopBits)Enum.Parse(typeof(StopBits), stopBits);

}

 

Ejemplos de programación entre puertos y dispositivos. public static Handshake SetPortHandshake(Handshake defaultPortHandshake)

{

string handshake;

 

Console.WriteLine("Available Handshake options:");

foreach (string s in Enum.GetNames(typeof(Handshake)))

{

Console.WriteLine(" {0}", s);

}

 

Console.Write("Stop Bits({0}):", defaultPortHandshake.ToString());

handshake = Console.ReadLine();

 

if (handshake == "")

{

handshake = defaultPortHandshake.ToString();

}

 

return (Handshake)Enum.Parse(typeof(Handshake), handshake);

}

}