C++ Video::getWidth方法代码示例

/* The computational routine */
void knnfield(const mwSize *dimsA, const mwSize *dimsB, nnf_data_t* videoA, nnf_data_t* videoB, NNFieldParams params, int32_t *outMatrix, nnf_data_t * distMatrix)
{
    Video<nnf_data_t> A;
    int dA[4];
    for (int i = 0; i < 4; ++i) {
        dA[i] = dimsA[i];
    }
    A.initFromMxArray(4, dA, videoA);

    Video<nnf_data_t> B;
    int dB[4];
    for (int i = 0; i < 4; ++i) {
        dB[i] = dimsB[i];
    }
    B.initFromMxArray(4, dB, videoB);

    NNField field(&A,&B, params);
    NNFieldOutput output = field.compute();
    Video<int32_t> &nnf  = output.nnf;
    Video<nnf_data_t> &cost  = output.error;

    const int32_t* pData = nnf.dataReader();
    const nnf_data_t* pCost = cost.dataReader();

    int channel_stride = nnf.voxelCount();
    int in_nn_stride   = 3*channel_stride;
    int out_nn_stride  = 3*channel_stride;


    for (unsigned int idx = 0; idx < dimsA[0]*dimsA[1]*dimsA[2]; ++idx) // each voxel
    {
        for(int k = 0; k < params.knn; ++ k) { // each NN
            for (unsigned int c = 0; c < 3; ++c) { // each warp channel
                outMatrix[idx + c*channel_stride + k*out_nn_stride] = pData[idx + c*channel_stride + k*in_nn_stride];
            }
            assert(outMatrix[idx + 0*channel_stride + k*out_nn_stride] < B.getWidth()-params.patch_size_space+1);
            assert(outMatrix[idx + 1*channel_stride + k*out_nn_stride] < B.getHeight()-params.patch_size_space+1);
            assert(outMatrix[idx + 2*channel_stride + k*out_nn_stride] < B.frameCount()-params.patch_size_time+1);
        }
    }

    if(distMatrix != nullptr) {
        for (unsigned int idx = 0; idx < dimsA[0]*dimsA[1]*dimsA[2]; ++idx) // each voxel
        {
            for(int k = 0; k < params.knn; ++ k) { // each NN
                distMatrix[idx + k*channel_stride] = pCost[idx + k*channel_stride];
            }
        }
    }
}

void mexFunction(
    int          nlhs,
    mxArray*      plhs[],
    int          nrhs,
    const mxArray* prhs[]
) {

    char* filename;
    int first_frame, last_frame;
    bool color;
    parse_arguments(nlhs, prhs, nrhs, &filename, &first_frame, &last_frame, &color);

    Video* video = NULL;

    if (first_frame < 0) {
        std::cout << "reading all video!" << std::endl;
        video = new Video(filename);
        first_frame = 1;
        last_frame = video->frames;//frames counted by grabbing all frames in video
    } else {
        std::cout << "reading frames: " << first_frame << "-" << last_frame << std::endl;
        video = new Video(filename, last_frame - first_frame);
    }



    int n_of_dims, channels;
    mwSize* dims;
    if (!color) {
        n_of_dims = 3;
        channels = 1;
        dims = new mwSize[3];
        dims[1] = video->getWidth();
        dims[0] = video->getHeight();
        dims[2] = last_frame - first_frame + 1 ;
    } else {
        n_of_dims = 4;
        channels = 3;
        dims = new mwSize[4];
        dims[1] = video->getWidth();
        dims[0] = video->getHeight();
        dims[3] = last_frame - first_frame + 1 ;
        dims[2] = 3;
    }
    IplImage* img = 0;

    //create 3 dimensional storage and assign it to output arguments
    plhs[0] = mxCreateNumericArray(n_of_dims, dims , mxUINT8_CLASS, mxREAL);
    //get pointer to data (cast necessary since data is not double, mxGetData returns a void*)
    unsigned char* video_ptr = (unsigned char*)mxGetData(plhs[0]);


    //frame counter
    int f = 0;
    //we skip frames until f == first_frame (we want to grab from here)
    //and we stop grabbing after f == last_frame
    while ((img = video->getNextFrame()) && f < last_frame) {
        ++f;
        //check if we are in the correct range (following annotation)
        if (f >= first_frame) { // && f <= last_frame ... no need to check this after last_frame we grab the last one
            video->convertFrame(video_ptr, img, color);
            //move pointer ahead one frame
            video_ptr += video->getHeight() * video->getWidth() * channels;
        }
    }
    mxFree(filename);
    return;
}