Comment afficher une image en C ?

**Le Pharaon** · 30/01/2006, 17h06

Bonjour tout le monde

Je dois dans mon programme en C mettre une image dans une page de garde. Je vous signale que je n'ai travaillé avec les images. J'aimerais ainsi savoir comment celà fonctionne. Un bout de code à l'appuie serait le bienvenu

**fearyourself** · 30/01/2006, 17h10

Déjà, il fait quoi ton programme? Parce que je ne comprends pas trop cette phrase:

Je dois dans mon programme en C mettre une image dans une page de garde.

Ton programme crée un livre?

Ensuite, il n'y a pas de standard C pour ouvrir/afficher/écrire un fichier graphique. Pour cela, tu vas devoir utiliser une des librairies qui peut le faire: SDL_image, OpenIL ou l'écrire à la main (pour les bitmaps, c'est facile).

Pour des bouts de code, suffit de faire SDL_Image/OpenIL + Tutorial avec le grand, le magique le beau:

Jc

**Le Pharaon** · 30/01/2006, 17h39

Envoyé par fearyourself

Déjà, il fait quoi ton programme? Parce que je ne comprends pas trop cette phrase:

Je dois dans mon programme en C mettre une image dans une page de garde.

Ton programme crée un livre?

Je m'excuse de pas avoir été plus claire
En fait c'est dans l'interface même du programme que je dois insérer l'image, un logo au format bmp.

Envoyé par fearyourself

l'écrire à la main (pour les bitmaps, c'est facile).

C'est ce que je veux alsolument faire

**fearyourself** · 30/01/2006, 18h09

Je suis désolé mais pour aider, il faudrait plus d'information.

Sous quel SE es-tu?

Quelle est le GUI que t'utilises (OpenGL/SDL ou Glut, DirectX, Tcl/Tk...)? Dépendant du quel tu utilises, ils ont déjà des fonctions toutes faites....

Jc

Ici se trouve du code qui pourra t'aider à comprendre le format:

http://astronomy.swin.edu.au/~pbourke/dataformats/bmp/

**Le Pharaon** · 31/01/2006, 09h32

J'ai bien été claire, je n'ai que des notions simples sur ce que je veux faure. Si je trouve un exemple j'arriverai à l'adapter. Que ce soit en OpenGl, DiretX ....

Merci quand même !
Nota : SE = Windows

**fearyourself** · 31/01/2006, 10h34

Ok, si je comprends bien tu n'as même pas encore choisi quel langage utilisé pour faire ton interface graphique... Sans ce choix, cela ne sert à rien de réfléchir à comment lire un .bmp...

Sinon regarde le lien, il permet d'ouvrir et lire les .bmp

Jc

**Le Pharaon** · 31/01/2006, 11h01

Envoyé par fearyourself

Ok, si je comprends bien tu n'as même pas encore choisi quel langage utilisé pour faire ton interface graphique...

Je fais du C en mode console

**Médinoc** · 31/01/2006, 11h02

Ben, comment veux-tu afficher une image dans une console ??
Quel que soit le format...

**ToTo13** · 31/01/2006, 11h04

Bonjour,
pour ma part je fais de l'imagerie numérique.

Un standart pour tout ce qui est imagerie est d'utiliser OpenGL et certaines de ces extensions. En général, sous Linux, Unix et Mac OS X OpenGL est installé par défaut, sinon tu devras le rajouter.

OpenGL permet d'afficher des images dans une fenêtre graphique. Il faut juste avoir la librairie C qui gère le format de ton image (pour toi la lib BMP).
Tu trouvera des tutoriaux, canevas, sources sur :
http://www.linuxgraphic.org/ (Site officiel d'imagerie)
http://www.esil.univ-mrs.fr/~gthibaul/Cours/LienCours.php.html (mon site)
http://www.esil.univ-mrs.fr/~smavroma/page1/page3/page3.html (toutes les fonctions utilisable, un de mes potes chercheur)

Si tu as encore des soucis, je peux t'envoyer un canevas pour afficher des images au format PGM (c'est du noir et blanc).

**gege2061** · 31/01/2006, 11h06

