Sources du TP n°2

Author: JuvignyEnsta

Makefile

@@ -0,0 +1,16 @@
+# Makefile TD n°2
+CXX = g++ -std=c++14
+CXXFLAGS = -O2 -Wall -pedantic -march=native
+#CXXFLAGS = -g -Wall -pedantic -march=native
+LIBS = -lm
+
+all:    Mandelbrot.exe matvec.exe
+
+Mandelbrot.exe: Mandelbrot.cpp lodepng/lodepng.cpp
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
+
+matvec.exe:	matvec.cpp
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
+
+cleanall:
+	@rm -rf *.o *~ *.exe

Mandelbrot.cpp

@@ -0,0 +1,122 @@
+# include <iostream>
+# include <cstdlib>
+# include <string>
+# include <chrono>
+# include <cmath>
+# include "lodepng/lodepng.h"
+
+/** Une structure complexe est définie pour la bonne raison que la classe
+ * complex proposée par g++ est très lente ! Le calcul est bien plus rapide
+ * avec la petite structure donnée ci--dessous
+ **/
+struct Complex
+{
+    Complex() : real(0.), imag(0.)
+    {}
+    Complex(double r, double i) : real(r), imag(i)
+    {}
+    Complex operator + ( const Complex& z )
+    {
+        return Complex(real + z.real, imag + z.imag );
+    }
+    Complex operator * ( const Complex& z )
+    {
+        return Complex(real*z.real-imag*z.imag, real*z.imag+imag*z.real);
+    }
+    double sqNorm() { return real*real + imag*imag; }
+    double real,imag;
+};
+
+/** Pour un c complexe donné, calcul le nombre d'itérations de mandelbrot
+ * nécessaires pour détecter une éventuelle divergence. Si la suite
+ * converge, la fonction retourne la valeur maxIter
+ **/
+int iterMandelbrot( int maxIter, const Complex& c)
+{
+    Complex z{0.,0.};
+    // On vérifie dans un premier temps si le complexe
+    // n'appartient pas à une zone de convergence connue :
+    // Appartenance aux disques  C0{(0,0),1/4} et C1{(-1,0),1/4}
+    if ( c.real*c.real+c.imag*c.imag < 0.0625 )
+        return maxIter;
+    if ( (c.real+1)*(c.real+1)+c.imag*c.imag < 0.0625 )
+        return maxIter;
+    // Appartenance à la cardioïde {(1/4,0),1/2(1-cos(theta))}    
+    if ((c.real > -0.75) && (c.real < 0.5) ) {
+        Complex ct{c.real-0.25,c.imag};
+        double ctnrm2 = sqrt(ct.sqNorm());
+        if (ctnrm2 < 0.5*(1-ct.real/ctnrm2)) return maxIter;
+    }
+    int niter = 0;
+    while ((z.sqNorm() < 4.) && (niter < maxIter))
+    {
+        z = z*z + c;
+        ++niter;
+    }
+    return niter;
+}
+
+/**
+ * On parcourt chaque pixel de l'espace image et on fait correspondre par
+ * translation et homothétie une valeur complexe c qui servira pour
+ * itérer sur la suite de Mandelbrot. Le nombre d'itérations renvoyé
+ * servira pour construire l'image finale.
+ **/
+std::vector<int> computeMandelbrotSet( int W, int H, int maxIter )
+{
+    std::chrono::time_point<std::chrono::system_clock> start, end;
+    // Calcul le facteur d'échelle pour rester dans le disque de rayon 2
+    // centré en (0,0)
+    double scaleX = 3./(W-1);
+    double scaleY = 2.25/(H-1);
+    //
+    std::vector<int> pixels(W*H);
+    start = std::chrono::system_clock::now();
+    // On parcourt les pixels de l'espace image :
+    for ( int i = 0; i < H; ++i )
+        for ( int j = 0; j < W; ++j ) {
+            Complex c{-2.+j*scaleX,-1.125+i*scaleY};
+            pixels[i*W+j] = iterMandelbrot( maxIter, c );
+        }
+    end = std::chrono::system_clock::now();
+    std::chrono::duration<double> elapsed_seconds = end-start;
+    std::cout << "Temps calcul ensemble mandelbrot : " << elapsed_seconds.count() 
+              << std::endl;
+    return pixels;
+}
+
+/** Construit et sauvegarde l'image finale **/
+void savePicture( const std::string& fileName, int W, int H, const std::vector<int>& nbIters, int maxIter )
+{
+    std::vector<unsigned char> image(4*W*H);
+    double scaleCol = 1./maxIter;//16777216
+    for ( int i = 0; i < H; ++i ) {
+        for ( int j = 0; j < W; ++j ) {
+            double iter = scaleCol*nbIters[i*W+j];
+            unsigned r = unsigned (iter*256.) & 0xFF;
+            unsigned b = (unsigned (iter*65536) & 0xFF);
+            unsigned g = (unsigned( iter*16777216) & 0xFF);
+            image[4*(i*W+j)+0] = (unsigned char)(256-r);
+            image[4*(i*W+j)+1] = (unsigned char)(256-g);
+            image[4*(i*W+j)+2] = (unsigned char)(256-b);
+            image[4*(i*W+j)+3] = 255;
+        }
+    }
+    unsigned error = lodepng::encode(fileName.c_str(), image, W, H);
+
+    //if there's an error, display it
+    if(error) std::cout << "encoder error " << error << ": "<< lodepng_error_text(error) << std::endl;
+}
+
+int main()
+{
+    const int W = 800;
+    const int H = 600;
+    // Normalement, pour un bon rendu, il faudrait le nombre d'itérations
+    // ci--dessous :
+    //const int maxIter = 16777216;
+    const int maxIter = 8*65536;
+    auto iters = computeMandelbrotSet( W, H, maxIter );
+    savePicture("mandelbrot.png", W, H, iters, maxIter);
+    return EXIT_SUCCESS;
+}

