Correcciones gramaticales

Filter.cpp

 
 
 // Given an image and two rectangles defined by the x,y locations of their
-// upperleft pixels and their height, width, swaps the pixels in those rectangles.
+// upperleft pixels and their height and width, the function swaps the pixels in those rectangles.
 // For example, for an image I with height and width of 100. The following invocation
 // swaps the top and bottom halves of the image:
 // cropSwap(I, 0, 0, 0, 50, 100, 50)

ImageScrambler.cpp

     // KEYBOARD SHORTCUTS
     // ATAJOS DEL KEYBOARD
 
-    // Loads a image with cmd + o
+    // Loads an image with cmd + o
     // Carga una imagen con cmd + o
     new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_O), this, SLOT(on_btnLoadNewImage_clicked()));
-    // Saves a image with cmd + s
+    // Saves an image with cmd + s
     // Guarda una imagen con cmd + s
     new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_S), this, SLOT(on_btnSave_clicked()));
     // Closes window with cmd + w
     // Cierra la ventana con cmd + w
     new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_W), this, SLOT(close()));
-    // Scramble a image with cmd + e
+    // Scrambles an image with cmd + e
     // Revuelve una imagen con cmd + e
     new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_E), this, SLOT(on_btnScrambleImage_clicked()));
-    // Restore the image with cmd + d
+    // Restores the image with cmd + d
     // Restaura la imagen con cmd + d
     new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_D), this, SLOT(on_btnDescrambleImage_clicked()));
     ui->btnDescrambleImage->setEnabled(false);
 
 /// \fn void ImageScrambler::on_btnLoadNewImage_clicked()
 /// \~English
