将opencv矩阵放入共享内存

我想在两个linux进程之间共享一个CvMat对象（OpenCV库中的一个矩阵），因为我使用的是共享内存。一个进程（服务器）将从网络摄像头捕获一帧（矩阵），将其转换为灰度，使用共享内存共享，并在屏幕上显示该帧。另一个进程（客户端）将读取共享帧并执行一些操作。请参阅下面的代码

问题似乎在于，由于“rows”和“cols”为零（或者服务器没有在共享内存中写入），客户机没有读取信息。无论如何，我没有收到任何错误信息，我不知道我做错了什么。有什么想法吗

多谢各位

---

以下是服务器的代码：

#include <iostream>
#include <cv.h>
#include <highgui.h>
using namespace std;

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

#include "2cam.h"

int sizeofmat(CvMat *mat) {
    return mat->rows * mat->cols * CV_ELEM_SIZE(mat->type);
}

int main() {
    int shmid;
    key_t key = 5678;

    CvMat *vdisp = cvCreateMat(240, 320, CV_8U);
    const size_t vdispsize = sizeofmat(vdisp);
    CvMat *s = cvCreateMat(240, 320, CV_8U);
    CvMat stub;
    CvSize imageSize = cvSize(320, 240);

    IplImage *color = cvCreateImage(imageSize, 8, 3);
    IplImage *gray = cvCreateImage(imageSize, 8, 1);

    /* Create the segment */
    if ((shmid = shmget(key, vdispsize, IPC_CREAT | 0666)) < 0) {
        perror("shmget");
        exit(1);
    }

    /* Attach the segment to our data space */
    if ((vdisp = (CvMat *)shmat(shmid, NULL, 0)) == (CvMat *)-1) {
        perror("shmat");
        exit(1);
    }

    /* Put CvMat into the memory to be read for other processes */
    s = vdisp;

    /* Create camera */
    Camera c("/dev/video0", 320, 240, 30);

    while (1) {
        /* Get one frame */
        c.Update();
        c.toIplImage(color);

        /* Convert color frame to grayscale */
        cvCvtColor(color, gray, CV_BGR2GRAY);

        /* Get matrix from the gray frame and write the matrix in shared memory*/
        s = cvGetMat(gray, &stub, 0, 0);

        /* Show frame */
        cvNamedWindow("result", CV_WINDOW_AUTOSIZE);
        cvShowImage("result", s);

        /* Wait for escape key */
        if ((cvWaitKey(10) & 255) == 27)
            break;
    }

    /* free memory */
    cvDestroyWindow("result");
    cvReleaseImage(&color);
    cvReleaseImage(&gray);
    //cvReleaseMat(&vdisp);
    //cvReleaseMat(&s);

    return 0;
}  

#包括
#包括
#包括
使用名称空间std；
#包括
#包括
#包括
#包括
#包括“凌晨2点”
int sizeofmat（CvMat*mat）{
返回mat->rows*mat->cols*CV元素大小（mat->type）；
}
int main（）{
int shmid；
键=5678；
CvMat*vdisp=cvCreateMat（240、320、CV_8U）；
const size\u t vdispsize=sizeofmat（vdisp）；
CvMat*s=cvCreateMat（240320，CV_8U）；
CvMat存根；
CvSize imageSize=CvSize（320240）；
IplImage*color=cvCreateImage（imageSize，8,3）；
IplImage*gray=cvCreateImage（imageSize，8,1）；
/*创建段*/
如果（（shmid=shmget（键，vdispsize，IPC|U CREAT | 0666））<0）{
佩罗尔（“shmget”）；
出口（1）；
}
/*将数据段附加到我们的数据空间*/
如果（（vdisp=（CvMat*）shmat（shmid，NULL，0））==（CvMat*）-1）{
佩罗尔（“shmat”）；
出口（1）；
}
/*将CvMat放入内存，以便为其他进程读取*/
s=vdisp；
/*创建摄影机*/
摄像机c（“/dev/video0”、320、240、30）；
而(1){
/*得到一帧*/
c、 更新（）；
c、 toIplImage（彩色）；
/*将色框转换为灰度*/
CVT颜色（颜色、灰色、CV_bgr2灰色）；
/*从灰色框架中获取矩阵，并将矩阵写入共享内存*/
s=cvGetMat（灰色和存根，0,0）；
/*展示架*/
cvNamedWindow（“结果”，CV_窗口_自动调整大小）；
cvShowImage（“结果”，s）；
/*等待逃生钥匙*/
如果（（cvWaitKey（10）&255）==27）
打破
}
/*空闲内存*/
“结果”；
cvReleaseImage（图像和颜色）；
cvReleaseImage（&灰色）；
//cvReleaseMat（和vdisp）；
//cvReleaseMat&s；
返回0；
}  

