इंटेल रीयलसेन्स (विज़ुअल सी ++) में एक छवि को कैसे सहेजें

Question

मैं इंटेल रीयलसेन्स एसडीके (आर 2) पर काम कर रहा हूं। मैं कैमरा_दृश्य से छवि को सहेजना चाहता हूं। मैंने फ्रेम को विशिष्ट बफर में सहेजने तक और इसे पुनर्प्राप्त करने तक काम किया है। मैं जानना चाहता हूं कि उन फ्रेम/छवियों को किसी निर्दिष्ट स्थान/फ़ोल्डर में कैसे सहेजना है।

PXCImage *colorIm, *depthIm; 
for (int i=0; i<MAX_FRAMES; i++) { 

    // This function blocks until all streams are ready (depth and color) 
    // if false streams will be unaligned 
    if (psm->AcquireFrame(true)<PXC_STATUS_NO_ERROR) break; 

    // retrieve all available image samples 
    PXCCapture::Sample *sample = psm->QuerySample(); 

    // retrieve the image or frame by type from the sample 
    colorIm = sample->color; 
    depthIm = sample->depth; 

    // render the frame 
    if (!renderColor->RenderFrame(colorIm)) break; 
    if (!renderDepth->RenderFrame(depthIm)) break; 

    // release or unlock the current frame to fetch the next frame 
    psm->ReleaseFrame(); 
} 

मैं फ्रेम/छवियों सफलतापूर्वक पुनः प्राप्त कर हूँ, लेकिन मैं आगे उपयोग के लिए उन फ़ाइलों को सहेजना चाहते:

यहाँ मेरी कोड है। इसलिए मैं जानना चाहता हूं कि उन फ़ाइलों को फ़ोल्डर में कैसे सहेजना है।

अग्रिम धन्यवाद

Answer 1

एक ही सवाल here को कहा था और जवाब यह है कि पोस्ट किया गया प्रारंभिक सवाल हल किया। हालांकि छवियों को विशिष्ट फ़ोल्डर में सहेजने के तरीके पर एक फॉलो-अप प्रश्न था।

यदि आपके पास यह विशिष्ट प्रश्न है, तो उत्तर केवल SetFileName() होगा। this link, pxcCHAR *file is the full path of the file to playback or to be recorded. के अनुसार। ऐसा कहा जा रहा है कि, आप एक कस्टम फ़ोल्डर बना सकते हैं और custom folder पर अपना पथ इंगित कर सकते हैं, इसके बाद आपकी छवि को सहेजने के लिए एक वैध फ़ाइल नाम हो सकता है।

Answer 2

डेटा को बचाने मैं छवि डेटा से एक बिटमैप पैदा करेगा के रूप में ThorngardSO कहा और इसे सहेजने के लिए http://www.runicsoft.com/bmp.cpp से कोड का उपयोग करने के लिए -

#include <windows.h> 
#include <stdio.h>  // for memset 