-/// \brief Function display a file browsing window to load an image into the GUI
+/// \brief Function that displays a browsing window file to load an image into the GUI
 /// \~Spanish
 /// \brief Funcion que despliega una ventana de busqueda de archivos para cargar
 /// una imagen en el GUI.
 void ImageScrambler::on_btnScrambleImage_clicked(){
 
     //Call Scramble to scramble the image
+    //Llamar Scramble para revolver la imagen
     scrambleDepth = ui->scrambleDepth->value() ;
     scrambledImage = ScrambleFilter(originalImage, scrambleDepth, 0, 0, originalImage.width(),originalImage.height());
     ui->lblScrambleImage->setPixmap(QPixmap::fromImage(scrambledImage));
 
 /// \fn void ImageScrambler::on_btnDescrambleImage_clicked()
 /// \~English
-/// \brief Function that restore the scrambled image to the original image.
+/// \brief Function that restores the scrambled image to the original image.
 /// \~Spanish
 /// \brief Funcion que restaura la imagen revuelta a la imagen original.
 void ImageScrambler::on_btnDescrambleImage_clicked(){

ImageScrambler.h

 
     /// \fn void ImageScrambler::cropSwap(QImage &img, int x0, int y0, int x1, int y1, int width, int height )
     /// \~English
-    /// \brief Funtion that crop two squares of equal size of an image or sub image and swaps them.
-    /// The funtion receives two coords (x0, y0) and (x1, y1)  and a width and a height. Then swaps pixel
+    /// \brief Function that crops two squares of equal size of an image or sub image and swaps them.
+    /// The function receives two coords (x0, y0) and (x1, y1)  and a width and a height. Then swaps pixel
     /// by pixel the square formed from the top left coordinate (x0, y0) to the bottom right coordinate (x0+width, y0+height)
     /// with the square formed from the top left coordinate (x1, y1) to the bottom right (x1+width, y1+height).
     /// \param image Reference to the image to swap the squares.
 
     /// \fn QImage ImageScrambler::ScrambleFilter(QImage image, int N, int sw, int sh, int width, int height)
     /// \~English
-    /// \brief Funtion that recursively scrambles an images by dividing the image in squares (sub images)
+    /// \brief Function that recursively scrambles an image by dividing the image in squares (sub images)
     /// and then swapping them.  The first step the program does is divide the image in two or four squares
     /// and swap the squares, the resulting image is divided in four squares and then the same steps are applied
     /// recursively to each of the four squares.
     /// \return the scrambled image
     /// \~Spanish
     /// \brief Funcion que recursivamente revuelve una imagen dividiendola en cuadrados (sub imagenes)
-    /// y luego intercambiandolas.  El primer paso que el programa hace es dividir la imagen en two o cuatro cuadrados
-    /// e intercambia los cuadrados, el resultado de la imagen se divide en cuatros cuadros y cada uno de los cuadros
+    /// y luego intercambiandolas.  El primer paso que el programa hace es dividir la imagen en dos o cuatro cuadrados
+    /// e intercambia los cuadrados. El resultado de la imagen se divide en cuatros cuadros y cada uno de los cuadros
     /// se le aplican los mismos pasos recursivamente.
-    /// \param image The image a revolver
+    /// \param image La imagen a revolver
     /// \param level La profundidad de la recursion. La imagen se revolvera en 4^N cuadrados.
     /// \param sx La coordenada arriba izquierda x inicial de la imagen o sub imagen a dividir.
     /// \param sy La coordenada arriba izquierda y inicial de la imagen o sub imagen a dividir.
 
     /// \fn void ImageScrambler::on_btnLoadNewImage_clicked()
     /// \~English
-    /// \brief Function display a file browsing window to load an image into the GUI
+    /// \brief Function that displays a browsing window file to load an image into the GUI
     /// \~Spanish
     /// \brief Funcion que despliega una ventana de busqueda de archivos para cargar
     /// una imagen en el GUI.
 
     /// \fn void ImageScrambler::on_btnDescrambleImage_clicked()
     /// \~English
-    /// \brief Function that restore the scrambled image to the original image.
+    /// \brief Function that restores the scrambled image to the original image.
     /// \~Spanish
     /// \brief Funcion que restaura la imagen revuelta a la imagen original.
     void on_btnDescrambleImage_clicked();
 private:
     Ui::ImageScrambler *ui;
     QImage originalImage;  //This will hold the original image.
+			   //Esto aguantará la imagen original.
     QImage scrambledImage; //This will hold the encrypted image.
+			   //Esto aguantará la imagen cifrado .
     int scrambleDepth ;
 };
 

README-en.md

 ![main2.png](images/main2-small.png)
 ![main3.png](images/main3-small.png)
 
-[Verano 2016 - Ive - Coralys]
 
 One commonly used programming technique is *recursion*. With this technique, problems are solved by solving similar problems, but for smaller cases. We can build sets of objects or tasks using *recursive rules* and *initial values*. *Recursive functions* are functions that are self-invoking, using smaller sets or elements each time, until reaching a point where the initial value is used instead of self-invoking. In this laboratory experience, you will practice the definition and implementation of recursive functions to scramble an image and make it incomprehensible.
 
 
        ---
 
-     The button that says `Scramble Image` is programmed so it invokes a function called `ScramblerFilter`.
+     The button that says `Scramble Image` is programmed so it invokes a function called `ScrambleFilter`.
 
-3. Complete the function `ScrambleFIlter` contained in the `Filter.cpp` file so it implements the recursive algorithm to scramble images. The function has the following format:
+3. Complete the function `ScrambleFilter` contained in the `Filter.cpp` file so it implements the recursive algorithm to scramble images. The function has the following format:
 
      `QImage ImageScrambler::ScrambleFilter(QImage image, int N, int sx, int sy, int width, int height);`
 

README-es.md

 
 Antes de llegar al laboratorio debes:
 
-1. Repasado los conceptos relacionados a funciones recursivas.
+1. Haber repasado los conceptos relacionados a funciones recursivas.
 
 2. Haber estudiado los conceptos e instrucciones para la sesión de laboratorio.