---

这里是客户代码：

#include <iostream>
#include <cv.h>
#include <highgui.h>
using namespace std;

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

int sizeofmat(CvMat *mat) {
    return mat->rows * mat->cols * CV_ELEM_SIZE(mat->type);
}

int main() {
    int shmid;
    key_t key = 5678;

    CvMat *vdisp = cvCreateMat(240, 320, CV_8U);
    const size_t vdispsize = sizeofmat(vdisp);
    CvMat *s = cvCreateMat(240, 320, CV_8U);

    /* Locate the segment */
    if ((shmid = shmget(key, vdispsize, 0666)) < 0) {
        perror("shmget");
        exit(1);
    }

    /* Now we attach the segment to our data space */
    if ((vdisp = (CvMat *)shmat(shmid, NULL, 0)) == (CvMat *) -1) {
        perror("shmat");
        exit(1);
    }

    s = vdisp;

    cout << "rows: " << s->rows << endl;
    cout << "cols: " << s->cols << endl;

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
#包括
#包括
#包括
#包括
int sizeofmat（CvMat*mat）{
返回mat->rows*mat->cols*CV元素大小（mat->type）；
}
int main（）{
int shmid；
键=5678；
CvMat*vdisp=cvCreateMat（240、320、CV_8U）；
const size\u t vdispsize=sizeofmat（vdisp）；
CvMat*s=cvCreateMat（240320，CV_8U）；
/*定位该段*/
如果（（shmid=shmget（键，vdispsize，0666））<0）{
佩罗尔（“shmget”）；
出口（1）；
}
/*现在，我们将该段附加到数据空间*/
如果（（vdisp=（CvMat*）shmat（shmid，NULL，0））==（CvMat*）-1）{
佩罗尔（“shmat”）；
出口（1）；
}
s=vdisp；
多亏了拉斯曼，他为我指明了正确的方向。无论如何，我回答了自己的问题，以防万一有人需要同样的解决方案


这是服务器的代码：

#include <iostream>
#include <cv.h>
#include <highgui.h>
using namespace std;

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

#include "2cam.h"

int sizeofmat(CvMat *mat) {
    return mat->rows * mat->step;
}

int main() {
    int shmid;
    key_t key = 5678;

    uchar *vdisp;
    CvMat *s = cvCreateMat(240, 320, CV_8U);
    CvMat *tmp = cvCreateMat(240, 320, CV_8U);
    const size_t vdispsize = sizeofmat(s);
    CvMat stub;
    CvSize imageSize = cvSize(320, 240);

    IplImage *color = cvCreateImage(imageSize, 8, 3);
    IplImage *gray = cvCreateImage(imageSize, 8, 1);

    /* Create the segment */
    if ((shmid = shmget(key, vdispsize, IPC_CREAT | 0666)) < 0) {
        perror("shmget");
        exit(1);
    }

    /* Attach the segment to our data space */
    if ((vdisp = (uchar *) shmat(shmid, NULL, 0)) == (uchar *) -1) {
        perror("shmat");
        exit(1);
    }

    s->data.ptr = vdisp;

    /* Create camera */
    Camera c("/dev/video0", 320, 240, 30);

    while (1) {
        /* Get one frame */
        c.Update();
        c.toIplImage(color);

        /* Convert color frame to grayscale */
        cvCvtColor(color, gray, CV_BGR2GRAY);

        /* Get matrix from the gray frame and write the matrix in shared memory*/
        tmp = cvGetMat(gray, &stub, 0, 0);

        for (int row = 0; row < tmp->rows; row++) {
            const uchar* ptr = (const uchar*) (tmp->data.ptr + row * tmp->step);
            memcpy((uchar*)(s->data.ptr + row * s->step), ptr, tmp->step);
        }

        /* Show frame */
        cvNamedWindow("result", CV_WINDOW_AUTOSIZE);
        cvShowImage("result", s);

        /* Wait for escape key */
        if ((cvWaitKey(10) & 255) == 27)
            break;
    }

    /* free memory */
    cvDestroyWindow("result");
    cvReleaseImage(&color);
    cvReleaseImage(&gray);

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
#包括
#包括
#包括
#包括
#包括“凌晨2点”
int sizeofmat（CvMat*mat）{
返回垫->行*垫->步；
}
int main（）{
int shmid；
键=5678；
uchar*vdisp；
CvMat*s=cvCreateMat（240320，CV_8U）；
CvMat*tmp=cvCreateMat（240320，CV_8U）；
const size\u t vdispsize=sizeofmat；
CvMat存根；
CvSize imageSize=CvSize（320240）；
IplImage*color=cvCreateImage（imageSize，8,3）；
IplImage*gray=cvCreateImage（imageSize，8,1）；
/*创建段*/
如果（（shmid=shmget（键，vdispsize，IPC|U CREAT | 0666））<0）{
佩罗尔（“shmget”）；
出口（1）；
}
/*将数据段附加到我们的数据空间*/
if（（vdisp=（uchar*）shmat（shmid，NULL，0））==（uchar*）-1）{
佩罗尔（“shmat”）；
出口（1）；
}
s->data.ptr=vdisp；
/*创建摄影机*/
摄像机c（“/dev/video0”、320、240、30）；
而(1){
/*得到一帧*/
c、 更新（）；
c、 toIplImage（彩色）；
/*将色框转换为灰度*/
CVT颜色（颜色、灰色、CV_bgr2灰色）；
/*从灰色框架中获取矩阵，并将矩阵写入共享内存*/
tmp=cvGetMat（灰色和存根，0,0）；
对于（int row=0；rowrows；row++）{
常量uchar*ptr=（常量uchar*）（tmp->data.ptr+行*tmp->step）；
memcpy（（uchar*）（s->data.ptr+行*s->step）、ptr、tmp->step）；
}
/*展示架*/
cvNamedWindow（“结果”，CV_窗口_自动调整大小）；
cvShowImage（“结果”，s）；
/*等待逃生钥匙*/
如果（（cvWaitKey（10）&255）==27）
打破
}
/*空闲内存*/
“结果”；
cvReleaseImage（图像和颜色）；
cvReleaseImage（&灰色）；
返回0；
}

以下是客户代码：

#include <iostream>
#include <cv.h>
#include <highgui.h>
using namespace std;

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>

int sizeofmat(CvMat *mat) {
    return mat->rows * mat->step;
}

int main() {
    int shmid;
    key_t key = 5678;

    uchar *vdisp;
    CvMat *s = cvCreateMat(240, 320, CV_8U);
    const size_t vdispsize = sizeofmat(s);

    /* Locate the segment */
    if ((shmid = shmget(key, vdispsize, 0666)) < 0) {
        perror("shmget");
        exit(1);
    }

    /* Now we attach the segment to our data space */
    if ((vdisp = (uchar *)shmat(shmid, NULL, 0)) == (uchar *) -1) {
        perror("shmat");
        exit(1);
    }

    s->data.ptr = vdisp;

    cvNamedWindow("result", CV_WINDOW_AUTOSIZE);
    cvShowImage("result", s);

    cvWaitKey(10000);

    cvDestroyWindow("result");

    return 0;
}

#包括
#包括
#包括
使用名称空间std；
#包括
#包括
#包括
#包括
int sizeofmat（CvMat*mat）{
返回垫->行*垫->步；
}
int main（）{
int shmid；
键=5678；
uchar*vdisp；
CvMat*s=cvCreateMat（240320，CV_8U）；
const size\u t vdispsize=sizeofmat；
/*定位该段*/
如果（（shmid=shmget（键，vdispsize，0666））<0）{
佩罗尔（“shmget”）；
出口（1）；
}
/*现在，我们将该段附加到数据空间*/
if（（vdisp=（uchar*）shmat（shmid，NULL，0））==（uchar*）-1）{
佩罗尔（“shmat”）；
出口（1）；
}
s->data.ptr=vdisp；
cvNamedWindow（“结果”，CV_窗口_自动调整大小）；
cvShowImage（“结果”，s）；
cvWaitKey（10000）；
个人简历
if(argv[1] = SERVER){

  struct shm_remove{
    shm_remove() {shared_memory_object::remove("SharedMemoryForCvMat"); }
    ~shm_remove(){shared_memory_object::remove("SharedMemoryForCvMat"); }
  }remover;

  shared_memory_object shm (create_only,"SharedMemoryForCvMat",read_write);
  shm.truncate(widht*height*channel);
  mapped_region region(shm, read_write);

  cv::VideoCapture cap(0);
  cv::Mat frame;

  while(everything_is_ok_for_server){
    cap >> frame;
    memcpy(region.get_address(), frame.data, width*height*channel);   
  }
}

else if(argv[1] == CLIENT){

    shared_memory_object shm (open_only, "SharedMemoryForCvMat", read_only);
    mapped_region region(shm, read_only);

    while(everything_is_ok_for_client){

        cv::Mat frame(cv::Size(width, height),
                      CV_8UC3,
                      region.get_address(),
                      cv::Mat::AUTO_STEP);
        cv::imshow("unimportant_string",frame);
        cv::waitKey(2);
    }
}