README.md

@@ -0,0 +1 @@
+# TP n°2 : MPI et messages collectifs

lodepng/README.md

@@ -0,0 +1,12 @@
+LodePNG
+-------
+
+PNG encoder and decoder in C and C++.
+
+Home page: http://lodev.org/lodepng/
+
+Only two files are needed to allow your program to read and write PNG files: lodepng.cpp and lodepng.h.
+
+For C, you can rename lodepng.cpp to lodepng.c and it'll work. C++ only adds extra API.
+
+The other files in the project are just examples, unit tests, etc...

lodepng/examples/example_4bit_palette.cpp

@@ -0,0 +1,106 @@
+/*
+LodePNG Examples
+
+Copyright (c) 2005-2012 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+//g++ lodepng.cpp example_4bit_palette.cpp -ansi -pedantic -Wall -Wextra -O3
+
+
+
+/*
+LodePNG 4-bit palette example.
+This example encodes a 511x511 PNG with a 4-bit palette.
+Both image and palette contain sine waves, resulting in a sort of plasma.
+The 511 (rather than power of two 512) size is of course chosen on purpose to
+confirm that scanlines not filling up an entire byte size are working.
+
+NOTE: a PNG image with a translucent palette is perfectly valid. However there
+exist some programs that cannot correctly read those, including, surprisingly,
+Gimp 2.8 image editor (until you set mode to RGB).
+*/
+
+#include <cmath>
+#include <iostream>
+
+#include "lodepng.h"
+
+int main(int argc, char *argv[])
+{
+  //check if user gave a filename
+  if(argc < 2)
+  {
+    std::cout << "please provide a filename to save to" << std::endl;
+    return 0;
+  }
+
+  //create encoder and set settings and info (optional)
+  lodepng::State state;
+
+  //generate palette
+  for(int i = 0; i < 16; i++)
+  {
+    unsigned char r = 127 * (1 + std::sin(5 * i * 6.28318531 / 16));
+    unsigned char g = 127 * (1 + std::sin(2 * i * 6.28318531 / 16));
+    unsigned char b = 127 * (1 + std::sin(3 * i * 6.28318531 / 16));
+    unsigned char a = 63 * (1 + std::sin(8 * i * 6.28318531 / 16)) + 128; /*alpha channel of the palette (tRNS chunk)*/
+
+    //palette must be added both to input and output color mode, because in this
+    //sample both the raw image and the expected PNG image use that palette.
+    lodepng_palette_add(&state.info_png.color, r, g, b, a);
+    lodepng_palette_add(&state.info_raw, r, g, b, a);
+  }
+
+  //both the raw image and the encoded image must get colorType 3 (palette)
+  state.info_png.color.colortype = LCT_PALETTE; //if you comment this line, and create the above palette in info_raw instead, then you get the same image in a RGBA PNG.
+  state.info_png.color.bitdepth = 4;
+  state.info_raw.colortype = LCT_PALETTE;
+  state.info_raw.bitdepth = 4;
+  state.encoder.auto_convert = 0; //we specify ourselves exactly what output PNG color mode we want
+
+  //generate some image
+  const unsigned w = 511;
+  const unsigned h = 511;
+  std::vector<unsigned char> image;
+  image.resize((w * h * 4 + 7) / 8, 0);
+  for(unsigned y = 0; y < h; y++)
+  for(unsigned x = 0; x < w; x++)
+  {
+    size_t byte_index = (y * w + x) / 2;
+    bool byte_half = (y * w + x) % 2 == 1;
+
+    int color = (int)(4 * ((1 + std::sin(2.0 * 6.28318531 * x / (double)w))
+                         + (1 + std::sin(2.0 * 6.28318531 * y / (double)h))) );
+
+    image[byte_index] |= (unsigned char)(color << (byte_half ? 0 : 4));
+  }
+
+  //encode and save
+  std::vector<unsigned char> buffer;
+  unsigned error = lodepng::encode(buffer, image.empty() ? 0 : &image[0], w, h, state);
+  if(error)
+  {
+    std::cout << "encoder error " << error << ": "<< lodepng_error_text(error) << std::endl;
+    return 0;
+  }
+  lodepng::save_file(buffer, argv[1]);
+}

