[MFC] Enregistrement d'une image affichée à l'écran . . .

Enregistrement d'une image affichée à l'écran . . . [MFC] - C++ - Programmation

Marsh Posté le 23-02-2004 à 14:41:13    

J'ai réalisé un prog. qui affiche (dans une fenetre) un flux d'image qu'il recoit par le proto. TCP.
Je cherche le moyen d'enregistrer à n'importe quel moment l'image qui est affichée à cet instant.
 
Pour ce qui est de l'affichage, j'utilise les fct  
 
LoadImage()
GetObject()
SelectObject()
StretchBlt()
 
et une instance de la classe CPaintDC.
 
L'image affichée à l'instant 't' à l'écran est passer en paramètre à la fct.  
LoadImage(NULL, "MON_IMAGE.BMP", IMAGE_BITMAP,0,0, LR_DEFAULTSIZE|LR_LOADFROMFILE);
 
Je cherche le moyen que dès lorsque j'appui sur un bouton "SaveImage" (par ex.), l'image affichée à cet instant soit sauvegardée.
 
Une solution ?

Reply

Marsh Posté le 23-02-2004 à 14:41:13   

Reply

Marsh Posté le 23-02-2004 à 15:09:30    

        Salut,
 
 
    Faut créer une bitmap, c'est le plus simple a faire, je dois avoir un exemple qaui traine.............
 

