Fixing markdown README.md. Removed most of the diagnostics

README.md

 Una de las ventajas de utilizar programas de computadoras es que podemos realizar tareas repetitivas fácilmente. Los ciclos como `for`, `while`, y `do-while` son estructuras de control que nos permiten repetir un conjunto de instrucciones. A estas estructuras también se les llama *estructuras de repetición*.  En la experiencia de laboratorio de hoy completarás una aplicación de esteganografía para practicar el uso de ciclos anidados en la manipulación de arreglos bi-dimensionales.
 
 
-##Objetivos:
+## Objetivos:
 
 1. Aplicar ciclos anidados y estructuras de control para manipular arreglos bi-dimensionales y  extraer mensajes escondidos en imágenes.
 
 3. Utilizar la representación binaria de caracteres.
 
 
-##Pre-Lab:
+## Pre-Lab:
 
 Antes de llegar al laboratorio debes haber:
 
 
 ![figure1.png](images/figure1.png)
 
-**Figura 1.** Distribución de bits para las tonalidades de rojo, verde y azul dentro de la representación RGB.  Cada tonalidad puede tener valores entre 0x00 (los ocho bits en 0) y 0xFF (los 8 bits en 1). 
+**Figura 1.** Distribución de bits para las tonalidades de rojo, verde y azul dentro de la representación RGB.  Cada tonalidad puede tener valores entre 0x00 (los ocho bits en 0) y 0xFF (los 8 bits en 1).
 
 ---
 
 Podemos hacer lo siguiente para empotrar cada trío de bits  `b2, b1, b0`:
 
 ```
-Datos de entrada: p: un píxel 
+Datos de entrada: p: un píxel
     b2,b1,b0: el trío de bits
 Dato de salida: modifiedPixel: el píxel con el trío empotrado
 ========
-1. r = componente rojo de p 
+1. r = componente rojo de p
 2. g = componente verde de p
 3. b = componente azul de p
 4. "limpiar" o apagar" los bits menos significativos de r,g,b
 | `0x00 00 00` | `111`  | `0x01 01 01`  |
 
 
-Pregunta: 
+Pregunta:
 ¿Qué mensaje está escondido (usando la técnica del bit menos significativo) en una imagen cuyos primeros 8 píxeles son:
 
 
 ```
 0x545554 0x666667 0x444544 0x333232
-0xff0000 0x0100ff 0x00ff00 0x10aaba 
+0xff0000 0x0100ff 0x00ff00 0x10aaba
 ```
 
 Explica tu respuesta.
 
 ---
 
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-01.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-02.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-03.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-04.html"
 
 !INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-05.html"
 
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-06.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/es/diag-steganography-07.html"
-
 ---
 
 ---
 
 
-##Sesión de laboratorio:
+## Sesión de laboratorio:
 
 En la experiencia de laboratorio de hoy completarás una aplicación de esteganografía para extraer mensajes ocultos en imágenes.
 
-###Ejercicio 1: Extraer el mensaje binario
+### Ejercicio 1: Extraer el mensaje binario
 
-####Instrucciones
+#### Instrucciones
 
 
 1. Carga a QtCreator el proyecto `Steganography` haciendo doble "click" en el archivo `Steganography.pro` en el directorio `Documents/eip/Repetitions-Steganography` de tu computadora. También puedes ir a `http://bitbucket.org/eip-uprrp/repetitions-steganography` para descargar la carpeta `Repetitions-Steganography` a tu computadora.
- 
 
     El proyecto contiene el esqueleto de una aplicación para recuperar mensajes empotrados en imágenes. Los mensajes que estarás recobrando se empotraron utilizando la técnica del bit menos significativo. El final de cada mensaje se codificó utilizando el caracter ASCII con código binario `00000000`.
 
     Por ejemplo, si los primeros píxeles de la imagen fuesen los siguientes,
 
     ````
