Запись cv::Mat в БД MySQL

cv::Mat ImageAnalyzer::GetDescriptors(cv::Mat InputImage)
{
    qWarning () << "Call Get Descriptors function";
 
    cv::Mat ImageEnchanced = ImagePrepare(InputImage);
    ImageEnchanced.convertTo(ImageEnchanced, CV_32SC1);
    RemoveHoles(50, ImageEnchanced);
    ImageEnchanced.convertTo(ImageEnchanced, CV_8UC1);
 
    cv::imwrite("/home/ortech/Desktop/TestFingerprintData/BinaryNoHoles.png",
            ImageEnchanced);
 
    //********************************************************************************************************
    // Now lets detect the strong minutiae using Haris corner detection
    cv::Mat harris_corners, harris_normalised;
    harris_corners = cv::Mat::zeros(ImageEnchanced.size(), CV_32FC1);
    cornerHarris(ImageEnchanced, harris_corners, 3, 3, 0.04, cv::BORDER_DEFAULT);
    normalize(harris_corners, harris_normalised, 0, 255, cv::NORM_MINMAX, CV_32FC1, cv::Mat());
 
    // Select the strongest corners that you want
    int threshold_harris = 120;
    std::vector<cv::KeyPoint> keypoints;
 
    // Make a color clone for visualisation purposes
 
    cv::Mat rescaled;
    convertScaleAbs(harris_normalised, rescaled);
    cv::Mat harris_c(rescaled.rows, rescaled.cols, CV_8UC3);
    cv::Mat in[] = { rescaled, rescaled, rescaled };
    int from_to[] = { 0,0, 1,1, 2,2 };
    mixChannels( in, 3, &harris_c, 1, from_to, 3 );
    for(int x=0; x<harris_normalised.cols; x++)
    {
        for(int y=0; y<harris_normalised.rows; y++)
        {
            if ( (int)harris_normalised.at<float>(y, x) > threshold_harris )
            {
                circle(harris_c, cv::Point(x, y), 1, cv::Scalar(0,0,255), 1);
                keypoints.push_back( cv::KeyPoint (x, y, 1) );
            }
        }
    }
 
    cv::imwrite("/home/ortech/Desktop/TestFingerprintData/4_KeyPoints.png",
        harris_c);
 
    //********************************************************************************************************
    qWarning() << "Calculate the ORB descriptor based on the keypoint";
    cv::Ptr<cv::Feature2D> orb_descriptor = cv::ORB::create();
    cv::Mat descriptors;
    orb_descriptor->compute(ImageEnchanced, keypoints, descriptors);
    //qWarning() << "Calculated value: " << orb_descriptor;
 
    return descriptors;
 
}

QByteArray mat2ByteArray(const cv::Mat &image)
    {
        QByteArray byteArray;
        QDataStream stream( &byteArray, QIODevice::WriteOnly );
        stream << image.type();
        stream << image.rows;
        stream << image.cols;
        const size_t data_size = image.cols * image.rows * image.elemSize();
        QByteArray data = QByteArray::fromRawData( (const char*)image.ptr(), data_size );
        stream << data;
        return byteArray;
    }
 
    cv::Mat byteArray2Mat(const QByteArray & byteArray)
    {
        QDataStream stream(byteArray);
        int matType, rows, cols;
        QByteArray data;
        stream >> matType;
        stream >> rows;
        stream >> cols;
        stream >> data;
        cv::Mat mat( rows, cols, matType, (void*)data.data() );
        return mat.clone();
    }