Envoyé par Bujuman

Envoyé par fearyourself

Ok, si je comprends bien tu n'as même pas encore choisi quel langage utilisé pour faire ton interface graphique...

Je fais du C en mode console

Ce qui ne change rien au problème, le C standard ne connait pas les images et ne sais encore moins les afficher, il te faut donc utiliser une bibliothèque.

Donc commence par répondre à la question avec quoi et ensuite on pourra réfléchir à comment.

si ça peux t'aider j'ai entendu parler du framebuffer sous Linux qui permet de faire ceci.

**Le Pharaon** · 31/01/2006, 11h14

Peut-être que je me suis mal exprimé
Voici un code que j'ai trouvé sur le net.
Le principe serait à mon avis de lire le fichier bmp et de l'afficher pixel par pixel

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
 
#define VIDEO_INT           0x10      /* the BIOS video interrupt. */
#define WRITE_DOT           0x0C      /* BIOS func to plot a pixel. */
#define SET_MODE            0x00      /* BIOS func to set the video mode. */
#define VGA_256_COLOR_MODE  0x13      /* use to set 256-color mode. */
#define TEXT_MODE           0x03      /* use to set 80x25 text mode. */
 
#define SCREEN_WIDTH        320       /* width in pixels of mode 0x13 */
#define SCREEN_HEIGHT       200       /* height in pixels of mode 0x13 */
#define NUM_COLORS          256       /* number of colors in mode 0x13 */
 
typedef unsigned char  byte;
typedef unsigned short word;
 
 
byte *VGA=(byte *)0xA0000000L;        /* this points to video memory. */
word *my_clock=(word *)0x0000046C;    /* this points to the 18.2hz system
                                         clock. */
 
/**************************************************************************
 *  set_mode                                                              *
 *     Sets the video mode.                                               *
 **************************************************************************/
 
void set_mode(byte mode)
{
  union REGS regs;
 
  regs.h.ah = SET_MODE;
  regs.h.al = mode;
  int86(VIDEO_INT, &regs, &regs);
}
 
/**************************************************************************
 *  plot_pixel_slow                                                       *
 *    Plot a pixel by using BIOS function 0x0C (Write Dot).               *
 **************************************************************************/
 
void plot_pixel_slow(int x,int y,byte color)
{
  union REGS regs;
 
  regs.h.ah = WRITE_DOT;
  regs.h.al = color;
  regs.x.cx = x;
  regs.x.dx = y;
  int86(VIDEO_INT, &regs, &regs);
}
 
/**************************************************************************
 *  plot_pixel_fast                                                       *
 *    Plot a pixel by directly writing to video memory.                   *
 **************************************************************************/
 
void plot_pixel_fast(int x,int y,byte color)
{
  VGA[y*SCREEN_WIDTH+x]=color;
}
 
/**************************************************************************
 *  Main                                                                  *
 *    Plots 50000 pixels two different ways: using the BIOS and by        *
 *    directly writing to video memory.                                   *
 **************************************************************************/
 
void main()
{
  int x,y,color;
  float t1,t2;
  word i,start;
 
  srand(*my_clock);                   /* seed the number generator. */
  set_mode(VGA_256_COLOR_MODE);       /* set the video mode. */
 
  start=*my_clock;                    /* record the starting time. */
  for(i=0;i<50000L;i++)               /* randomly plot 50000 pixels. */
  {
    x=rand()%SCREEN_WIDTH;
    y=rand()%SCREEN_HEIGHT;
    color=rand()%NUM_COLORS;
    plot_pixel_slow(x,y,color);
  }
 
  t1=(*my_clock-start)/18.2;          /* calculate how long it took. */
 
  set_mode(VGA_256_COLOR_MODE);       /* set the video mode again in order
                                         to clear the screen. */
 
  start=*my_clock;                    /* record the starting time. */
  for(i=0;i<50000L;i++)               /* randomly plot 50000 pixels. */
  {
    x=rand()%SCREEN_WIDTH;
    y=rand()%SCREEN_HEIGHT;
    color=rand()%NUM_COLORS;
    plot_pixel_fast(x,y,color);
  }
 
  t2=(*my_clock-start)/18.2;          /* calculate how long it took. */
  set_mode(TEXT_MODE);                /* set the video mode back to
                                         text mode. */
 
  /* output the results... */
  printf("Slow pixel plotting took %f seconds.\n",t1);
  printf("Fast pixel plotting took %f seconds.\n",t2);
  if (t2 != 0) printf("Fast pixel plotting was %f times faster.\n",t1/t2);
 
  return;
}