-    0x98 99 98 0x00 00 01 0x00 00 00 0x01 01 00 
+    0x98 99 98 0x00 00 01 0x00 00 00 0x01 01 00
     0x01 01 01 0x01 00 01 0x01 00 00 0x01 01 01
     0xf0 ea 00 0x44 00 f0 0x00 aa 22 . . . .,
     ````
 Para poder implementar el algoritmo de extracción del mensaje, debes entender cómo fue empotrado el mensaje. Si es necesario, repasa la sección “Empotrando un mensaje en una imagen”.
 
 
-###Ejercicio 2: Interpretar el mensaje
+### Ejercicio 2: Interpretar el mensaje
 
-####Instrucciones
+#### Instrucciones
 
 
 1. Completa la función `binaryStringToMessage` que recibe el "string" de `0`'s y `1`'s extraido de la imagen para que devuelva el mensaje oculto. Puedes aprovechar la función `binStringToChar` para convertir "substrings" de 8 `0`'s y `1`'s en el caracter que le corresponde.
 
 ---
 
-##Entrega
+## Entrega
 
 Utiliza "Entrega" en Moodle para entregar el archivo `steganography.cpp` que contiene las funciones `ExtractMessage` y `binaryStringToMessage`. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
 
 
 One of the advantages of using computer programs is that we can easily implement repetitive tasks. Structures such as the `for`, `while`, and `do-while` allow us to repeat a block of instructions as many times as needed. These structures are also referred to as *repetition structures*. In today's laboratory experience you will complete a steganography application to practice the use of nested loops and the manipulation of bidimensional arrays.
 
-##Objectives:
+## Objectives:
 
 1. Apply nested loops and decision structures to manipulate bidimensional arrays and extract messages hidden in images.
 
 3. Use the binary representation of characters.
 
 
-##Pre-Lab:
+## Pre-Lab:
 
 Before coming to the laboratory session you should have:
 
 ---
 
 
-##Steganography
+## Steganography
 
-Steganography is the science of camouflaging the presence of hidden messages in legitimate carriers (seemingly harmless files). This science has been used by cybercriminals to inflict damage to computer systems and by (old style) terrorists to encode hidden messages transmitted through the internet. There is claim that Al-Qaeda may have used steganography to encode messages into images, and then transport them via e-mail, and possibly via USENET, to prepare and execute the September 11,  2001 terrorist attack. 
+Steganography is the science of camouflaging the presence of hidden messages in legitimate carriers (seemingly harmless files). This science has been used by cybercriminals to inflict damage to computer systems and by (old style) terrorists to encode hidden messages transmitted through the internet. There is claim that Al-Qaeda may have used steganography to encode messages into images, and then transport them via e-mail, and possibly via USENET, to prepare and execute the September 11,  2001 terrorist attack.
 
 Steganography has some lawful uses too [1]:
 
-* A medical imaging laboratory can embed a patient's information into the images, thus preventing against fraud and/or patient misdiagnosis. 
+* A medical imaging laboratory can embed a patient's information into the images, thus preventing against fraud and/or patient misdiagnosis.
 * We can use hidden information to identify the legitimate owner of a document or image. If the document is leaked, or distributed to unauthorized parties, one can trace it back to the rightful owner and perhaps discover which party broke the license distribution agreement.
 
 In this laboratory experience you will implement a simple algorithm to extract hidden messages from steganography images.
 
 ---
 
-##Image Editing
+## Image Editing
 
 In this laboratory experience, you will recover secret messages that have been hidden in an image. To be able to carry out your task, you should understand some concepts related to images, be familiar with the methods of the `QImage` class in `Qt`,  and with functions to work with data of the `QRgb` type.
 
-###Pixels
+### Pixels
 
 The smallest element in an image is called a *pixel*. This unit consists of a single color. Since each color is a combination of tones for the primary red, green and blue colors, it is coded as an unsigned integer whose bytes represent the tones of red, green and blue of the pixel (Figure 1). This combination is called the color's *RGB* which is an acronym for "Red-Green-Blue". For example, a pure red pixel has an RGB representation of `0x00ff0000`, while a white pixel has an RGB representation of `0x00FFFFFF` (since the color white is a combination of tones of red, green and blue in all of their intensity).
 
 
 `Qt` uses the `QRgb` type to represent `RGB` values. Using the functions that are described below we can perform important operations to analyze images, such as obtaining the RGB of each pixel in an image, and to obtain the red, green and blue components of the `QRgb` value of the pixel.
 