bool SaveBMP (BYTE* Buffer, int width, int height, long paddedsize, LPCTSTR bmpfile) 
{ 
    // declare bmp structures 
    BITMAPFILEHEADER bmfh; 
    BITMAPINFOHEADER info; 

    // andinitialize them to zero 
    memset (&bmfh, 0, sizeof (BITMAPFILEHEADER)); 
    memset (&info, 0, sizeof (BITMAPINFOHEADER)); 

    // fill the fileheader with data 
    bmfh.bfType = 0x4d42;  // 0x4d42 = 'BM' 
    bmfh.bfReserved1 = 0; 
    bmfh.bfReserved2 = 0; 
    bmfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + paddedsize; 
    bmfh.bfOffBits = 0x36;  // number of bytes to start of bitmap bits 

    // fill the infoheader 

    info.biSize = sizeof(BITMAPINFOHEADER); 
    info.biWidth = width; 
    info.biHeight = height; 
    info.biPlanes = 1;   // we only have one bitplane 
    info.biBitCount = 24;  // RGB mode is 24 bits 
    info.biCompression = BI_RGB;  
    info.biSizeImage = 0;  // can be 0 for 24 bit images 
    info.biXPelsPerMeter = 0x0ec4;  // paint and PSP use this values 
    info.biYPelsPerMeter = 0x0ec4;  
    info.biClrUsed = 0;   // we are in RGB mode and have no palette 
    info.biClrImportant = 0; // all colors are important 

    // now we open the file to write to 
    HANDLE file = CreateFile (bmpfile , GENERIC_WRITE, FILE_SHARE_READ, 
     NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
    if (file == NULL) 
    { 
     CloseHandle (file); 
     return false; 
    } 

    // write file header 
    unsigned long bwritten; 
    if (WriteFile (file, &bmfh, sizeof (BITMAPFILEHEADER), &bwritten, NULL) == false) 
    { 
     CloseHandle (file); 
     return false; 
    } 
    // write infoheader 
    if (WriteFile (file, &info, sizeof (BITMAPINFOHEADER), &bwritten, NULL) == false) 
    { 
     CloseHandle (file); 
     return false; 
    } 
    // write image data 
    if (WriteFile (file, Buffer, paddedsize, &bwritten, NULL) == false) 
    { 
     CloseHandle (file); 
     return false; 
    } 

    // and close file 
    CloseHandle (file); 

    return true; 
} 

यह तो बाद में ही कड़ी से अधिक कोड का उपयोग कर लोड किया जा सकता -

/******************************************************************* 
BYTE* LoadBMP (int* width, int* height, long* size 
     LPCTSTR bmpfile) 

The function loads a 24 bit bitmap from bmpfile, 
stores it's width and height in the supplied variables 
and the whole size of the data (padded) in <size> 
and returns a buffer of the image data 

On error the return value is NULL. 

    NOTE: make sure you [] delete the returned array at end of 
     program!!! 
*******************************************************************/ 

BYTE* LoadBMP (int* width, int* height, long* size, LPCTSTR bmpfile) 
{ 
    // declare bitmap structures 
    BITMAPFILEHEADER bmpheader; 
    BITMAPINFOHEADER bmpinfo; 
    // value to be used in ReadFile funcs 
    DWORD bytesread; 
    // open file to read from 
    HANDLE file = CreateFile (bmpfile , GENERIC_READ, FILE_SHARE_READ, 
     NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL); 
    if (NULL == file) 
     return NULL; // coudn't open file 


    // read file header 
    if (ReadFile (file, &bmpheader, sizeof (BITMAPFILEHEADER), &bytesread, NULL) == false) 
    { 
     CloseHandle (file); 
     return NULL; 
    } 

    //read bitmap info 

    if (ReadFile (file, &bmpinfo, sizeof (BITMAPINFOHEADER), &bytesread, NULL) == false) 
    { 
     CloseHandle (file); 
     return NULL; 
    } 

    // check if file is actually a bmp 
    if (bmpheader.bfType != 'MB') 
    { 
     CloseHandle (file); 
     return NULL; 
    } 

    // get image measurements 
    *width = bmpinfo.biWidth; 
    *height = abs (bmpinfo.biHeight); 

    // check if bmp is uncompressed 
    if (bmpinfo.biCompression != BI_RGB) 
    { 
     CloseHandle (file); 
     return NULL; 
    } 

    // check if we have 24 bit bmp 
    if (bmpinfo.biBitCount != 24) 
    { 
     CloseHandle (file); 
     return NULL; 
    } 


    // create buffer to hold the data 
    *size = bmpheader.bfSize - bmpheader.bfOffBits; 
    BYTE* Buffer = new BYTE[ *size ]; 
    // move file pointer to start of bitmap data 
    SetFilePointer (file, bmpheader.bfOffBits, NULL, FILE_BEGIN); 
    // read bmp data 
    if (ReadFile (file, Buffer, *size, &bytesread, NULL) == false) 
    { 
     delete [] Buffer; 
     CloseHandle (file); 
     return NULL; 
    } 

    // everything successful here: close file and return buffer 

    CloseHandle (file); 

    return Buffer; 
} 

फिर आप उन बिटमैप फ़ाइलों को एक बाद की तारीख में कोड का उपयोग कर इंटेल https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/manuals_image_and_audio_data.html से लोड कर सकते हैं -

// Image info 
PXCImage::ImageInfo info={}; 
info.format=PXCImage::PIXEL_FORMAT_RGB32; 
info.width=image_width; 
info.height=image_height; 

// Create the image instance 
PXCImage image=session->CreateImage(&info); 

// Write data 
PXCImage::ImageData data; 
image->AcquireAccess(PXCImage::ACCESS_WRITE,&data); 
... // copy the imported image to data.planes[0] 
image->ReleaseAccess(&data); 

कोड के इन तीन सेटों का उपयोग करके आप आसानी से WriteFile का उपयोग करके किसी भी निर्दिष्ट फ़ोल्डर में बिटमैप्स को सहेजने में सक्षम होना चाहिए, एक बार लोड होने पर आप बिटमैप को छविडेटा में वापस परिवर्तित कर सकते हैं।

मुझे बताएं कि यह कैसा चल रहा है।