**ToTo13** · 31/01/2006, 11h17

Pour ma part, je ne connais pas ce genre de code.
J'utilise OpenGL pour l'affichage et ca marche parfaitement, en plus c'est portable.
Donc voir mon message précédent.

**fearyourself** · 31/01/2006, 11h37

Ecrire directement dans la carte graphique:

Sérieusement, je l'ai aussi fait pour faire un petit moteur 3D qui fait tourner un cube en utilisant un effet d'ombre gaussien (juste pour l'histoire) mais sérieusement, je ne suis pas sûr que c'est une bonne idée, encore moins si c'est vraiment très portable.

Faire une interface graphique à partir de rien et juste utiliser la mémoire de la carte graphique me semble une idée bizarre pour faire une interface graphique... Surtout quand tout ce que tu veux faire c'est afficher un bmp...

Jc

**DaZumba** · 31/01/2006, 11h44

Envoyé par Bujuman

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

#include <dos.h>

Tu ne peux donc utiliser cette methode que sous MS-DOS, et cela depasse les connaissances de la plupart des intervenants de ce forum. Les systemes d'exploitation modernes interdisent l'interaction directe avec le materiel. Il faut desormais passer par les pilotes du materiel (drivers, modules selon le systeme).

En mode console pur, il est impossible d'afficher une image. On peut jouer sur la couleur du texte pour certains terminaux acceptant cette possibilite, mais c'est bien le maximum.
Si tu veux afficher une image, une bibliotheque de fenetrage comme GTK est un bon choix.

**hegros** · 31/01/2006, 13h37

Envoyé par Bujuman

Quels durs moments !

Qu'est-ce que tu ne comprends pas dans ce qui a été dis ?

**Le Pharaon** · 31/01/2006, 14h18

Je fais du C standard on me parle de OpenGL, de GTK ,de DirectX.
C'est un projet d'école je n'ai pas le choix des outils. Le mode console uniquement

**DaZumba** · 31/01/2006, 14h25

Envoyé par Bujuman

C'est un projet d'école je n'ai pas le choix des outils. Le mode console uniquement

Dans ce cas, ce que tu souhaites faire est impossible. Une console ne peut afficher d'image, elle ne gere que du texte (c'est deja bien pour beaucoup d'applications).

Pour citer ta signature: "Parfois, les circonstances extérieures sont les plus fortes, et il est obligé de se montrer lâche et de céder. Tout cela fait partie de l'apprentissage." (bon, le mot lachete est un peu fort...)

**PRomu@ld** · 31/01/2006, 14h27

Je fais du C standard on me parle de OpenGL, de GTK ,de DirectX.

Il faut faire une différence entre le langage C et les outils qui utilisent le langage C.

C'est un projet d'école je n'ai pas le choix des outils. Le mode console uniquement

J'ai du mal à voir comment tu veux afficher une image en mode console ... (à part en framebuffer mais sous windows ça va être dur ...)

**Emmanuel Delahaye** · 31/01/2006, 16h36

Envoyé par Bujuman

Voici un code que j'ai trouvé sur le net.
Le principe serait à mon avis de lire le fichier bmp et de l'afficher pixel par pixel

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>

Pas standard. Ne fonctionne que sous MS-DOS et les vieux Windows...

Sur les systèmes modernes (NT, Unixoides), ce genre ne manip n'est pas autorisée. (En fait, les fonctions BIOS de la PROM de boot sont carrément remplacées par d'autres fonctions par le système...)

Il faut utiliser des fonctions systèmes ou des bibliothèques portables spécialisées comme on te l'a déjà expliqué.