-###Library
+### Library
 
 In today's laboratory experience you will use the `QImage` class. This class allows you to access the data in the pixels of an image to manipulate it. The documentation for the `QImage` class can be found in http://doc.qt.io/qt-4.8/qimage.html.
 
 
 The objects of the `QImage` class have the following methods that will be useful for today's laboratory experience:
 
-* `width()`      // returns the positive integer value for the image's width 
-* `height()`      // returns the positive integer value for the image's height 
+* `width()`      // returns the positive integer value for the image's width
+* `height()`      // returns the positive integer value for the image's height
 * `pixel(i, j)`       // returns the `QRgb` for the pixel in position `(i,j)`
 
 
 
 
 
-####Examples:
+#### Examples:
 
 1. If the following `4 x 4` image of pixels represents the object `origImage`,
 
 ---
 
 
-###Embedding a message into an image
+### Embedding a message into an image
 
 One of the simplest methods of *hidding* a message in an image is by encoding the message into the least significant bits of the image pixel's colors. This method effectively hides the message in the image because changing the least significant bit of a 8-bit color is barely noticeable by the human observer.  
 
 
 ![main3.png](images/main3.png)
 
-Assume that each square is a pixel of the image. 
+Assume that each square is a pixel of the image.
 
 The first step would be to obtain the ASCII representation of the message. The bits of the ASCII representation are the bits we will encode into the colors of the pixels. The ASCII representation of `Dog` is:
 
 b2,b1,b0: the trio of bits
 Output: modifiedPixel: the pixel with the embedded trio
 ========
-1. r = red component of p 
+1. r = red component of p
 2. g = green component of p
 3. b = blue component of p
 4. clear the least significant bits of r,g,b
 | `0x00 00 00` | `111`  | `0x01 01 01`  |
 
 
-Question: 
+Question:
 What message is hidden (using the least significant bit technique) in an image whose first 8 pixels are:
 
 ```
 0x545554 0x666667 0x444544 0x333232
-0xff0000 0x0100ff 0x00ff00 0x10aaba 
+0xff0000 0x0100ff 0x00ff00 0x10aaba
 ```
 
 Explain your answer.
 
 ---
 
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-01.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-02.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-03.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-04.html"
-
 !INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-05.html"
 
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-06.html"
-
-!INCLUDE "../../eip-diagnostic/steganography/en/diag-steganography-07.html"
 
 ---
 
 
 In today's laboratory experience you will complete a steganography application to extract hidden messages from images.
 
-###Exercise 1: Extract the binary message
+### Exercise 1: Extract the binary message
 
-####Instructions
+#### Instructions
 
 1. Load the Qt project called `Steganography` by double-clicking on the `Steganography.pro` file in the `Documents/eip/Repetitions-Steganography` folder of your computer. You can also go to `http://bitbucket.org/eip-uprrp/repetitions-steganography` to download the `Repetitions-Steganography` folder to your computer.
 
-The project contains the skeleton for an application to recover embedded messages from images. The messages that you will be recovering have been  embedded using the least significant bit technique. The end of each message was encoded by using the ASCII character with binary code `00000000`. 
+   The project contains the skeleton for an application to recover embedded messages from images. The messages that you will be recovering have been  embedded using the least significant bit technique. The end of each message was encoded by using the ASCII character with binary code `00000000`.
 
 2. Compile and run the program. You should obtain an interface that looks similar to:
 
-![img1.png](images/img1.png)
+    ![img1.png](images/img1.png)
 
 3. The button `Load Image` has already been programmed to allow the user to load an image and display it. Your task is to program the functionality of the button `Retrieve Message` to analyze the image and extract the hidden message. The hidden message should be displayed in the `Write a message` window.
 
 4. You will be working with the `steganography.cpp` file. Complete the `ExtractMessage` function that receives a steganography image so it extracts the digits of the binary message encoded in the image and stores them in a string. The function should invoke another function `binaryStringToMessage` that converts the string from `0`'s and `1`'s in the message's characters and returns the hidden message.
 
 
