void BleWindowsCaptureSource::run() { // TODO make could select screen // QGuiApplication::screens(); while (!m_stop) { QElapsedTimer elapsedTimer; elapsedTimer.start(); QScreen *screen = QGuiApplication::primaryScreen(); if (screen) { QPixmap pixmap = screen->grabWindow(m_wid, m_x, m_y, m_width, m_height); #if 1 // TODO to draw cursor to image QRect desktopRect = QRect(QPoint(0, 0), screen->size()); if (desktopRect.contains(QCursor::pos())) { drawCursor(&pixmap); } #endif QImage image = pixmap.toImage(); m_modifyMutex.lock(); // Start lock BleImage be; be.width = image.width(); be.height = image.height(); int imageSize = be.width * be.height * 3; be.data = new char[imageSize]; IplImage *oriImage = cvCreateImageHeader(cvSize(image.width(), image.height()), IPL_DEPTH_8U, 4); cvSetData(oriImage, image.bits(), image.bytesPerLine()); IplImage *dstImage = cvCreateImageHeader(cvSize(image.width(), image.height()), IPL_DEPTH_8U, 3); cvSetData(dstImage, be.data, be.width * 3); cvCvtColor(oriImage, dstImage, CV_BGRA2BGR); be.dataSize = imageSize; be.format = BleImage_Format_BGR24; m_image = be; cvReleaseImageHeader(&oriImage); cvReleaseImageHeader(&dstImage); m_modifyMutex.unlock(); // End unlock } int elapsedMs = elapsedTimer.elapsed(); int needSleepMs = m_interval - elapsedMs; if (needSleepMs < 0) { needSleepMs = 0; } msleep(needSleepMs); } log_trace("BleWindowsCaptureSource exit normally."); }
CLIFIntegralResult clifGrayscaleIntegral(const IplImage* source, CLIFEnvironmentData* data, const cl_bool use_opencl) { CLIFIntegralResult ret; if(!use_opencl) { IplImage* grayscale = cvCreateImage(cvSize(source->width, source->height), IPL_DEPTH_8U, 1); cvCvtColor(source, grayscale, CV_BGR2GRAY); ret.image = cvCreateMat(source->height + 1, source->width + 1, CV_32SC1); ret.square_image = cvCreateMat(source->height + 1, source->width + 1, CV_64FC1); cvIntegral(grayscale, ret.image, ret.square_image); cvReleaseImage(&grayscale); return ret; } cl_int error = CL_SUCCESS; // Init buffer error = clEnqueueWriteBuffer(data->environment.queue, data->bgr_to_gray_data.buffers[0], CL_FALSE, 0, source->widthStep * source->height, source->imageData, 0, NULL, NULL); clCheckOrExit(error); // Run kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[0], 2, NULL, data->bgr_to_gray_data.global_size, data->bgr_to_gray_data.local_size, 0, NULL, NULL); clCheckOrExit(error); // Set as arg the output of greyscale clSetKernelArg(data->environment.kernels[1], 0, sizeof(cl_mem), &(data->bgr_to_gray_data.buffers[1])); clCheckOrExit(error); // Run sum rows kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[1], 1, NULL, &(data->integral_image_data.global_size[0]), &(data->integral_image_data.local_size[0]), 0, NULL, NULL); clCheckOrExit(error); // Run sum cols kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[2], 1, NULL, &(data->integral_image_data.global_size[1]), &(data->integral_image_data.local_size[1]), 0, NULL, NULL); clCheckOrExit(error); // Read result cl_uint* result = (cl_uint*)clEnqueueMapBuffer(data->environment.queue, data->integral_image_data.buffers[3], CL_TRUE, CL_MAP_READ, 0, (source->width + 1) * (source->height + 1) * sizeof(cl_uint), 0, NULL, NULL, &error); clCheckOrExit(error); cl_ulong* square_result = (cl_ulong*)clEnqueueMapBuffer(data->environment.queue, data->integral_image_data.buffers[4], CL_TRUE, CL_MAP_READ, 0, (source->width + 1) * (source->height + 1) * sizeof(cl_ulong), 0, NULL, NULL, &error); clCheckOrExit(error); data->integral_image_data.ptr = result; // Return ret.image = cvCreateMatHeader(source->height + 1, source->width + 1, CV_32SC1); cvSetData(ret.image, result, source->width + 1); ret.square_image = cvCreateMatHeader(source->height + 1, source->width + 1, CV_64FC1); cvSetData(ret.square_image, square_result, source->width + 1); return ret; }
void BleImageProcess::paintEvent(QPaintEvent *event) { Q_UNUSED(event); QPainter p(this); p.setRenderHint(QPainter::SmoothPixmapTransform); // back ground p.fillRect(rect(), QBrush(QColor(48, 48, 48))); // element draw for (int i = 0; i < m_sources.size(); ++i) { const SourcePair & pair = m_sources.at(i); BleSourceAbstract *s = pair.source; // TODO image data may be used by other thread BleImage image = s->getImage(); if (image.dataSize <= 0) continue; QImage qimage; if (image.format == BleImage_Format_BGR24) { IplImage *oriImage = cvCreateImageHeader(cvSize(image.width, image.height), IPL_DEPTH_8U, 3); cvSetData(oriImage, image.data, image.width*3); IplImage *dstImage = cvCreateImageHeader(cvSize(image.width, image.height), IPL_DEPTH_8U, 3); cvSetData(dstImage, image.data, image.width*3); cvCvtColor(oriImage, dstImage, CV_BGR2RGB); cvReleaseImageHeader(&oriImage); cvReleaseImageHeader(&dstImage); } qimage = QImage((uchar*)image.data, image.width, image.height, QImage::Format_RGB888); p.drawPixmap(pair.rect, QPixmap::fromImage(qimage)); // p.drawImage(pair.rect, qimage); } if (m_activePair && m_activePair->rect.isValid()) { QPen pen(Qt::SolidLine); pen.setColor(Qt::white); pen.setWidth(2); pen.setStyle(Qt::DotLine); p.setPen(pen); p.drawRect(m_activePair->rect); QRect topLeftRect(m_activePair->rect.x(), m_activePair->rect.y(), 8, 8); p.fillRect(topLeftRect, QBrush(Qt::red)); QRect bottomRightRect(m_activePair->rect.bottomRight().x(), m_activePair->rect.bottomRight().y(), -8, -8); p.fillRect(bottomRightRect, QBrush(Qt::red)); } }
void ofxImageROI::projectToTarget(ofPoint *dstPoints) { CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; cvsrc[0].x = cornerPoints[0].x; cvsrc[0].y = cornerPoints[0].y; cvsrc[1].x = cornerPoints[1].x; cvsrc[1].y = cornerPoints[1].y; cvsrc[2].x = cornerPoints[2].x; cvsrc[2].y = cornerPoints[2].y; cvsrc[3].x = cornerPoints[3].x; cvsrc[3].y = cornerPoints[3].y; cvdst[0].x = dstPoints[0].x; cvdst[0].y = dstPoints[0].y; cvdst[1].x = dstPoints[1].x; cvdst[1].y = dstPoints[1].y; cvdst[2].x = dstPoints[2].x; cvdst[2].y = dstPoints[2].y; cvdst[3].x = dstPoints[3].x; cvdst[3].y = dstPoints[3].y; CvMat* src_mat = cvCreateMat(4, 2, CV_32FC1); CvMat* dst_mat = cvCreateMat(4, 2, CV_32FC1); cvSetData(src_mat, cvsrc, sizeof(CvPoint2D32f)); cvSetData(dst_mat, cvdst, sizeof(CvPoint2D32f)); CvMat * translate = cvCreateMat(3,3,CV_32FC1); // 領域確保 cvFindHomography(src_mat, dst_mat, translate); // ホモグラフィ計算 // 画像サイズが変わったとき if (this->bAllocated() == true && inputImg.bAllocated == false) { projectedImage.allocate(this->width, this->height, OF_IMAGE_COLOR); inputImg.allocate(this->width, this->height); outputImg.allocate(this->width, this->height); } inputImg.setFromPixels(this->getPixelsRef()); // 画像のロード cvWarpPerspective(inputImg.getCvImage(), outputImg.getCvImage(), translate, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(255)); // 透視投影変換 //出力結果をofImageに変換 projectedImage.setFromPixels(outputImg.getPixels(), outputImg.getWidth(), outputImg.getHeight(), OF_IMAGE_COLOR); cvReleaseMat(&translate); cvReleaseMat(&src_mat); cvReleaseMat(&dst_mat); }
static CvSpillTree* icvCreateSpillTree( const CvMat* raw_data, const int naive, const double rho, const double tau ) { int n = raw_data->rows; int d = raw_data->cols; CvSpillTree* tr = (CvSpillTree*)cvAlloc( sizeof(CvSpillTree) ); tr->root = (CvSpillTreeNode*)cvAlloc( sizeof(CvSpillTreeNode) ); memset(tr->root, 0, sizeof(CvSpillTreeNode)); tr->refmat = (CvMat**)cvAlloc( sizeof(CvMat*)*n ); tr->total = n; tr->naive = naive; tr->rho = rho; tr->tau = tau; tr->type = raw_data->type; // tie a link-list to the root node tr->root->lc = (CvSpillTreeNode*)cvAlloc( sizeof(CvSpillTreeNode) ); memset(tr->root->lc, 0, sizeof(CvSpillTreeNode)); tr->root->lc->center = cvCreateMatHeader( 1, d, tr->type ); cvSetData( tr->root->lc->center, _dispatch_mat_ptr(raw_data, 0), raw_data->step ); tr->refmat[0] = tr->root->lc->center; tr->root->lc->lc = NULL; tr->root->lc->leaf = true; tr->root->lc->i = 0; CvSpillTreeNode* node = tr->root->lc; for ( int i = 1; i < n; i++ ) { CvSpillTreeNode* newnode = (CvSpillTreeNode*)cvAlloc( sizeof(CvSpillTreeNode) ); memset(newnode, 0, sizeof(CvSpillTreeNode)); newnode->center = cvCreateMatHeader( 1, d, tr->type ); cvSetData( newnode->center, _dispatch_mat_ptr(raw_data, i*d), raw_data->step ); tr->refmat[i] = newnode->center; newnode->lc = node; newnode->i = i; newnode->leaf = true; newnode->rc = NULL; node->rc = newnode; node = newnode; } tr->root->rc = node; tr->root->cc = n; icvDFSInitSpillTreeNode( tr, d, tr->root ); return tr; }
void showInputLayer2DImage(LayerStack* stack){ //printf("show image\n"); int scale = 10; CvMat* image; int width = sqrt(stack->layerSizes[0]); image =cvCreateMat(width*scale,width*scale,CV_8UC1); //upscaled =cvCreateMat(width*scale,width*scale,CV_8UC1); unsigned char* data = malloc((width*width*scale*scale)*sizeof(unsigned char)); assert(data!=NULL); for(int i=0;i<width*scale;i++){ for(int j=0;j<width*scale;j++){ //printf("to %d from %d\n",i*width*scale+j,(i/scale)*width+j/scale); data[i*width*scale+j] = 255-(stack->layers[0][(i/scale)*width+j/scale]*255); //printf("neuron: %.3f, pixel: %d \n",stack->stack[0]->neurons[i],data[i]); } } cvSetData(image,data,width*scale); cvNamedWindow("NeuroOutput",CV_WINDOW_AUTOSIZE); cvShowImage("NeuroOutput",image); cvWaitKey(0); cvReleaseMat(&image); free(data); //cvReleaseMat(&upscaled); }
IplImage* CvCaptureCAM_Aravis::retrieveFrame(int) { if(framebuffer) { int depth = 0, channels = 0; switch(pixelFormat) { case ARV_PIXEL_FORMAT_MONO_8: depth = IPL_DEPTH_8U; channels = 1; break; case ARV_PIXEL_FORMAT_MONO_12: depth = IPL_DEPTH_16U; channels = 1; break; } if(depth && channels) { IplImage src; cvInitImageHeader( &src, cvSize( width, height ), depth, channels, IPL_ORIGIN_TL, 4 ); cvSetData( &src, framebuffer, src.widthStep ); if( !frame || frame->width != src.width || frame->height != src.height || frame->depth != src.depth || frame->nChannels != src.nChannels) { cvReleaseImage( &frame ); frame = cvCreateImage( cvGetSize(&src), src.depth, channels ); } cvCopy(&src, frame); return frame; } } return NULL; }
void ICVConsumer::consume (IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { cvSetData (_image_in, stream_in[0].ptr, _stride_in); consume (stream_in[0].sr, _image_in); }
// initialize CvMat header, allocated by the user CV_IMPL CvMat* cvInitMatHeader( CvMat* arr, int height, int width, int type, void* data, int step ) { CV_FUNCNAME( "cvInitMatHeader" ); __BEGIN__; if( !arr ) CV_ERROR_FROM_CODE( CV_StsNullPtr ); if( (unsigned)(CV_ARR_CN(type) - 1) >= CV_CN_MAX ) CV_ERROR_FROM_CODE( CV_BadDepth ); if( (unsigned)CV_ARR_DEPTH(type) > CV_DEPTH_MAX ) CV_ERROR_FROM_CODE( CV_BadNumChannels ); if( height <= 0 || width <= 0 ) CV_ERROR_FROM_CODE( CV_StsBadSize ); arr->type = (type & CV_ARR_TYPE_MASK) | CV_ARR_MAGIC_VAL; arr->height = height; arr->width = width; CV_CALL( cvSetData( arr, data, step )); __END__; return arr; }
IplImage* CvCaptureAVI_VFW::retrieveFrame(int) { if( avistream && bmih ) { bool isColor = bmih->biBitCount == 24; int nChannels = (isColor) ? 3 : 1; IplImage src; cvInitImageHeader( &src, cvSize( bmih->biWidth, bmih->biHeight ), IPL_DEPTH_8U, nChannels, IPL_ORIGIN_BL, 4 ); char* dataPtr = (char*)(bmih + 1); // Only account for the color map size if we are an 8-bit image and the color map is used if (!isColor) { static int RGBQUAD_SIZE_PER_BYTE = sizeof(RGBQUAD)/sizeof(BYTE); int offsetFromColormapToData = (int)bmih->biClrUsed*RGBQUAD_SIZE_PER_BYTE; dataPtr += offsetFromColormapToData; } cvSetData( &src, dataPtr, src.widthStep ); if( !frame || frame->width != src.width || frame->height != src.height ) { cvReleaseImage( &frame ); frame = cvCreateImage( cvGetSize(&src), 8, nChannels ); } cvFlip( &src, frame, 0 ); return frame; } return 0; }
/******************将图片缩小至640*512方便显示***********************/ void CMainFrame::Resize() { CvSize cvSize; cvSize.width = Width; cvSize.height = Height; //生成支持OPENCV的IPLIMAGE数据结构,并使用相机采集的图像数据初始化 IplImage *iplImage = cvCreateImageHeader(cvSize,IPL_DEPTH_8U,3); cvSetData(iplImage,m_pImageBuffer,Width*3); CvSize my_cvSize; //新图片尺寸 my_cvSize.width = Width/2; my_cvSize.height = Height/2; IplImage *iplgraytemp = cvCreateImage(my_cvSize,IPL_DEPTH_8U,3); //新图片矩阵 cvResize(iplImage,iplgraytemp,CV_INTER_NN); //从LPLIMAGE数据结构中提取图像数据 memcpy(DisplayBuffer,(BYTE*)iplgraytemp->imageData,Height/2*Width/2*3); //释放申请的图象空间 cvReleaseImage(&iplgraytemp); }
static IplImage* icvRetrieveImage( void* obj ) { IplImage* img = 0; if( CV_IS_IMAGE(obj) ) img = (IplImage*)obj; else if( CV_IS_MAT(obj) ) { CvMat* m = (CvMat*)obj; img = cvCreateImageHeader( cvSize(m->cols,m->rows), CV_MAT_DEPTH(m->type), CV_MAT_CN(m->type) ); cvSetData( img, m->data.ptr, m->step ); img->imageDataOrigin = (char*)m->refcount; m->data.ptr = 0; m->step = 0; cvReleaseMat( &m ); } else if( obj ) { cvRelease( &obj ); CV_Error( CV_StsUnsupportedFormat, "The object is neither an image, nor a matrix" ); } return img; }
PyObject *wrapped_People_detectAllFaces(PyObject *self, PyObject *args) { wrapped_People_t *pp = (wrapped_People_t*)self; // IplImage *image, const char* haar_classifier_filename, double threshold, IplImage *disparity_image, CvStereoCamModel *cam_model, bool do_draw) IplImage *input; char *haar_filename; double threshold; PyObject *disparity_image, *cam_model; int do_draw; { char *imgdata; int imgdata_size, x, y; if (!PyArg_ParseTuple(args, "s#iisdOOi", &imgdata, &imgdata_size, &x, &y, &haar_filename, &threshold, &disparity_image, &cam_model, &do_draw)) return NULL; input = cvCreateImageHeader(cvSize(x, y), IPL_DEPTH_8U, 1); cvSetData(input, imgdata, x); } vector<CvRect> faces_vector = pp->c.detectAllFaces(input, haar_filename, threshold, NULL, NULL, do_draw); PyObject *r = PyList_New(faces_vector.size()); for (size_t i = 0; i < faces_vector.size(); i++) PyList_SetItem(r, i, Py_BuildValue("iiii", faces_vector[i].x, faces_vector[i].y, faces_vector[i].width, faces_vector[i].height)); return r; }
void ofxCvBrightnessContrast::setBrightnessAndContrast(ofxCvImage& img, float brightnessAmount, float contrastAmount){ brightnessVal = MAX(-127, MIN(127, brightnessAmount)); contrastVal = MAX(-127, MIN(127, contrastAmount)); unsigned char data[ 256 ]; CvMat * matrix; double delta, a, b; matrix = cvCreateMatHeader( 1, 256, CV_8UC1 ); cvSetData( matrix, data, 0 ); if ( contrastVal>0 ) { delta = (127.0f*contrastVal) / 128.0f; a = 255.0f / ( 255.0f-(delta*2.0f) ); b = a * (brightnessVal-delta); } else { delta = (-128.0f*contrastVal) / 128.0f; a = ( 256.0f-(delta*2.0f) ) / 255.0f; b = ( a*brightnessVal )+delta; } for( int i=0; i<256; i++ ) { int value = cvRound( (a*i)+b ); data[i] = (unsigned char) min( max(0,value), 255 ); } cvLUT( img.getCvImage(), img.getCvImage(), matrix ); cvReleaseMat( &matrix ); }
void Filters::lowPass(VRFrame* frame, int size) { IplImage* imgDst = 0; IplImage* imgAux = 0; IplImage* imgNew = 0; VRFrame* frameAux; Log::writeLog("%s :: param: frame[%x] size[%d]", __FUNCTION__, frame, size); //Ajuste do tamanho da matriz. if (size > 9) size = 9; int cols_i = size; int rows_i = size; int total_size = 0; CvMat *filter = 0; total_size=(int)pow((double)size,2); // Máscara para realizar o processo de convolução. ///double convMask[total_size]; double * convMask = new double[total_size]; // Cria uma imagem com os mesmos parâmetros da original. frameAux = new VRFrame(frame); imgDst = VRFrame::imgAlloc(frameAux); imgAux = VRFrame::imgAlloc(frameAux); imgNew = VRFrame::imgAlloc(frameAux); // Monta a máscara com o tamanho que foi passado como parâmetro. for (int i=0; i<total_size; i++) convMask[i] = (double)1/(double)total_size; imgAux->imageData = frameAux->data->imageData; imgAux->widthStep = frameAux->data->width; imgDst->imageData = imgAux->imageData; imgDst->widthStep = imgAux->width; filter = cvCreateMatHeader(rows_i, cols_i, CV_64FC1); cvSetData(filter, convMask, cols_i*8); cvFilter2D(imgAux, imgDst, filter, cvPoint(-1,-1)); VRFrame::imgCopy(imgDst, imgNew); frame->setImage(imgNew); // Desaloca os temporários VRFrame::imgDealloc(imgAux); VRFrame::imgDealloc(imgDst); delete[] convMask; delete frameAux; }
void VideoFrame::ImageView(IplImage* view) const { ASSURE_LOG(view) << "View not set."; ASSERT_LOG(width_step_ % 4 == 0) << "IplImages need to have width_step_ " << "divisable by 4."; cvInitImageHeader(view, cvSize(width_, height_), IPL_DEPTH_8U, channels_); cvSetData(view, data_, width_step_); }
//-------------------------------------------------------------- ofImage ofxContrast::setBrightness(ofImage& _img, float brightnessAmount){ ofxCvColorImage cvimg; cvimg.allocate(_img.width, _img.height); cvimg.setFromPixels(_img.getPixels(), _img.width, _img.height); float brightnessVal = MAX(-127, MIN(127, brightnessAmount)); unsigned char data[ 256 ]; CvMat * matrix; matrix = cvCreateMatHeader( 1, 256, CV_8UC1 ); cvSetData( matrix, data, 0 ); for( int i=0; i<256; i++ ) { int value = cvRound( i+brightnessVal ); data[i] = (unsigned char) min( max(0,value), 255 ); } cvLUT( cvimg.getCvImage(), cvimg.getCvImage(), matrix ); cvReleaseMat( &matrix ); ofImage ofimg; ofimg.allocate(_img.width, _img.height, OF_IMAGE_COLOR); ofimg.setFromPixels(cvimg.getPixels(), _img.width, _img.height, OF_IMAGE_COLOR); return ofimg; }
// OpenCLIF computations CLIFGrayscaleResult clifGrayscale(const IplImage* source, CLIFEnvironmentData* data, const cl_bool use_opencl) { CLIFGrayscaleResult ret; if(!use_opencl) { ret.image = cvCreateImage(cvSize(source->width, source->height), IPL_DEPTH_8U, 1); cvCvtColor(source, ret.image, CV_BGR2GRAY); return ret; } cl_int error = CL_SUCCESS; // Init buffer error = clEnqueueWriteBuffer(data->environment.queue, data->bgr_to_gray_data.buffers[0], CL_FALSE, 0, source->widthStep * source->height, source->imageData, 0, NULL, NULL); clCheckOrExit(error); // Run kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[0], 2, NULL, data->bgr_to_gray_data.global_size, data->bgr_to_gray_data.local_size, 0, NULL, NULL); clCheckOrExit(error); // Read result cl_uchar* result = (cl_uchar*)clEnqueueMapBuffer(data->environment.queue, data->bgr_to_gray_data.buffers[1], CL_TRUE, CL_MAP_READ, 0, source->width * source->height, 0, NULL, NULL, &error); clCheckOrExit(error); // Return ret.image = cvCreateImageHeader(cvSize(source->width, source->height), IPL_DEPTH_8U, 1); cvSetData(ret.image, result, source->width); return ret; }
_IplImage cvIplImage(const cv::Mat& m) { _IplImage self; CV_Assert( m.dims <= 2 ); cvInitImageHeader(&self, cvSize(m.size()), cvIplDepth(m.flags), m.channels()); cvSetData(&self, m.data, (int)m.step[0]); return self; }
void rgb_cb(freenect_device *dev, freenect_pixel *rgb, uint32_t timestamp) { pthread_mutex_lock(&backbuf_mutex); got_frames++; cvSetData(rgbBack, rgb, 3*FREENECT_FRAME_W); pthread_cond_signal(&framesReady_cond); pthread_mutex_unlock(&backbuf_mutex); }
C_RESULT output_gtk_stage_transform( void *cfg, vp_api_io_data_t *in, vp_api_io_data_t *out) { uint64_t timeCode; struct timeval lastFrameReceptionTime; gettimeofday(&lastFrameReceptionTime, NULL); if (!videoServer_isStarted()) return SUCCESS; videoServer_lockFrameBuffer(); if(out->status == VP_API_STATUS_INIT) { out->numBuffers = 1; out->size = QVGA_WIDTH * QVGA_HEIGHT * 3; out->buffers = (int8_t **) vp_os_malloc (sizeof(int8_t *)+out->size*sizeof(int8_t)); out->buffers[0] = (int8_t *)(out->buffers+1); outputImageBuffer = out->buffers[0]; cvSetData(debugImage, outputImageBuffer, QVGA_WIDTH * 3); out->indexBuffer = 0; // out->lineSize not used out->status = VP_API_STATUS_PROCESSING; } if(out->status == VP_API_STATUS_PROCESSING && outputImageBuffer != NULL) { /* Get a reference to the last decoded picture */ pixbuf_data = (uint8_t*)in->buffers[0]; { int i; int8_t *outBuffer = outputImageBuffer; for (i = 0; i < QVGA_WIDTH * QVGA_HEIGHT * 3; i += 3) { outBuffer[i] = pixbuf_data[i + 2]; outBuffer[i + 1] = pixbuf_data[i + 1]; outBuffer[i + 2] = pixbuf_data[i]; } } timeCode = (uint64_t)lastFrameReceptionTime.tv_sec * 1e6 + (uint64_t)lastFrameReceptionTime.tv_usec; videoServer_feedFrame_BGR24(timeCode, outputImageBuffer); /* struct timeval currentTime; gettimeofday(¤tTime, NULL); double elapsed = (currentTime.tv_sec - lastFrameTime.tv_sec) + (currentTime.tv_usec - lastFrameTime.tv_usec) / 1e6; lastFrameTime = currentTime; PRINT("fps: %f\n", 1.0 / elapsed); */ #ifdef IMAGE_DEBUG cvShowImage("DroneCamera", debugImage); #endif } videoServer_unlockFrameBuffer(); return (SUCCESS); }
void showImage_1ch(UINT8T* p_1ch, const char* name) { // 显示单通道数据 cvSetData(image_1ch, p_1ch, C); cvNamedWindow(name, 0); cvShowImage(name, image_1ch); cvWaitKey(0); }
CLIFIntegralResult clifIntegral(const IplImage* source, CLIFEnvironmentData* data, const cl_bool use_opencl) { CLIFIntegralResult ret; if(!use_opencl) { ret.image = cvCreateMat(source->height + 1, source->width + 1, CV_32SC1); ret.square_image = cvCreateMat(source->height + 1, source->width + 1, CV_64FC1); cvIntegral(source, ret.image, ret.square_image); return ret; } cl_int error = CL_SUCCESS; // Init buffer error = clEnqueueWriteBuffer(data->environment.queue, data->integral_image_data.buffers[0], CL_FALSE, 0, source->width * source->height, source, 0, NULL, NULL); clCheckOrExit(error); // Run sum rows kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[1], 1, NULL, &(data->integral_image_data.global_size[0]), &(data->integral_image_data.local_size[0]), 0, NULL, NULL); clCheckOrExit(error); // Run sum cols kernel error = clEnqueueNDRangeKernel(data->environment.queue, data->environment.kernels[2], 1, NULL, &(data->integral_image_data.global_size[1]), &(data->integral_image_data.local_size[1]), 0, NULL, NULL); clCheckOrExit(error); // Read result cl_uint* result = (cl_uint*)clEnqueueMapBuffer(data->environment.queue, data->integral_image_data.buffers[3], CL_TRUE, CL_MAP_READ, 0, (source->width + 1) * (source->height + 1) * sizeof(cl_uint), 0, NULL, NULL, &error); clCheckOrExit(error); cl_ulong* square_result = (cl_ulong*)clEnqueueMapBuffer(data->environment.queue, data->integral_image_data.buffers[4], CL_TRUE, CL_MAP_READ, 0, (source->width + 1) * (source->height + 1) * sizeof(cl_ulong), 0, NULL, NULL, &error); clCheckOrExit(error); data->integral_image_data.ptr = result; // Return ret.image = cvCreateMat(source->height + 1, source->width + 1, CV_32SC1); cvSetData(ret.image, result, (source->width + 1) * sizeof(cl_uint)); ret.square_image = cvCreateMatHeader(source->height + 1, source->width + 1, CV_64FC1); cvSetData(ret.square_image, square_result, (source->width + 1) * sizeof(cl_ulong)); return ret; }
IplImage *freenect_sync_get_rgb_cv(int index) { static IplImage *image = 0; static char *data = 0; if (!image) image = cvCreateImageHeader(cvSize(640,480), 8, 3); unsigned int timestamp; if (freenect_sync_get_video(&data, ×tamp, index, FREENECT_VIDEO_RGB)) return NULL; cvSetData(image, data, 640*3); return image; }
IplImage* host_image2d<V>::getIplImage() const { assert(begin_); //allocate the structure IplImage* frameIPL = cvCreateImageHeader(cvSize(ncols(),nrows()), sizeof(typename V::vtype)*8, V::size); //init the data structure cvSetData(frameIPL, (void*)begin(), pitch()); return frameIPL; }
IplImage *freenect_sync_get_depth_cv(int index) { static IplImage *image = 0; static char *data = 0; if (!image) image = cvCreateImageHeader(cvSize(640,480), 16, 1); unsigned int timestamp; if (freenect_sync_get_depth(&data, ×tamp, index, FREENECT_DEPTH_11BIT)) return NULL; cvSetData(image, data, 640*2); return image; }
/** * Create IplImage from Comp Buf * @param cbuf * @return IplImage pointer */ IplImage* BOCV_IplImage_attach(CompBuf* cbuf) { if(cbuf->x>0 && cbuf->y>0){ IplImage *img = cvCreateImageHeader(cvSize(cbuf->x,cbuf->y),IPL_DEPTH_32F,cbuf->type); cvSetData(img,cbuf->rect,cbuf->x * cbuf->type * sizeof(float)); // always 4 byte align. return img; }else{ return NULL; } }
unsigned int __stdcall RightCaptureThread(LPVOID lpParameter) { BYTE *pRGB24Buff = new BYTE[IMGWIDTH * IMGHEIGHT * 3];//接收图像数据的缓冲区 DeviceFrameInfo dfInfo; while (true) { RightDevice->SoftTriggerOnce(); RightDevice->DeviceGetImageBufferEx2(pRGB24Buff, -1, &dfInfo); cvSetData(RightImg, pRGB24Buff, dfInfo.uiWidth * 3); ReleaseSemaphore(RightImgOver, 1, NULL); } }
void adjustBrightnessContrast(IplImage *&src, int Brightness, int Contrast) { unsigned char LookupTableData[256]; CvMat *LookupTableMatrix; double Delta; double a, b; int y; IplImage *filterB = cvCreateImage(cvGetSize(src), (src)->depth, 1); IplImage *filterG = cvCreateImage(cvGetSize(src), (src)->depth, 1); IplImage *filterR = cvCreateImage(cvGetSize(src), (src)->depth, 1); cvSplit(src, filterB, filterG, filterR, 0); //Brightness/Contrast Formula if(Contrast > 0) { Delta = 127 * Contrast / 100; a=255 / (255 - Delta * 2); b = a * (Brightness - Delta); } else { Delta = -128 * Contrast / 100; a = (256 - Delta*2) / 255; b = a * Brightness + Delta; } for(int x = 0 ; x < 256 ; x++) { y=(int)(a * x + b); if(y < 0) y = 0; else if(y > 255) y = 255; LookupTableData[x]=(uchar)y; } LookupTableMatrix = cvCreateMatHeader(1, 256, CV_8UC1); cvSetData(LookupTableMatrix, LookupTableData, 0); cvLUT(filterB, filterB, LookupTableMatrix); cvLUT(filterG, filterG, LookupTableMatrix); cvLUT(filterR, filterR, LookupTableMatrix); IplImage *dst = cvCreateImage(cvGetSize(src), src->depth, src->nChannels); cvMerge(filterB, filterG, filterR, 0, dst); cvReleaseImage(&src); src = cvCloneImage(dst); cvReleaseImage(&dst); cvReleaseImage(&filterB); cvReleaseImage(&filterG); cvReleaseImage(&filterR); cvReleaseMat(&LookupTableMatrix); }//end Brightness/Contrast
virtual IplImage* retrieveFrame(int) { unsigned char* data = 0; int step=0, width=0, height=0, cn=0; if(!ffmpegCapture || !icvRetrieveFrame_FFMPEG_p(ffmpegCapture,&data,&step,&width,&height,&cn)) return 0; cvInitImageHeader(&frame, cvSize(width, height), 8, cn); cvSetData(&frame, data, step); return &frame; }