lodepng/examples/example_bmp2png.cpp

@@ -0,0 +1,134 @@
+/*
+LodePNG Examples
+
+Copyright (c) 2005-2010 Lode Vandevenne
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/
+
+/*
+Load a BMP image and convert it to a PNG image. This example also shows how
+to use other data with the same memory structure as BMP, such as the image
+format native to win32, GDI (HBITMAP, BITMAPINFO, ...) often encountered if
+you're programming for Windows in Visual Studio.
+
+This example only supports uncompressed 24-bit RGB or 32-bit RGBA bitmaps.
+For other types of BMP's, use a full fledged BMP decoder, or convert the
+bitmap to 24-bit or 32-bit format.
+
+NOTE: it overwrites the output file without warning if it exists!
+*/
+
+//g++ lodepng.cpp example_bmp2png.cpp -ansi -pedantic -Wall -Wextra -O3
+
+#include "lodepng.h"
+
+#include <iostream>
+
+//returns 0 if all went ok, non-0 if error
+//output image is always given in RGBA (with alpha channel), even if it's a BMP without alpha channel
+unsigned decodeBMP(std::vector<unsigned char>& image, unsigned& w, unsigned& h, const std::vector<unsigned char>& bmp)
+{
+  static const unsigned MINHEADER = 54; //minimum BMP header size
+  
+  if(bmp.size() < MINHEADER) return -1;
+  if(bmp[0] != 'B' || bmp[1] != 'M') return 1; //It's not a BMP file if it doesn't start with marker 'BM'
+  unsigned pixeloffset = bmp[10] + 256 * bmp[11]; //where the pixel data starts
+  //read width and height from BMP header
+  w = bmp[18] + bmp[19] * 256;
+  h = bmp[22] + bmp[23] * 256;
+  //read number of channels from BMP header
+  if(bmp[28] != 24 && bmp[28] != 32) return 2; //only 24-bit and 32-bit BMPs are supported.
+  unsigned numChannels = bmp[28] / 8;
+
+  //The amount of scanline bytes is width of image times channels, with extra bytes added if needed
+  //to make it a multiple of 4 bytes.
+  unsigned scanlineBytes = w * numChannels;
+  if(scanlineBytes % 4 != 0) scanlineBytes = (scanlineBytes / 4) * 4 + 4;
+
+  unsigned dataSize = scanlineBytes * h;
+  if(bmp.size() < dataSize + pixeloffset) return 3; //BMP file too small to contain all pixels
+
+  image.resize(w * h * 4);
+
+  /*
+  There are 3 differences between BMP and the raw image buffer for LodePNG:
+  -it's upside down
+  -it's in BGR instead of RGB format (or BRGA instead of RGBA)
+  -each scanline has padding bytes to make it a multiple of 4 if needed
+  The 2D for loop below does all these 3 conversions at once.
+  */
+  for(unsigned y = 0; y < h; y++)
+  for(unsigned x = 0; x < w; x++)
+  {
+    //pixel start byte position in the BMP
+    unsigned bmpos = pixeloffset + (h - y - 1) * scanlineBytes + numChannels * x;
+    //pixel start byte position in the new raw image
+    unsigned newpos = 4 * y * w + 4 * x;
+    if(numChannels == 3)
+    {
+      image[newpos + 0] = bmp[bmpos + 2]; //R
+      image[newpos + 1] = bmp[bmpos + 1]; //G
+      image[newpos + 2] = bmp[bmpos + 0]; //B
+      image[newpos + 3] = 255;            //A
+    }
+    else
+    {
+      image[newpos + 0] = bmp[bmpos + 3]; //R
+      image[newpos + 1] = bmp[bmpos + 2]; //G
+      image[newpos + 2] = bmp[bmpos + 1]; //B
+      image[newpos + 3] = bmp[bmpos + 0]; //A
+    }
+  }
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  if(argc < 3)
+  {
+    std::cout << "Please provice input PNG and output BMP file names" << std::endl;
+    return 0;
+  }
+
+  std::vector<unsigned char> bmp;
+  lodepng::load_file(bmp, argv[1]);
+  std::vector<unsigned char> image;
+  unsigned w, h;
+  unsigned error = decodeBMP(image, w, h, bmp);
+
+  if(error)
+  {
+    std::cout << "BMP decoding error " << error << std::endl;
+    return 0;
+  }
+  
+  std::vector<unsigned char> png;
+  error = lodepng::encode(png, image, w, h);
+
+  if(error)
+  {
+    std::cout << "PNG encoding error " << error << ": " << lodepng_error_text(error) << std::endl;
+    return 0;
+  }
+  
+  lodepng::save_file(png, argv[2]);
+  
+}