-For example, if the first few pixels the image were these:
+    For example, if the first few pixels the image were these:
 
-````
-0x98 99 98 0x00 00 01 0x00 00 00 0x01 01 00 
-0x01 01 01 0x01 00 01 0x01 00 00 0x01 01 01
-0xf0 ea 00 0x44 00 f0 0x00 aa 22 . . . .
-````
+  ````
+  0x98 99 98 0x00 00 01 0x00 00 00 0x01 01 00
+  0x01 01 01 0x01 00 01 0x01 00 00 0x01 01 01
+  0xf0 ea 00 0x44 00 f0 0x00 aa 22 . . . .
+  ````
 
-your `ExtractMessage` function would extract the least significant bits of each colors component and construct the `string`: `"010001000110111101100111000000000.."`.
+  your `ExtractMessage` function would extract the least significant bits of each colors component and construct the `string`: `"010001000110111101100111000000000.."`.
 
-Notice that your algorithm should have some mechanism for detecting if the last 8 character block were all `0`. When this happens, the algorithm should stop reading the pixels.
+  Notice that your algorithm should have some mechanism for detecting if the last 8 character block were all `0`. When this happens, the algorithm should stop reading the pixels.
 
-The string of binary digits should then be sent to another function `binaryStringToMessage` (see Exercise 2) that interprets the `0`'s and `1`'s as the bits of ASCII characters. In the example, the string `”010001000110111101100111000000000”` would be decoded to "Dog"
-(because `01000100` corresponds to 'D', `01101111` is 'o',  `01100111` is 'g', and a `00000000` symbolizes the end of the string.)
+  The string of binary digits should then be sent to another function `binaryStringToMessage` (see Exercise 2) that interprets the `0`'s and `1`'s as the bits of ASCII characters. In the example, the string `”010001000110111101100111000000000”` would be decoded to "Dog"
+  (because `01000100` corresponds to 'D', `01101111` is 'o',  `01100111` is 'g', and a `00000000` symbolizes the end of the string.)
 
-To implement the algorithm for extracting the message, you should understand how the message was encoded. If necessary, review the "Embedding a message into an image" section.
+  To implement the algorithm for extracting the message, you should understand how the message was encoded. If necessary, review the "Embedding a message into an image" section.
 
 
-###Exercise 2: Interpreting the message
+### Exercise 2: Interpreting the message
 
 
-####Instructions
+#### Instructions
 
 1. Complete the `binaryStringToMessage` function that receives the string of `0`'s and `1`'s extracted from the image so it returns the hidden message. You can use the `binStringToChar` function to convert substrings of 8 `0`'s and `1`'s in its corresponding character.
 
     * `pug.png`, contains the message "Hello World !"
     * `uprTorre.png`, contains the message "CCOM3033 - Steganography Lab Rules!!!"
 
-3. Once you validate your program using the test images, use the program to analyze the following images. 
+3. Once you validate your program using the test images, use the program to analyze the following images.
 
     * `gallito.png`
     * `puppy.png`
 
 ---
 
-##Deliverables
+## Deliverables
 
 Use "Deliverables" in Moodle to upload the `steganography.cpp` file that contains the `ExtractMessage` and `binaryStringToMessage` functions. Remember to use good programming techniques, include the names of the programmers involved, and to document your program.
 
 ---
 
 
-##References 
+## References
 
-[1] Rocha, Anderson, and Siome Goldenstein. "Steganography and steganalysis in digital multimedia: Hype or hallelujah?." Revista de Informática Teórica e Aplicada 15.1 (2008): 83-110.
+[1] Rocha, Anderson, and Siome Goldenstein. "Steganography and steganalysis in digital multimedia: Hype or hallelujah?." Revista de Informática Teórica e Aplicada 15.1 (2008): 83-110.