Archives pour la catégorie Programmation

SFML: texte et police

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment charger une police et afficher du texte.

/*!
 * \file    main.cpp
 * \brief   start SFML in full screen and display a text (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme
 * \version 1.0
 * \date    12/18/2016
 */

// SFML libraries
#include 
#include 

int main()
{
    // _____________________
    // ::: Create window :::

    // Create a window with the same pixel depth as the desktop
    sf::VideoMode desktopMode = sf::VideoMode::getDesktopMode();

    sf::RenderWindow window(sf::VideoMode(  desktopMode.width,
                                            desktopMode.height,
                                            desktopMode.bitsPerPixel),
                            "SFML part 10",
                            sf::Style::Fullscreen);


    // Enable vertical sync. (vsync)
    window.setVerticalSyncEnabled (true);

    // _________________
    // ::: Load font :::

    sf::Font font;
    if (!font.loadFromFile("../example_font.ttf"))
    {
        std::cerr << ".Error while loading font" << std::endl;
        return -1;
    }

    sf::Text text;
    text.setFont(font); // font est un sf::Font
    text.setString(L"www.lucidarme.me");
    text.setCharacterSize(60); // exprimée en pixels, pas en points !
    text.setColor(sf::Color::Black);
    text.setOrigin(text.getLocalBounds().width/2. , text.getLocalBounds().height/2.);

    std::cout << text.getLocalBounds().width << "\t" << text.getLocalBounds().height;
    // _________________
    // ::: Main loop :::

    sf::Clock timer;
    while (window.isOpen())
    {
        // Process events
        sf::Event event;
        while (window.pollEvent(event))
        {
            // Close the window if a key is pressed or if requested
            if (event.type == sf::Event::Closed) window.close();
            if (event.type == sf::Event::KeyPressed) window.close();
        }

        // Clear the window and apply grey background
        window.clear( sf::Color(127,127,127));
        text.setPosition(window.getSize().x/2. , window.getSize().y/2.);
        window.draw(text);
        // Update display and wait for vsync
        window.display();
    }
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_010

<- Retour au menu du tutoriel sur SFML

SFML: music et sons

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment jouer de la musique et des sons.

/*!
 * \file    main.cpp
 * \brief   Music and sound examples (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme
 * \version 1.0
 * \date    12/20/2016
 */

#include 
#include 


// Wait for ms milliseconds
void delay_ms(int ms)
{
    sf::Clock Timer;
    while (Timer.getElapsedTime().asMilliseconds()5;vol--)
    {
        music.setVolume(vol);
        delay_ms(50);
    }

    // Stop music
    std::cout << "Stop music" << std::endl;
    music.stop();
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_009

<- Retour au menu du tutoriel sur SFML

SFML: shader 'effet eau'

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment créer un effet eau sur un sprite grâce aux shaders.

/*!
 * \file    main.cpp
 * \brief   apply a water effect shader to a sprite (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme (from https://github.com/SFML/SFML/wiki/Source:-HeatHazeShader)
 * \version 1.0
 * \date    12/19/2016
 */

// SFML libraries
#include 
#include 
#include 


int main()
{
    // _____________________
    // ::: Create window :::

    // Create a window with the same pixel depth as the desktop
    sf::VideoMode desktopMode = sf::VideoMode::getDesktopMode();

    sf::RenderWindow window(sf::VideoMode(  desktopMode.width,
                                            desktopMode.height,
                                            desktopMode.bitsPerPixel),
                            "SFML part 8",
                            sf::Style::Fullscreen);

    // Enable vertical sync. (vsync)
    window.setVerticalSyncEnabled (true);



    // ____________________
    // ::: Load texture :::

    // Create texture from PNG file
    sf::Texture texture;
    if (!texture.loadFromFile("../sfml-icon-small.png"))
    {
        std::cerr << "Error while loading texture" << std::endl;
        return -1;
    }
    // Enable the smooth filter. The texture appears smoother so that pixels are less noticeable.
    texture.setSmooth(true);



    // _______________________________________
    // ::: Create sprite and apply texture :::

    // Create the sprite and apply the texture
    sf::Sprite sprite;
    sprite.setTexture(texture);
    sf::FloatRect spriteSize=sprite.getGlobalBounds();
    // Set origin in the middle of the sprite
    sprite.setOrigin(spriteSize.width/2.,spriteSize.height/2.);



    // _______________
    // ::: Shaders :::

    // Check if shaders are available
    if (!sf::Shader::isAvailable())
    {
        std::cerr << "Shader are not available" << std::endl;
        return -1;
    }

    // Load shaders
    sf::Shader shader;
    if (!shader.loadFromFile("../water.frag", sf::Shader::Fragment))
    {
        std::cerr << "Error while shaders" << std::endl;
        return -1;
    }



    // ___________________________
    // ::: Load distortion map :::

    sf::Texture distortionMap;

    if (!distortionMap.loadFromFile("../noiseWater.png"))
    {
        sf::err() << "Error while loading distortion map" << std::endl;
        return -1;
    }

    // It is important to set repeated to true to enable scrolling upwards
    distortionMap.setRepeated(true);
    // Setting smooth to true lets us use small maps even on larger images
    distortionMap.setSmooth(true);

    // Set texture to the shader
    shader.setParameter("currentTexture", sf::Shader::CurrentTexture);
    shader.setParameter("distortionMapTexture", distortionMap);

    // Shader parameters
    float level = .5f;


    // _________________
    // ::: Main loop :::

    sf::Clock timer;
    while (window.isOpen())
    {
        // Process events
        sf::Event event;
        while (window.pollEvent(event))
        {
            // Close the window if a key is pressed or if requested
            if (event.type == sf::Event::Closed) window.close();

            // If a key is pressed
            if (event.type == sf::Event::KeyPressed)
            {
                switch (event.key.code)
                {
                // If escape is pressed, close the application
                case  sf::Keyboard::Escape : window.close(); break;
                // Process the up, down, left and right keys to modify parameters
                case sf::Keyboard::Up :     level -= .005f;    break;
                case sf::Keyboard::Down:    level += .005f;    break;
                default : break;
                }
            }
        }

        if (level>0.8) level=0.8;
        if (level<0.2) level=0.2;

        // Set shader parameters
        shader.setParameter("time", timer.getElapsedTime().asSeconds());
        shader.setParameter("level",level);

        // Clear the window and apply grey background
        window.clear( sf::Color(127,127,127));

        // Draw the sprite and apply shader
        sprite.setPosition(window.getSize().x/2.,window.getSize().y/2.);
        sprite.setScale(2,2);
        window.draw(sprite,&shader);

        // Update display and wait for vsync
        window.display();
    }
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_008

<- Retour au menu du tutoriel sur SFML

SFML: shader 'effet chaleur'

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment utiliser un effet "chaleur" sur un sprite grâce aux shaders.

/*!
 * \file    main.cpp
 * \brief   apply a heat shader to a sprite (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme (from https://github.com/SFML/SFML/wiki/Source:-HeatHazeShader)
 * \version 1.0
 * \date    12/19/2016
 */

// SFML libraries
#include 
#include 
#include 


int main()
{
    // _____________________
    // ::: Create window :::

    // Create a window with the same pixel depth as the desktop
    sf::VideoMode desktopMode = sf::VideoMode::getDesktopMode();

    sf::RenderWindow window(sf::VideoMode(  desktopMode.width,
                                            desktopMode.height,
                                            desktopMode.bitsPerPixel),
                            "SFML part 7",
                            sf::Style::Fullscreen);

    // Enable vertical sync. (vsync)
    window.setVerticalSyncEnabled (true);



    // ____________________
    // ::: Load texture :::

    // Create texture from PNG file
    sf::Texture texture;
    if (!texture.loadFromFile("../sfml-icon-small.png"))
    {
        std::cerr << "Error while loading texture" << std::endl;
        return -1;
    }
    // Enable the smooth filter. The texture appears smoother so that pixels are less noticeable.
    texture.setSmooth(true);



    // _______________________________________
    // ::: Create sprite and apply texture :::

    // Create the sprite and apply the texture
    sf::Sprite sprite;
    sprite.setTexture(texture);
    sf::FloatRect spriteSize=sprite.getGlobalBounds();
    // Set origin in the middle of the sprite
    sprite.setOrigin(spriteSize.width/2.,spriteSize.height/2.);



    // _______________
    // ::: Shaders :::

    // Check if shaders are available
    if (!sf::Shader::isAvailable())
    {
        std::cerr << "Shader are not available" << std::endl;
        return -1;
    }

    // Load shaders
    sf::Shader shader;
    if (!shader.loadFromFile("../example_001.frag", sf::Shader::Fragment))
    {
        std::cerr << "Error while shaders" << std::endl;
        return -1;
    }



    // ___________________________
    // ::: Load distortion map :::

    sf::Texture distortionMap;

    if (!distortionMap.loadFromFile("../distortion_map.png"))
    {
        sf::err() << "Error while loading distortion map" << std::endl;
        return -1;
    }

    // It is important to set repeated to true to enable scrolling upwards
    distortionMap.setRepeated(true);
    // Setting smooth to true lets us use small maps even on larger images
    distortionMap.setSmooth(true);

    // Set texture to the shader
    shader.setParameter("currentTexture", sf::Shader::CurrentTexture);
    shader.setParameter("distortionMapTexture", distortionMap);

    // Shader parameters
    float distortionFactor = .05f;
    float riseFactor = .2f;


    // _________________
    // ::: Main loop :::

    sf::Clock timer;
    while (window.isOpen())
    {
        // Process events
        sf::Event event;
        while (window.pollEvent(event))
        {
            // Close the window if a key is pressed or if requested
            if (event.type == sf::Event::Closed) window.close();

            // If a key is pressed
            if (event.type == sf::Event::KeyPressed)
            {
                switch (event.key.code)
                {
                // If escape is pressed, close the application
                case  sf::Keyboard::Escape : window.close(); break;

                // Process the up, down, left and right keys to modify parameters
                case sf::Keyboard::Up :     distortionFactor *= 2.f;    break;
                case sf::Keyboard::Down:    distortionFactor /= 2.f;    break;
                case sf::Keyboard::Left:    riseFactor *= 2.f;          break;
                case sf::Keyboard::Right:   riseFactor /= 2.f;          break;
                default : break;
                }
            }
        }

        // Set shader parameters
        shader.setParameter("time", timer.getElapsedTime().asSeconds());
        shader.setParameter("distortionFactor", distortionFactor);
        shader.setParameter("riseFactor", riseFactor);


        // Clear the window and apply grey background
        window.clear( sf::Color(127,127,127));

        // Draw the sprite and apply shader
        sprite.setPosition(window.getSize().x/2.,window.getSize().y/2.);
        sprite.setScale(2,2);
        window.draw(sprite,&shader);

        // Update display and wait for vsync
        window.display();
    }
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_007

<- Retour au menu du tutoriel sur SFML

SFML: sprite et shaders

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment utiliser les shaders. Il s'agit de programme qui sont exécutes dans le GPU (Graphics Processing Unit). L’avantage est de libérer le processeur principal.

/*!
 * \file    main.cpp
 * \brief   apply a shaders to a sprite (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme
 * \version 1.0
 * \date    12/20/2016
 */

// SFML libraries
#include 
#include 
#include 


// Example 1 : distorsion
// Example 2 : breath
// Example 3 : shaked
// Example 4 : fade
// Example 5 : blur
//#define SHADER_FILENAME         "../example_001.frag"
//#define SHADER_FILENAME         "../example_002.frag"
//#define SHADER_FILENAME         "../example_003.frag"
//#define SHADER_FILENAME         "../example_004.frag"
#define SHADER_FILENAME         "../example_005.frag"

#define     WINDOW_WIDTH    256
#define     WINDOW_HEIGHT   256

int main()
{

    // _____________________
    // ::: Create window :::

    // Create a non resizable window
    sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "SFML Shader Example", sf::Style::Titlebar | sf::Style::Close);


    // Create a window size texture and a sprite for the shader
    sf::Texture tex;
    tex.create(WINDOW_WIDTH, WINDOW_HEIGHT);
    sf::Sprite spr(tex);

    // Enable vertical sync. (vsync)
    window.setVerticalSyncEnabled (true);



    // ____________________
    // ::: Load texture :::

    // Create texture from PNG file
    sf::Texture texture;
    if (!texture.loadFromFile("../sfml-icon-small.png"))
    {
        std::cerr << "Error while loading texture" << std::endl;
        return -1;
    }
    // Enable the smooth filter. The texture appears smoother so that pixels are less noticeable.
    texture.setSmooth(true);



    // _______________________________________
    // ::: Create sprite and apply texture :::

    // Create the sprite and apply the texture
    sf::Sprite sprite;
    sprite.setTexture(texture);
    sf::FloatRect spriteSize=sprite.getGlobalBounds();
    // Set origin in the middle of the sprite
    sprite.setOrigin(spriteSize.width/2.,spriteSize.height/2.);



    // _______________
    // ::: Shaders :::

    // Check if shaders are available
    if (!sf::Shader::isAvailable())
    {
        std::cerr << "Shader are not available" << std::endl;
        return -1;
    }

    // Load shaders
    sf::Shader shader;
    if (!shader.loadFromFile(SHADER_FILENAME, sf::Shader::Fragment))
    {
        std::cerr << "Error while shaders" << std::endl;
        return -1;
    }




    // _________________
    // ::: Main loop :::

    sf::Clock time;
    while (window.isOpen())
    {
        // Process events
        sf::Event event;
        while (window.pollEvent(event))
        {
            // Close the window if a key is pressed or if requested
            if (event.type == sf::Event::Closed) window.close();

            // If escape is pressed, close the application
            if (event.type == sf::Event::KeyPressed && event.key.code==sf::Keyboard::Escape) window.close();
        }

        // Set shader parameters
        shader.setParameter("time", time.getElapsedTime().asSeconds());

        // Clear the window and apply grey background
        window.clear( sf::Color(127,127,127));

        // Draw the sprite and apply shader
        sprite.setPosition(window.getSize().x/2.,window.getSize().y/2.);
        window.draw(sprite,&shader);

        // Update display and wait for vsync
        window.display();
    }
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_006

<- Retour au menu du tutoriel sur SFML

SFML: Afficher un sprite

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment afficher un sprite en plein écran:

/*!
 * \file    main.cpp
 * \brief   start SFML in full screen and display a sprite (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme
 * \version 1.0
 * \date    12/18/2016
 */

// SFML libraries
#include 
#include 

int main()
{
    // _____________________
    // ::: Create window :::

    // Create a window with the same pixel depth as the desktop
    sf::VideoMode desktopMode = sf::VideoMode::getDesktopMode();

    sf::RenderWindow window(sf::VideoMode(  desktopMode.width,
                                            desktopMode.height,
                                            desktopMode.bitsPerPixel),
                            "SFML part 3",
                            sf::Style::Fullscreen);

    // Enable vertical sync. (vsync)
    window.setVerticalSyncEnabled (true);


    // ____________________
    // ::: Load texture :::

    // Create texture from PNG file
    sf::Texture texture;
    if (!texture.loadFromFile("../../img/sfml-icon-small.png"))
    {
        std::cerr << "Error while loading texture" << std::endl;
        return -1;
    }
    // Enable the smooth filter. The texture appears smoother so that pixels are less noticeable.
    texture.setSmooth(true);



    // _______________________________________
    // ::: Create sprite and apply texture :::

    // Create the sprite and apply the texture
    sf::Sprite sprite;
    sprite.setTexture(texture);
    sf::FloatRect spriteSize=sprite.getGlobalBounds();
    sprite.setOrigin(spriteSize.width/2.,spriteSize.height/2.);


    // _________________
    // ::: Main loop :::

    sf::Clock timer;
    while (window.isOpen())
    {
        // Display fps
        std::cout << int(1./timer.restart().asSeconds()) << " fps" << std::endl;

        // Process events
        sf::Event event;
        while (window.pollEvent(event))
        {
            // Close the window if a key is pressed or if requested
            if (event.type == sf::Event::Closed) window.close();
            if (event.type == sf::Event::KeyPressed) window.close();
        }

        // Clear the window and apply grey background
        window.clear( sf::Color(127,127,127));

        // Draw the sprite in the middle of the screen
        sprite.setPosition(window.getSize().x/2., window.getSize().y/2.);
        window.draw(sprite);

        // Update display and wait for vsync
        window.display();
    }
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_003

<- Retour au menu du tutoriel sur SFML

SFML : lister les résolutions

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Cet exemple montre comment obtenir la liste des résolutions utilisables pour le plein écran:

/*!
 * \file    main.cpp
 * \brief   Display the list of available video mode (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme
 * \version 1.0
 * \date    12/18/2016
 */

// SFML libraries
#include 
#include 

int main()
{

    // Display the list of all the video modes available for fullscreen
    std::vector modes = sf::VideoMode::getFullscreenModes();

    // Display each mode
    for (std::size_t i = 0; i < modes.size(); ++i)
    {
        sf::VideoMode mode = modes[i];
        std::cout << "Mode #" << i << "\t"
                  << mode.width << "x" << mode.height << " \t "
                  << mode.bitsPerPixel << " bpp" << std::endl;
    }

    // Get and display desktop mode
    sf::VideoMode mode = sf::VideoMode::getDesktopMode();
    std::cout << "Desktop"  << "\t"
              << mode.width << "x" << mode.height << " \t "
              << mode.bitsPerPixel << " bpp" << std::endl;

    // End of application
    return 0;
}

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_002

<- Retour au menu du tutoriel sur SFML

SFML: premier programme

Cet article appartient à une série de tutoriels dédiés à SFML. Le lecteur est invité à se référer aux autres sections de ce tutoriel en suivant ce lien : SFML tutoriel.

Paquets

Installer les paquets suivants:

sudo apt-get install qtcreator qt-sdk libsfml-dev

Configurer Qt

Pour compiler les applications avec la bibliothèque SFML, ajouter les lignes suivantes dans le fichier .pro:

LIBS += -lsfml-audio
LIBS += -lsfml-graphics
LIBS += -lsfml-network
LIBS += -lsfml-window
LIBS += -lsfml-system

Pour éviter les problèmes liés aux répertoires, décocher "Shadow build" dans le projet:

De la même façon, vous pouvez décocher "Run in terminal" :

Premier programme

/*!
 * \file    main.cpp
 * \brief   First example of SFML (http://www.lucidarme.me/?p=6127)
 * \author  Philippe Lucidarme (from official SFML tutorial)
 * \version 1.0
 * \date    12/18/2016
 */

// SFML libraries
#include 

int main()
{
    
    // Create a new 200x200 pixels window with a title
    sf::RenderWindow window(sf::VideoMode(200, 200), "SFML tutorial : part 1");
    
    // Create a green circle with a radius of 100. pixels
    sf::CircleShape shape(100.f);
    shape.setFillColor(sf::Color::Green);
    
    
    // Main loop, while the window is open
    while (window.isOpen())
    {
        // Event loop
        sf::Event event;
        while (window.pollEvent(event))
        {
            // If close is requested by user, close the window
            if (event.type == sf::Event::Closed) window.close();
        }
        
        // Display sequence : clear screen, draw circle and update display
        window.clear();
        window.draw(shape);
        window.display();
    }
    
    // End of application
    return 0;
}

Ce programme devrait afficher la fenêtre suivante:

Télécharger depuis Git

Les fichiers et les codes sources peuvent être téléchargés depuis GitLab : https://gitlab.com/philippe.lucidarme/sfml_tutorial/tree/master/part_001

<- Retour au menu du tutoriel sur SFML

SFML tutoriel

Ce tutoriel a été réalisé avec les versions logiciel suivantes:

  • XUbuntu 16.04 LTS
  • SFML 2.3.2
  • Qt Creator 3.5.1

Ce tutoriel est dédié aux développeurs qui sont déjà familiarisés avec le C/C++. Les fichiers et codes sources peuvent être téléchargés sur GitLab. Il s'agit d'une série d'exemples, chacun étant associé à un thème.

Optimisation, exemple de minimisation de fonction avec Matlab.

Voici un exemple de recherche de minimum de fonction avec avec la fonction fminsearch de Matlab :

optim

%% Optimization example
% This file is the main script
% Written by Philippe Lucidarme
% http://www.lucidarme.me
close all;
clear all;
clc;



%% Display the function fct

figure(1);
X=[-4:0.1:4]; %% The X-axis goes from the value of -5 to +5 with a step of 0.1 (100 points)
Y=[-4:0.1:4]; %% like the X-axis
[wx,wy]=meshgrid(X,Y); %% see [MATLAB documentation][1]
% Compute each point of the mesh
for i=1:size(X,2)
    for j=1:size(Y,2)
        %Z=100.*(wy - wx.^2).^2 + (1 - wx).^2;
        Z(j,i)=fct([X(i),Y(j)]);
    end
end
% Display curb
fig=surf(wx,wy,Z); %% make a surface plot with lighting
shading interp; %% optional, try to remove it.
%     hsv        - Hue-saturation-value color map.
%     hot        - Black-red-yellow-white color map.
%     gray       - Linear gray-scale color map.
%     bone       - Gray-scale with tinge of blue color map.
%     copper     - Linear copper-tone color map.
%     pink       - Pastel shades of pink color map.
%     white      - All white color map.
%     flag       - Alternating red, white, blue, and black color map.
%     lines      - Color map with the line colors.
%     colorcube  - Enhanced color-cube color map.
%     vga        - Windows colormap for 16 colors.
%     jet        - Variant of HSV.
%     prism      - Prism color map.
%     cool       - Shades of cyan and magenta color map.
%     autumn     - Shades of red and yellow color map.
%     spring     - Shades of magenta and yellow color map.
%     winter     - Shades of blue and green color map.
%     summer     - Shades of green and yellow color map.      
colormap cool; %% here you decide the colormap: hot is the one going from white to red
view(45,65);
rotate3d;
hold on;
xlabel ('x');
ylabel ('y');
title ('Optimization');




%% Optimization

% Initial point for optimization
x0 = [0,0];

% Set parameters
% optimplotfval, display the function evaluation
% iter, display algorithm status a each interation
% Call outfun at each iteration (for display)
options = optimset('PlotFcns',@optimplotfval,'Display','iter','OutputFcn', @outfun);
% Optimization algorithm
[x,FVAL,EXITFLAG,OUTPUT] = fminsearch(@fct,x0,options);


%% Display results

FVAL
OUTPUT
x
figure(1);
plot3 (x(1),x(2),fct(x),'or','MarkerSize',10,'LineWidth',5);
function y = fct( x )
% fct  function to minimize
%   x = [x,y] input vector
%   y = function output (scalar)
% Written by Philippe Lucidarme
% http://www.lucidarme.me

% Rosenbrock's function
%y = 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;

%y = (x(1)-4).^2 .* (x(2)-1.2).^2;

y = sinc(x(1)).*sinc(0.3*x(2));

end
function stop = outfun(x, optimValues, state)
% fct  this function is called at each step of the optimization process
%   x :             the point computed by the algorithm at the current iteration.
%   optimValues :   is a structure containing data from the current iteration.
%   state :         current state of the algorithm.
% Written by Philippe Lucidarme
% http://www.lucidarme.me

figure (1);
plot3 (x(1),x(2),optimValues.fval,'.k','MarkerSize',10);
stop=false;

Installation des logiciels FEBFMT1030 sous Linux

Cet article explique comment installer les logiciels du FEBFMT1030 (carte d'évaluation). Cette installation a été ralisée avec les versions suivantes des logiciels :

  • XUbuntu 14.04 LTS

Le logiciel peut être téléchargé depuis cette page : https://www.fairchildsemi.com/product-technology/mems-module/ ou ici :

Commençons par installer les dépendances :

sudo apt-get install realpath sharutils liblapack3 build-essential

Extraire l'archive principale et l'archive secondaire Linux qui se trouve à l'intérieur. Lancer un terminal (ctrl-alt-t) et se déplacer dans le répertoire de l'archive :

 cd path/to/the/archive 

Obtenir les droits sur l'USB

Ajouter l'utilisateur courant que groupe dialout :

sudo usermod -G dialout -a $USER

Après s'être ajouté au groupe, il faut soit redémarrer la session, soit exécuter la commande suivante pour que les changements soient effectifs:

newgrp dialout

Installation du SDK

Rendre les scripts executables :

chmod +x *.sh

Lancer les scripts :

 
sudo ./mtsdk_linux_4.4.135.sh
sudo ./mfmsdk_linux_4.4.135.sh
sudo ./fcs_mfmsdk_linux_4.4.135.sh
sudo ./fcs_mtsdk_linux_4.4.135.sh 

Installation de MTManager

Extraire l'arrchive fcs_mtmanager_Release-Linux-x64_135.tar.gz, et se déplacer dans le répertoire linux-64/bin directory. Lancer le logiciel de démo :

./mtmanager

La carte de développement est supportée sur les noyaux récents (depuis le 12 juin 2015). Si votre nsystème ne supporte pas la carte, vous pouvez l'ajouter manuellement :

sudo /sbin/modprobe ftdi_sio
echo 2639 0300 | sudo tee /sys/bus/usb-serial/drivers/ftdi_sio/new_id

Si la carte est reconnue mais non utilisable, consulter la section troubleshooting dans le fichier /usr/local/fairchild/README.MTSDK

Compiler un premier programme

Ajouter les bibliothèques au linker dynamique :

sudo ldconfig /usr/local/fairchild
sudo ldconfig /usr/local/xsens

Se déplacer dans le répertoire contenant les examples :

cd /usr/local/fairchild/examples/mtsdk/

Compiler :

make

Se déplacer dans le répertoire de compilation :

cd src_cpp

Lancer l'executable :

./example

La carte est nativement montée sur le port /dev/ttyUSB0, avec une vitesse de 115200 bauds.

Caractères autorisés dans un nom de fichier

Quels sont les caractère autorisés et interdits dans un nom de fichier ? POSIX "Fully portable filenames" liste les caractères suivants

  • Lettres majuscules : A B C ... Z (déconseillé, voir ci-dessous)
  • Lettres minuscules : a b c ... z
  • Chiffres : 0 1 2 ... 9
  • Point : .
  • Underscore : _
  • Moins : -

La ponctuation ne doit pas être utilisée comme premier caractère (. - _).

Exemple :

FileName_01-03-16.txt

Téléchargements

L'application check_file_name permet de renommer automatiquement les fichiers dans tous les sous-répertoires.

Afficher une image avec Qt (zoom, déplacement, redimensionnement, tool-tip, menu contextuel ...)

Cet article montre comment afficher une image avec QT. La classe rOg_image supporte les fonctionnalités suivantes:

  • affiche un QImage dans un widget,
  • affiche une image brute dans un widget,
  • supporte le redimensionnement intelligent,
  • zoom avant et arrière avec la molette,
  • déplacement de l'image avec le bouton gauche (dragging),
  • menu contextuel avec le bouton droit,
  • possibilité de surcharger la classe pour dessiner sur ou sous l'image (premier plan ou arrière plan),
  • possibilité de surcharger la classe pour afficher un tool-tip au passage de la souris.

Téléchargement

Crédits

Cette classe a été développée conjointement avec Simon Landrault (Eskimon).

Optimisation des accès mémoire

L'accès à de gros volumes de données stockés en mémoire peut avoir des répercutions importantes sur le temps d’exécution d'un programme. Comme les données sont généralement mémorisées dans la RAM, cela nécessite un transfert de la RAM vers le processeur. Ce transfert est coûteux car sur les PC, la RAM et le processeurs sont physiquement séparés. Lorsque l'on doit accéder fréquemment à un tableau de données la question de l'optimisation est un problème. J'ai lu et entendu beaucoup de choses sur ce sujet, voici la vérité (presque...). Cet article se focalise sur la lecture/écriture dans de grands tableaux de données stockés en mémoire. Nous ne considérerons pas le problème de l'allocation qui n'est généralement fait qu'une fois. Les tests suivants ont été réalisés sur une architecture Intel (octo-coeur I7) sous Ubuntu 14.04. Les données sont stockés en mémoire (pas de swap sur disk).

Accès continu versus Accès aléatoire

La première chose que l'on trouve dans la littérature est que l'accès continu à un tableau est plus rapide qu'un accès aléatoire. Considérons les codes suivants:

 
// Continuous access
uint16_t* array=new uint16_t [SIZE];
uint16_t Val;
for (uint64_t i=0;i

versus

// Random reading of data
uint16_t* array=new uint16_t [SIZE];
uint16_t Val;
for (uint64_t i=0;i

Les macros TIC et TOC macros mesurent le temps d'éxécution. Voici les résultats :

test1

La première conclusion est que l'accès continu est plus rapide. On pourrait imaginer que lors d'un accès mémoire, seuls les octets utiles sont copiés, mais en réalité le processeur copie des segments de données. Cela signifie que lors d'un accès continu, le nombre de copies est moindre, car les octets voisins sont déjà copiés. Lors d'un accès aléatoire, une copie doit être faite à chaque accès (si les octets ne sont pas dans le même segment. Je ne sais pas pourquoi l'écriture est plus rapide que la lecture. Si vous avez la réponse, n'hésitez pas à laisser un message en bas de la page.

New versus Malloc


L'allocation mémoire peut être faite avec les instructions new(c++) ou malloc(c). La question ici n'est pas de savoir lequel est le plus rapide, la question est de savoir si les données allouées avec l'un sont plus rapidement accessibles que les données allouées avec l'autre. Voici la réponse:

test2

Manifestement c'est équivalent. Ce n'est pas une grande surprise étant donné que dans les deux cas, les données sont stockées en mémoire. La légère différence entre les deux est probablement due aus autres processus du système qui ont pris un peu de ressources durant les tests

Accès à des tableaux multidimensionnels

Prenons l'exemple d'un tableau à deux dimensions alloué dynamiquement (par exemple une image). Nous voulons accéder au pixel de coordonnées (x,y). La première solution consiste à créer un tableau de taille width*height et d'accéder aux éléments en calculant l'index: y*width+x.

// Test 1 
uint16_t* array=new uint16_t [SIZE];
// ...
TIC_MACRO;
Val=array[y*WIDTH+x];
TOC_MACRO;

Bien sûr, cette première solution nécessite de calcul d'une multiplication et d'une addition qui peut être couteux. Une solution fréquement proposée est de créer un second tableau de pointeurs contenant l'adresse de chaque ligne du tableau principal. Cette solution nécessite une second tableau mais permet de s'affranchir du calcul de l'index:

// Test 2
uint16_t* array=new uint16_t [SIZE];
uint16_t** pArray=new uint16_t* [HEIGHT];
for (int i=0;i

Si les données ne doivent pas nécessairement être stockées de manière continue, il est même possible d'allouer chaque ligne séparément:

// Test 3
uint16_t** pArray=new uint16_t* [HEIGHT];
for (int i=0;i

Voici la comparaison:
test3

Comme on peut le constater, la première solution est la plus rapide, même si elle nécessite le calcul de l'index. Sur les machines contemporianes, un calcul de ce type ne prend en réalité que quelques cycles alors qu'un accès mémoire beaucoup plus. La seconde solution nécessite deux accès mémoires, un pour le pointer de ligne, et un autre pour la donnée. La troisième solution est encore plus mauvaise : elle nécessite plus de transferts de la mémoire vers le processeur car les données peuvent être dispersée en mémoire.

Type de données

Bien sûr, choisir letype de données approprié optimise la mémoire, but la question qui se pose ici est : est-ce que certains types de données sont plus rapides que d'autres ? J'ai entendu dore que des données alignées sur 32 ou 64 bits étaient plus rapides car les processeurs sont optimisés pour ce format de données. Par exemple, sur une architecture 32 bits un tableau de char serait moins rapide qu'un tableau de int. Voici le résultat d'éritures/lectures sur différents types de données :

test4

Il est clair que le type de données change les temps d'accès. Plus le type est grand, plus l'accès est lent. Je suppose que c'est lié au fait que de plus grands tableaux nécessitent plus de copies de la mémoires vers le processeur. Un tableau de uint64_t est 8 fois plus grand qu'un tableau de uint8_t. Ces résultats sont toutefois à prendre avec précaution car ces temps d'accès ne sont pas nécessairement vrais lorsque l'on accède à quelques octets.

Téléchargement

GIT mémo

Paramétrage global de Git

Définir le nom de l'utilisateur :

git config --global user.name "Firstname Lastname"

Définit l'email de l'utilisateur :

git config --global user.email "name@example.com"

Créer un nouveau dépot

git clone 
cd repo_folder
touch README.md
git add README.md
git commit -m "add README"
git push -u origin master

Dossier ou dépôt existant

cd existing_folder
git init
git remote add origin 
git add .
git commit
git push -u origin master

Commit, pull et push

Mettre à jour la version locale du code :

git pull

Mettre le code à jour sur le dépôt:

git commit -a -m "Add a comment here"
git push origin master

Supprimer un fichier:

git rm filename

Annuler les changements locaux et revenir à la dernière version du serveur:

git checkout -- .

Afficher la liste des serveurs

git remote -v

Créer une nouvelle branche

git branch brancheName

Créer une nouvelle branche depuis un commit précédent

git branch brancheName commitName

Afficher la liste des branches

git branch

Changer de branche

git checkout branchName

Créer une nouvelle branche et basculer vers celle-ci

git checkout -b branchName [commitName]

Fusionner la branche courante avec la branche principale (master)

git merge branchName

Envoyer la branche courante sur le serveur

git push origin branchName

Supprimer une branche

git branch -d branchName

FOrce la suppression d'une branche

git branch -D branchName

Récupérer les modification de la branche principale dans la branche courante

git pull master

ou

git rebase

Commiter un fichier

git add fileName
git commit -a -m "Comment"

OpenGL et Qt-Creator

Cet article est un simple exemple d'utilisation d'OpenGL dans une fenêtre Qt. Cet example a été réalisé avec les versions suivantes:

  • Xubuntu 14.04 LTS
  • Qt Creator 3.0.1
  • Qt 5.2.1 (GCC 4.8.2, 64 bit)

Capture d'écran

Cette application affiche un repère 3 axes et un nuage de points formant un cube.
capture

Installation des logiciels


Il peut être nécessaire d'installer la boite à outils OpenGL GLUT (OpenGL Utility Toolkit):

sudo apt-get install freeglut3 freeglut3-dev

Téléchargement


Scanner I2C pour Arduino

Le programme suivant est un scanner I2C pour Arduino. Il tente de lire une donnée (un octet) à chaque adresse I2C inclue dans l'intervalle [0:255]. Les adresses des modules esclaves qui répondent sont affichées dans le terminal.

#include 


void setup() { 
 //Initialize serial and wait for port to open:
  Serial.begin(115200); 
  
  // prints title with ending line break 
  Serial.println("I2C scanner ::: www.lucidarme.me"); 
} 


void loop() 
{
  // Test each I2C address 
  for (int i=0;i<256;i++)
  {
    // Request data (read one byte)
    Wire.requestFrom(i, 1);

    // If slave answers, a device is found
    if (Wire.available())
    {
      // Display address
      Serial.print(i,DEC);
      Serial.print("\t0x");
      Serial.print(i,HEX);
      Serial.print("\t");    
      Serial.print("0b");
      Serial.print(i,BIN);
      Serial.print("\t");
      Serial.println("Device found");
    }
    
//    delay(100);
  }
  Serial.println("End of scan"); 
  while (1);
}