Convert Leptonica Pix Object to QPixmap ( or other image object )

Question

I'm using the Leptonica Library to process some pictures. After that I want to show them in my QT GUI. Leptonica is using their own format Pix for the images, while QT is using their own format QPixmap. At the moment the only way for me is to save the pictures after processing as a file ( like bmp ) and then load them again with a QT function call. Now I want to convert them in my code, so I dont need to take the detour with saving them on the filesystem. Any ideas how to do this?

Best Regards

// edit:

Okay as already suggested I tried to convert the PIX* to a QImage. The PIX* is defined like this:

http://tpgit.github.com/Leptonica/pix_8h_source.html

struct Pix
{
  l_uint32             w;           /* width in pixels                   */
  l_uint32             h;           /* height in pixels                  */
  l_uint32             d;           /* depth in bits                     */
  l_uint32             wpl;         /* 32-bit words/line                 */
  l_uint32             refcount;    /* reference count (1 if no clones)  */
  l_int32              xres;        /* image res (ppi) in x direction    */
                                    /* (use 0 if unknown)                */
  l_int32              yres;        /* image res (ppi) in y direction    */
                                    /* (use 0 if unknown)                */
  l_int32              informat;    /* input file format, IFF_*          */
  char                *text;        /* text string associated with pix   */
  struct PixColormap  *colormap;    /* colormap (may be null)            */
  l_uint32            *data;        /* the image data                    */
};

while QImage offers me a method like this:

http://developer.qt.nokia.com/doc/qt-4.8/qimage.html#QImage-7

QImage ( const uchar * data, 
    int width, 
    int height, 
    int bytesPerLine, 
    Format format )

I assume I cant just copy the data from the PIX to the QImage when calling the constructor. I guess I need to fill the QImage Pixel by Pixel, but actually I dont know how? Do I need to loop through all the coordinates? How do I regard the bit depth? Any ideas here?

score 6 · Answer 1 · answered Apr 04 '12 at 21:27

I use this for conversion QImage to PIX:

PIX* TessTools::qImage2PIX(QImage& qImage) {
  PIX * pixs;
  l_uint32 *lines;

  qImage = qImage.rgbSwapped();
  int width = qImage.width();
  int height = qImage.height();
  int depth = qImage.depth();
  int wpl = qImage.bytesPerLine() / 4;

  pixs = pixCreate(width, height, depth);
  pixSetWpl(pixs, wpl);
  pixSetColormap(pixs, NULL);
  l_uint32 *datas = pixs->data;

  for (int y = 0; y < height; y++) {
    lines = datas + y * wpl;
    QByteArray a((const char*)qImage.scanLine(y), qImage.bytesPerLine());
    for (int j = 0; j < a.size(); j++) {
      *((l_uint8 *)lines + j) = a[j];
    }
  }
  return pixEndianByteSwapNew(pixs);
}

And this for conversion PIX to QImage:

QImage TessTools::PIX2QImage(PIX *pixImage) {
  int width = pixGetWidth(pixImage);
  int height = pixGetHeight(pixImage);
  int depth = pixGetDepth(pixImage);
  int bytesPerLine = pixGetWpl(pixImage) * 4;
  l_uint32 * s_data = pixGetData(pixEndianByteSwapNew(pixImage));

  QImage::Format format;
  if (depth == 1)
    format = QImage::Format_Mono;
  else if (depth == 8)
    format = QImage::Format_Indexed8;
  else
    format = QImage::Format_RGB32;

  QImage result((uchar*)s_data, width, height, bytesPerLine, format);

  // Handle pallete
  QVector<QRgb> _bwCT;
  _bwCT.append(qRgb(255,255,255));
  _bwCT.append(qRgb(0,0,0));

  QVector<QRgb> _grayscaleCT(256);
  for (int i = 0; i < 256; i++)  {
    _grayscaleCT.append(qRgb(i, i, i));
  }
  if (depth == 1) {
    result.setColorTable(_bwCT);
  }  else if (depth == 8)  {
    result.setColorTable(_grayscaleCT);

  } else {
    result.setColorTable(_grayscaleCT);
  }

  if (result.isNull()) {
    static QImage none(0,0,QImage::Format_Invalid);
    qDebug() << "***Invalid format!!!";
    return none;
  }

  return result.rgbSwapped();
}

score 2 · Answer 2 · edited Nov 27 '16 at 00:53

2

This code accepts a const QImage& parameter.

static PIX* makePIXFromQImage(const QImage &image)
{
 QByteArray ba;
 QBuffer buf(&ba);
 buf.open(QIODevice::WriteOnly);
 image.save(&buf, "BMP");
 return pixReadMemBmp(ba.constData(), ba.size());
}

edited Nov 27 '16 at 00:53

zx485

28,498
28
50
59

answered Nov 27 '16 at 00:36

Adam

21
1

score 1 · Answer 3 · answered Dec 28 '11 at 12:33

1

I do not know the Leptonica Library, but I had a short look at the documentation and found the documentation about the PIX structure. You can create a QImage from the raw data and convert this to a QPixmap with convertFromImage.

answered Dec 28 '11 at 12:33

hmuelner

8,093
1
28
39

Well thank you - I tried to work with this, but actually I'm a bit confused -> see update at my question – Toby Dec 28 '11 at 14:33
If you are lucky, you should be able to use Pix.data by casting it to an uchar*: reinterpret_cast(Pix.data). You have to adjust the Format parameter of the QImage constructor (try QImage::Format_RGB32 or QImage::Format_ARGB32). If you are unlucky you have to create a new buffer of size PIX.wpl * h first and copy the pixel values byte by byte by reading an l_uint32 from PIX.data and splitting them into four bytes (for R,G,B,A) by masking and shifting. – hmuelner Dec 28 '11 at 18:30
Ha okay I got it - did it a little different ( since there was a function which could do the deal ) - But still, without you advising me using QImage before using QPixmap I maybe wouldnt have found it! – Toby Dec 29 '11 at 08:37

score 1 · Accepted Answer · answered Dec 29 '11 at 09:01

Well I could solve the problem this way:

Leptonica offers a function

l_int32     pixWriteMemBmp (l_uint8 **pdata, size_t *psize, PIX *pix)

With this function you can write into the memory instead of a filestream. Still ( in this example ) the Bmp Header and format persists ( there are the same functions for other image formats too ).

The corresponding function from QT is this one:

bool QImage::loadFromData ( const uchar * data, int len, const char * format = 0 )

Since the the Header persits I just need to pass the data ptr and the size to the loadFromData function and QT does the rest.

So all together it would be like this:

PIX *m_pix;
FILE * pFile;
pFile = fopen( "PathToFile", "r" );
m_pix = pixReadStreamBmp(pFile); // If other file format use the according function
fclose(pFile);
// Now we have a Pix object from leptonica

l_uint8* ptr_memory;
size_t len;
pixWriteMemBmp(&ptr_memory, &size, m_pix);
// Now we have the picture somewhere in the memory

QImage testimage;
QPixmap pixmap;
testimage.loadFromData((uchar *)ptr_memory,len);
pixmap.convertFromImage(testimage);
// Now we have the image as a pixmap in Qt

This actually works for me, tho I don't know if there is a way to do this backwards so easy. ( If there is, please let me know )

Best Regards

score 0 · Answer 5 · answered May 23 '14 at 12:17

0

You can save your pixmap to RAM instead of file (use QByteArray to store the data, and QBuffer as your I/O device).

answered May 23 '14 at 12:17

Kirill Gamazkov

3,277
1
18
22

Convert Leptonica Pix Object to QPixmap ( or other image object )

5 Answers5

Linked