Code :
  1. Save()
  2. {
  3. int iColor   = GetBitColor(); // Fonction qui donne le nombre de bit voulut -> met 24
  4. DWORD dwSize  = m_ImageSizeX * m_ImageSizeY * iColor;
  5. DWORD dwTmp   = 0;
  6. BITMAPFILEHEADER hdr;
  7. HANDLE hf   = NULL;
  8. BITMAPINFO *pBitmap = NULL;
  10. if (iColor == DEF_NB_COLOR_8)
  11. {
  12.  LOGPALETTE* plp = NULL;
  13.  plp = (LOGPALETTE *)malloc (sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY));
  14.  plp->palVersion    = 0x0300;
  15.  plp->palNumEntries = 256;
  16.  for (int i = 0; i < 256; i++)
  17.  {
  18.   // Creation d'une palette 256 niveau de gris
  19.   plp->palPalEntry[i].peRed   = i;
  20.   plp->palPalEntry[i].peGreen = i;
  21.   plp->palPalEntry[i].peBlue  = i;
  22.   plp->palPalEntry[i].peFlags = 0;
  23.  }
  24.  pBitmap = (BITMAPINFO*) malloc(sizeof(BITMAPINFO)+256*sizeof(RGBQUAD));
  25.  memset(pBitmap, 0, sizeof(BITMAPINFO));
  26.  memcpy(pBitmap->bmiColors, plp->palPalEntry, 256*sizeof(RGBQUAD));
  27.  free(plp);
  28.  pBitmap->bmiHeader.biClrUsed = 256;
  29.  pBitmap->bmiHeader.biClrImportant = 0;
  31.  hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"  
  32.  // Compute the size of the entire file.  
  33.  hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO) + (256 * sizeof(RGBQUAD)) + dwSize);
  34.  hdr.bfReserved1 = 0;
  35.  hdr.bfReserved2 = 0;
  36.  // Compute the offset to the array of color indices.  
  37.  hdr.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO) + (256 * sizeof(RGBQUAD)));
  38. }
  39. else
  40. {
  41.  pBitmap = (BITMAPINFO*) malloc(sizeof(BITMAPINFO));
  42.  memset(pBitmap,0,sizeof(BITMAPINFO));
  44.  hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M"  
  45.  // Compute the size of the entire file.  
  46.  hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO) + dwSize);
  47.  hdr.bfReserved1 = 0;
  48.  hdr.bfReserved2 = 0;
  49.  // Compute the offset to the array of color indices.  
  50.  hdr.bfOffBits = (DWORD)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFO)) ;
  51. }
  53. pBitmap->bmiHeader.biBitCount  = 8 * iColor;
  54. pBitmap->bmiHeader.biPlanes   = 1;
  55. pBitmap->bmiHeader.biHeight   = m_ImageSizeY;
  56. pBitmap->bmiHeader.biWidth   = m_ImageSizeX;
  57. pBitmap->bmiHeader.biSizeImage  = dwSize;
  58. pBitmap->bmiHeader.biSize   = sizeof(BITMAPINFOHEADER);
  59. pBitmap->bmiHeader.biCompression = BI_RGB;
  61. // Create the .BMP file.  
  62. hf = CreateFile(csFile, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  63. if (hf != INVALID_HANDLE_VALUE)
  64. {
  65.  BOOL bDetruire = TRUE;
  67.  // Copy the BITMAPFILEHEADER into the .BMP file.  
  68.  WriteFile(hf, (LPVOID)&hdr, sizeof(BITMAPFILEHEADER), (LPDWORD)&dwTmp,  NULL);
  69.  if (dwTmp == sizeof(BITMAPFILEHEADER))
  70.  {
  71.   // Copy the BITMAPINFOHEADER and RGBQUAD array into the file.  
  72.   if (iColor == DEF_NB_COLOR_8)
  73.   {
  74.    WriteFile(hf, (LPVOID)pBitmap, sizeof(BITMAPINFO) + (256 * sizeof(RGBQUAD)), &dwTmp, NULL);
  75.   }
  76.   else
  77.   {
  78.    WriteFile(hf, (LPVOID)pBitmap, sizeof(BITMAPINFO), &dwTmp, NULL);
  79.   }
  81.   if (dwTmp == (iColor == DEF_NB_COLOR_8 ? sizeof(BITMAPINFO) + (256 * sizeof(RGBQUAD)) : sizeof(BITMAPINFO)))
  82.   {
  83.    // Copy the array of color indices into the .BMP file.  
  84.    WriteFile(hf, m_pImage->GetImagePtr(), dwSize, &dwTmp, NULL);
  86.    if (dwTmp == dwSize)
  87.    {
  88.     bRet  = TRUE;
  89.     bDetruire = FALSE;
  90.    }
  91.    else if (!bQuiet)
  92.    {
  93.     AfxMessageBox("Impossible d'écrire les données de l'image.", MB_ICONSTOP);
  94.    }
  95.   }
  96.   else if (!bQuiet)
  97.   {
  98.    AfxMessageBox("Impossible d'écrire les informations de la palette dans l'image.", MB_ICONSTOP);
  99.   }
  100.  }
  101.  else if (!bQuiet)
  102.  {
  103.   AfxMessageBox("Impossible d'écrire l'entête de l'image.", MB_ICONSTOP);
  104.  }
  106.  // Close the .BMP file.  
  107.  CloseHandle(hf);
  109.  if (bDetruire)
  110.  {
  111.   DeleteFile(csFile);
  112.  }
  113. }
  115. free(pBitmap);
  116. }
  118. Load()
  119. {
  120. if (m_pPicture)
  121. {
  122.  m_pPicture->Release();
  123.  m_pPicture = NULL;
  124. }
  126. // handle sur le fichier selectionné
  127. HANDLE hFile = CreateFile(csFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
  128. if (INVALID_HANDLE_VALUE != hFile)
  129. {
  130.  // Taille du fichier
  131.  DWORD dwFileSize = GetFileSize(hFile, NULL);
  132.  if (-1 != dwFileSize)
  133.  {
  134.   // allouer la memoire a partir de la taille du fichier
  135.   HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, dwFileSize);
  136.   if (hGlobal)
  137.   {
  138.    LPVOID pvData = GlobalLock(hGlobal);
  139.    if (pvData)
  140.    {
  141.     DWORD dwBytesRead = 0;
  142.     // lecture du fichier et stockage dans la memoire
  143.     BOOL bRead = ReadFile(hFile, pvData, dwFileSize, &dwBytesRead, NULL);
  144.     GlobalUnlock(hGlobal);
  145.     if (bRead)
  146.     {
  147.      LPSTREAM pstm = NULL;
  148.      // creation IStream* a partir de la memoire
  149.      HRESULT hr = CreateStreamOnHGlobal(hGlobal, TRUE, &pstm);
  150.      if(SUCCEEDED(hr) && pstm)
  151.      {
  152.       // Creation IPicture a partit du du flux IStream*
  153.       hr = ::OleLoadPicture(pstm, dwFileSize, FALSE, IID_IPicture, (LPVOID *)&m_pPicture);
  154.       if (SUCCEEDED(hr) && m_pPicture)
  155.       {
  156.        short sType;
  157.        hr = m_pPicture->get_Type(&sType);
  158.        if (SUCCEEDED(hr))
  159.        {
  160.         if (sType == PICTYPE_BITMAP)
  161.         {
  162.          HBITMAP hBitmap;
  163.          hr = m_pPicture->get_Handle((OLE_HANDLE *) &hBitmap);
  164.          if (SUCCEEDED(hr) && hBitmap)
  165.          {
  166.           RedrawWindow();
  167.          }
  168.         }
  169.        }
  170.       }
  171.       pstm->Release();
  172.      }
  173.     }
  174.     else if (!bQuiet)
  175.     {
  176.      AfxMessageBox("Impossible de lire le fichier image.", MB_ICONSTOP);
  177.     }
  178.    }
  179.    GlobalFree(hGlobal);
  180.   }
  181.  }
  182.  CloseHandle(hFile);
  183. }
  184. }


---------------
La raison du plus fort est toujours la plus forte.... Parce que c'est comme ça NA !
Reply

Marsh Posté le 23-02-2004 à 17:07:15    

En effet, c'était pas très compliquer ;)
Merci pour ton source...

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed