100+ results results for 'IplImage cvLoadImage' (245 ms)
180 <0 - output image is color or grayscale dependending on the file */
181CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(1));
182
225 !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
226CVAPI(IplImage*) cvRetrieveFrame( CvCapture* capture );
227
229 !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
230CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
231
259/* write frame to video file */
260CVAPI(int) cvWriteFrame( CvVideoWriter* writer, const IplImage* image );
261
284#define cvvCreateTrackbar cvCreateTrackbar
285#define cvvLoadImage(name) cvLoadImage((name),1)
286#define cvvSaveImage cvSaveImage
performance.cpp https://gitlab.com/zharfi/tutorial-haartraining | C++ | 374 lines
213 int x, y, width, height;
214 IplImage* img;
215 int hits, missed, falseAlarms;
241
242 img = cvLoadImage( fullname );
243 if( !img ) continue;
performance.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 378 lines
217 int x, y;
218 IplImage* img;
219 int hits, missed, falseAlarms;
245
246 img = cvLoadImage( fullname );
247 if( !img ) continue;
sift.cpp https://github.com/yianni/cappocacciaactivevision.git | C++ | 163 lines
11{
12 /*IplImage *image = cvLoadImage("blue.jpg", CV_LOAD_IMAGE_COLOR);
13
64 system("siftWin32.exe <blue1.pgm >tmp1.txt");
65 IplImage *image1 = cvLoadImage("blue1.pgm");
66 FILE* fp1=fopen("tmp1.txt","rb");
124 //matching
125 IplImage *imagematch = cvLoadImage("blue2.pgm");
126 float *bestmatchx = (float*)malloc(sizeof(float)*temp1);
MYmaska.cpp https://github.com/straiki/VisionCup-Deep-Team.git | C++ | 322 lines
7//konstruktor
8MYmaska::MYmaska(IplImage *frame){
9
25void MYmaska::open(string name){
26 this->source = cvLoadImage(name.c_str());
27}
29void MYmaska::open_mask(string name){
30 this->mask = cvLoadImage(name.c_str());
31}
132
133 IplImage * akt;
134 for(int j = 0; j < i ; j++){
230
231IplImage* MYmaska::addMask(IplImage *frame,int typ){
232// cvSetImageROI(frame, cvRect(mezi_oci_x - mask->rotated->width/2,
image.cpp https://bitbucket.org/bosp/external-opencv.git | C++ | 310 lines
69
70static IplImage*
71icvRetrieveImage( void* obj )
72{
73 IplImage* img = 0;
74
75 if( CV_IS_IMAGE(obj) )
76 img = (IplImage*)obj;
77 else if( CV_IS_MAT(obj) )
98{
99 IplImage* img = 0;
100
205 {
206 IplImage* img = (IplImage*)obj;
207 CvMat hdr, *src = cvGetMat( img, &hdr );
itkOpenCVImageBridgeGrayScaleTest.cxx https://github.com/chrismullins/ITK.git | C++ | 296 lines
31template<typename TPixelType>
32IplImage* ConvertIplImageDataType(IplImage* in)
33{
116
117 // Check results of IplImage -> itk::Image
118 typename DifferenceFilterType::Pointer differ = DifferenceFilterType::New();
152 //
153 // Test itk::Image -> IplImage
154 //
154 //
155 IplImage* outIpl = itk::OpenCVImageBridge::ITKImageToIplImage< ImageType >(baselineImage);
156
157 // check results of itk::Image -> IplImage
158 IplImage* dataConvertedInIpl = ConvertIplImageDataType<PixelType>(inIpl);
159 double itkIplDiff = cvNorm(outIpl, dataConvertedInIpl);
facept.c https://github.com/cledersonbd/trab1_multimidia.git | C | 375 lines
25struct face_s {
26 IplImage *img;
27 CvPoint pt1, pt2;
34CvHaarClassifierCascade* cascade = 0;
35IplImage *image = 0, *grey = 0, *prev_grey = 0, *pyramid = 0, *prev_pyramid = 0, *swap_temp;
36
53 int scale = 1;
54 IplImage *img;
55
146 CvCapture* capture = 0;
147 IplImage *foto,*wind;
148 int i,k,c;
151
152 foto = cvLoadImage(argv[1], -1);
153 foto_size = cvGetSize(foto);
facedetect.c https://github.com/SteveClement/privateface.git | C | 280 lines
23// Function prototype for detecting and drawing an object from an image
24void detect_and_draw( IplImage* image );
25
39 // Images to capture the frame from video or camera or from file
40 IplImage *frame, *frame_copy = 0;
41
100 {
101 // Capture the frame and load it in IplImage
102 if( !cvGrabFrame( capture ))
141 // Load the image from that filename
142 IplImage* image = cvLoadImage( filename, 1 );
143
202
203void cvOverlayImage(IplImage* src, IplImage* overlay, CvPoint location, CvScalar S, CvScalar D)
204{
highgui.h https://bitbucket.org/rlyspn/androidrr.git | C Header | 385 lines
147*/
148CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
149CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
180 !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
181CVAPI(IplImage*) cvRetrieveFrame( CvCapture* capture );
182
184 !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
185CVAPI(IplImage*) cvQueryFrame( CvCapture* capture );
186
232#define cvvCreateTrackbar cvCreateTrackbar
233#define cvvLoadImage(name) cvLoadImage((name),1)
234#define cvvSaveImage cvSaveImage
248
249CV_INLINE int iplWidth( const IplImage* img );
250CV_INLINE int iplWidth( const IplImage* img )
image.cpp https://gitlab.com/brian0218/rk3188_r-box_android4.2.2_sdk | C++ | 255 lines
83 {
84 if( m_img && m_img->nSize == sizeof(IplImage))
85 Destroy();
98{
99 IplImage* img = image.GetImage();
100 if( img )
107#define HG_IS_IMAGE(img) \
108 ((img) != 0 && ((const IplImage*)(img))->nSize == sizeof(IplImage) && \
109 ((IplImage*)img)->imageData != 0)
133{
134 IplImage* img = cvLoadImage( filename, desired_color );
135 if( !img )
149
150 IplImage* img = cvLoadImage( filename, desired_color );
151 if( !img )
test_latentsvmdetector.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 309 lines
86
87 IplImage* image = cvLoadImage(img_path.c_str());
88 if (!image)
highgui_reading_and_writing_images_and_video.rst https://github.com/ethanrublee/libopencv-debian.git | ReStructuredText | 679 lines
19
20 Loads an image from a file as an IplImage.
21
46The function
47``cvLoadImage``
48loads an image from the specified file and returns the pointer to the loaded image. Currently the following file formats are supported:
118The function
119``cvLoadImageM``
120loads an image from the specified file and returns the pointer to the loaded image.
428
429.. function:: QueryFrame(capture) -> iplimage
430
462
463.. function:: RetrieveFrame(capture) -> iplimage
464
find_obj.cpp https://github.com/BynreForest/FaceDetection.git | C++ | 308 lines
23
24IplImage *image = 0;
25
225
226 IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );
227 IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );
234 }
235 IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
236 cvCvtColor( object, object_color, CV_GRAY2BGR );
251 CvPoint dst_corners[4];
252 IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
253 cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
stereo_calib.cpp https://github.com/siegleal/iSanta.git | C++ | 378 lines
95 continue;
96 IplImage* img = cvLoadImage( buf, 0 );
97 if( !img )
103 {
104 IplImage* timg = img;
105 if( s > 1 )
128 printf("%s\n", buf);
129 IplImage* cimg = cvCreateImage( imageSize, 8, 3 );
130 cvCvtColor( img, cimg, CV_GRAY2BGR );
311 {
312 IplImage* img1=cvLoadImage(imageNames[0][i].c_str(),0);
313 IplImage* img2=cvLoadImage(imageNames[1][i].c_str(),0);
Thinkingtime_for_copy_task.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 404 lines
20
21 IplImage src = cvLoadImage(g[p].getPath(),0);
22
24 {
25 IplImage tmp2 = cvLoadImage("f.jpg",0);
26 IplImage result2 = cvCreateImage(cvSize(src.width()-tmp2.width()+1, src.height()-tmp2.height()+1), IPL_DEPTH_32F, 1);
53 {
54 IplImage tmp1 = cvLoadImage("e.jpg",0);
55 IplImage result1 = cvCreateImage(cvSize(src.width()-tmp1.width()+1, src.height()-tmp1.height()+1), IPL_DEPTH_32F, 1);
78 }
79 IplImage tmp = cvLoadImage("d.jpg",0);
80
80
81 IplImage result = cvCreateImage(cvSize(src.width()-tmp.width()+1, src.height()-tmp.height()+1), IPL_DEPTH_32F, 1);
82 cvZero(result);
DetectContours.java https://github.com/johnflan/Maple.git | Java | 205 lines
13import com.googlecode.javacv.cpp.opencv_core.CvSeq;
14import com.googlecode.javacv.cpp.opencv_core.IplImage;
15
30 IplImage frameRaw = grabber.grab();
31 //!!IplImage frameRaw = cvLoadImage(
32 //!! "/home/johnflan/workspace/Maple/docs/misc_images/testimg/leaf.png",
35
36 IplImage frameProcessed = cvCreateImage( cvGetSize(frameRaw), IPL_DEPTH_8U, 1 );
37
68 contourProcessor.printContourPoints(tempContour);
69 IplImage mapleContour = cvLoadImage(
70 "/home/johnflan/workspace/Maple/docs/misc_images/testimg/leaf.png",
83 contourProcessor.printContourPoints(tempContourLow);
84 IplImage mapleContourPolyApprox = cvLoadImage(
85 "/home/johnflan/workspace/Maple/docs/misc_images/testimg/leaf.png",
cap_images.cpp https://gitlab.com/generic-library/opencv | C++ | 396 lines
86 virtual bool grabFrame();
87 virtual IplImage* retrieveFrame(int);
88
94
95 IplImage* frame;
96 bool grabbedInOpen;
126 cvReleaseImage(&frame);
127 frame = cvLoadImage(str, CV_LOAD_IMAGE_UNCHANGED);
128 if( frame )
133
134IplImage* CvCapture_Images::retrieveFrame(int)
135{
334 virtual void close();
335 virtual bool writeFrame( const IplImage* );
336
adaptiveskindetector.cpp https://gitlab.com/juan-cardelino/misc_projects | C++ | 406 lines
63 virtual ~ASDFrameSequencer();
64 virtual IplImage *getNextImage();
65 virtual void close();
129
130IplImage *ASDFrameHolder::getImage()
131{
139
140void ASDFrameHolder::setImage(IplImage *sourceImage)
141{
264
265 IplImage* img = cvLoadImage(fileName);
266
289
290void displayBuffer(IplImage *rgbDestImage, IplImage *buffer, int rValue, int gValue, int bValue)
291{
ocvsurf.cpp https://github.com/sileht/debbot-seeks.git | C++ | 308 lines
63
64 IplImage *img = cvLoadImage(tfname.c_str(),CV_LOAD_IMAGE_GRAYSCALE);
65 if (!img) // failed loading image, usually from a broken transfer earlier...
Testculture.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 259 lines
18
19 IplImage src = cvLoadImage(g[p].getPath(),0);
20
20
21 IplImage tmp = cvLoadImage("d.jpg",0);
22
22
23 IplImage result = cvCreateImage(cvSize(src.width()-tmp.width()+1, src.height()-tmp.height()+1), IPL_DEPTH_32F, 1);
24
tp2.c https://bitbucket.org/a0viedo/orga2tp2.git | C | 592 lines
226void aplicar_recortar (int tiempo, int cant_iteraciones, const char *nomb_impl, const char *nomb_arch_entrada, int tam) {
227 IplImage *src = 0;
228 IplImage *dst = 0;
231 // Cargo la imagen
232 if( (src = cvLoadImage (nomb_arch_entrada, CV_LOAD_IMAGE_GRAYSCALE)) == 0 )
233 exit(EXIT_FAILURE);
246
247 // Creo una IplImage para cada salida esperada
248 if( (dst = cvCreateImage (dst_size, IPL_DEPTH_8U, 1) ) == 0 )
291void aplicar_colorizar (int tiempo, int cant_iteraciones, const char *nomb_impl, const char *nomb_arch_entrada, float alpha) {
292 IplImage *src = 0;
293 IplImage *dst = 0;
296 // Cargo la imagen
297 if( (src = cvLoadImage (nomb_arch_entrada, CV_LOAD_IMAGE_COLOR)) == 0 )
298 exit(EXIT_FAILURE);
MT_TrackerBase.cpp git://github.com/leonard-lab/MADTraC.git | C++ | 568 lines
49
50IplImage* MT_TrackerFrameGroup::getFrame(unsigned int frame_index) const
51{
211
212MT_TrackerBase::MT_TrackerBase(IplImage* ProtoFrame)
213 : m_pTrackedObjects(NULL)
251
252void MT_TrackerBase::doInit(IplImage* ProtoFrame)
253{
310
311void MT_TrackerBase::doTrain(IplImage* frame)
312{
387
388 IplImage* tBG_frame = cvLoadImage(BackgroundFilename,CV_LOAD_IMAGE_GRAYSCALE);
389 if(tBG_frame == 0)
cap_images.cpp https://gitlab.com/dlts/opencv | C++ | 376 lines
85 virtual bool grabFrame();
86 virtual IplImage* retrieveFrame(int);
87
93
94 IplImage* frame;
95};
116 cvReleaseImage(&frame);
117 frame = cvLoadImage(str, CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR);
118 if( frame )
123
124IplImage* CvCapture_Images::retrieveFrame(int)
125{
314 virtual void close();
315 virtual bool writeFrame( const IplImage* );
316
specialenrollment.cpp https://gitlab.com/nyimbi/voter-registration | C++ | 332 lines
217 if (fileReader.exists()) {
218 IplImage* dummy=cvLoadImage(filename,1);
219 QImage image(QSize(dummy->width,dummy->height),QImage::Format_RGB32);
273 if (fileReader.exists()) {
274 IplImage* dummy=cvLoadImage(filename,1);
275 QImage image(QSize(dummy->width,dummy->height),QImage::Format_RGB32);
opencv_glue.c https://gitlab.com/oytunistrator/QuIP | C | 320 lines
125
126 if( (ocvi_p->ocv_image = cvLoadImage( filename, CV_LOAD_IMAGE_COLOR)) == 0 ){
127 sprintf(ERROR_STRING,"Error opening file %s!?",filename);
153
154 IplImage* img;
155 Dimension_Set dimset;
267 }
268 ocvi_p->ocv_image = (IplImage *)getbuf(sizeof(*ocvi_p->ocv_image));
269 /* don't need to test here because getbuf kill whole program if failure... */
271 /* Now copy over the fields... */
272 IplImage* img = ocvi_p->ocv_image;
273 /*img->nSize =
opticalflow_nvidia_api.cpp https://gitlab.com/generic-library/opencv | C++ | 649 lines
84template<class T>
85NCVStatus CopyData(IplImage *image, Ptr<NCVMatrixAlloc<Ncv32f> >& dst)
86{
111template<class T>
112NCVStatus CopyData(const IplImage *image, const NCVMatrixAlloc<Ncv32f> &dst)
113{
140 Ptr<NCVMatrixAlloc<Ncv32f> > &dst,
141 IplImage *&firstFrame,
142 IplImage *&lastFrame)
143{
144 IplImage *image;
145 image = cvLoadImage (frame0Name);
155
156 IplImage *image2;
157 image2 = cvLoadImage (frame1Name);
CaptureManager.cpp https://github.com/p1r4nh4/CellTrack.git | C++ | 1239 lines
97 progressDlg.Update(i+1, wxString::Format(_T("Frame %d of %d"), i+1, totalFrameCount));
98 IplImage *newframe = capture.queryFrame(i);
99 IplImage *resized;
129 book = new ImagePlus*[totalFrameCount];
130 IplImage* testImg = NULL;
131 if (testImg = cvLoadImage((m_capture->getFilename(0)).mb_str()))
141 progressDlg.Update(i+1, wxString::Format(_T("Frame %d of %d"), i+1, totalFrameCount));
142 IplImage *newframe = capture.queryFrame(i);
143 IplImage *resized;
177 newsize, 1);
178 IplImage *resized;
179 if (resize)
180 resized = cvCreateImage(newsize,8,3);
181 IplImage *frame_flip = cvCreateImage(newsize,8,3);
182 wxProgressDialog progressDlg(_T("Saving movie..."), wxString::Format(_T("Frame 0 of %d"), frameCount),frameCount, NULL, wxPD_APP_MODAL|wxPD_ELAPSED_TIME|wxPD_REMAINING_TIME|wxPD_AUTO_HIDE);
FaceMngr_fast.cpp http://facerecog.googlecode.com/svn/trunk/ | C++ | 269 lines
61 { // ?????????
62 if ( ! align->GetFace((IplImage*)pic, faceImg8, leftEye, rightEye) ) // ???FaceAlign_Coord?
63 return false;
102 CString path = strRp + iter->picPath;
103 IplImage *img = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
104 if (!img)
150 CString path = strRp + iter->picPath;
151 IplImage *img = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
152 if (!img)
234 path += testIter->picPath;
235 IplImage *img = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
236 if (!img)
camera.cpp https://github.com/aiwenar/Eyes.git | C++ | 1383 lines
31
32IplImage* QImage2IplImage(QImage *qimg)
33{
43
44QImage* IplImage2QImage(IplImage *iplImg)
45{
108}
109void mirror::init_mirrors(IplImage * srcExample)
110{
179 prevMirror = cvCloneImage(src);
180 IplImage * mirror = cvCreateImage(cvSize(prevMirror->width, prevMirror->height), prevMirror->depth, prevMirror->nChannels);
181 cvFlip(prevMirror, mirror, 1);
192
193 //IplImage* srcd = cvLoadImage( "./test.png", 1 );
194 //IplImage* newd;
test_main.cpp https://github.com/sdp-2011/sdp-12.git | C++ | 310 lines
39 CvMemStorage* storage=cvCreateMemStorage(0);
40 IplImage* frame;
41 IplImage* back_img;
66 {
67 frame=cvLoadImage("bg.jpg");
68 if(frame)
106
107 frame =cvLoadImage(currentFile.c_str(),1);
108 std::cout<<"image: "<<conf.i_base.current<<std::endl;
117 int h=290;
118 IplImage* buffer_frame = cvCreateImage(cvSize(frame->width,frame->height),frame->depth,3);
119 IplImage* current_frame = cvCreateImage(cvSize(w,h), frame->depth,3);
123 cvResetImageROI(buffer_frame);
124 IplImage* current_frame_pro_TY=NULL;
125 cvReleaseImage(&buffer_frame);
BlobDemo.java https://bitbucket.org/cagcontactor/jcurious.git | Java | 270 lines
42 else if(k == 4) { RawImage = cvLoadImage("Blob2.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; }
43 else if(k == 5) { RawImage = cvLoadImage("Blob3.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; }
44 else if(k == 6) { RawImage = cvLoadImage("Rice.jpg"); MinArea = 30; ErodeCount = 2; DilateCount = 1; }
105 }
106 public static void ShowImage(IplImage image, String caption, int size)
107 {
125
126 public static void Highlight(IplImage image, int [] inVec)
127 {
214 // Counterclockwise small angle rotation by skewing - Does not stretch border pixels
215 public static IplImage SkewGrayImage(IplImage Src, double angle) // angle is in radians
216 {
259
260 public static IplImage TransposeImage(IplImage SrcImage)
261 {
seadlib.cpp https://github.com/brigr/InFeRno.git | C++ | 720 lines
138
139int Sead::doAdaptiveGammaCorrection(IplImage *img) {
140 static const double chiM = 128.0; /* intensity midpoint */
200
201int Sead::Edge(const IplImage *skin_binary_img, const IplImage *canny_edge_img, int x, int y) {
202 return (Psi(skin_binary_img, x, y) + CAN(canny_edge_img, x, y) == 2);
204
205void Sead::cvGetAreaPixels(IplImage *image, IplImage *blackboard, CvPoint init_point, CvScalar boundary_color, CvScalar fill_color, CvSeq *points, double& contour_nonskin_mean_r, double& contour_nonskin_mean_g, double& contour_nonskin_mean_b, double& skin_to_nonskin_ratio, unsigned long& contour_nonskin_total_pixels) {
206 unsigned long contour_skin_total_pixels = 0;
285struct Sead::IplImageFeature *Sead::process() {
286 IplImage *splitColorImage = NULL, *featureimg = NULL, *blackboard = NULL, *hu_img = NULL;
287 CvMemStorage *mem_storage = NULL, *nsp_storage = NULL;
479
480int Sead::cvAdaptiveGrids(IplImage *image, int partitions_x, int partitions_y, int maxSplitLevel, struct IplImagePartition *cell, CvSeq *ctrl_points, struct IplImagePartition*& partition) {
481 bool returnNull = false;
reading_and_writing_images_and_video.rst https://gitlab.com/Ruggero/SparkEngine_Desktop | ReStructuredText | 570 lines
13
14.. ocv:cfunction:: IplImage* cvDecodeImage( const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)
15
65
66.. ocv:cfunction:: IplImage* cvLoadImage( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
67
67
68.. ocv:cfunction:: CvMat* cvLoadImageM( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
69
332
333.. ocv:cfunction:: IplImage* cvRetrieveFrame( CvCapture* capture, int streamIdx=0 )
334
qt_new_functions.rst git://pkgs.fedoraproject.org/opencv | ReStructuredText | 339 lines
37
38 IplImage* img1 = cvLoadImage("files/flower.jpg");
39 IplImage* img2 = cvCreateImage(cvGetSize(img1),8,3);
40 CvCapture* video = cvCaptureFromFile("files/hockey.avi");
41 IplImage* img3 = cvCreateImage(cvGetSize(cvQueryFrame(video)),8,3);
42
ContourProcessor.java https://github.com/johnflan/Maple.git | Java | 173 lines
18import com.googlecode.javacv.cpp.opencv_core.CvSeqWriter;
19import com.googlecode.javacv.cpp.opencv_core.IplImage;
20
30
31 public void detect(IplImage binaryImage, CvSeq contours, CvMemStorage storage){
32
40
41 public void draw(IplImage rawImage, CvSeq contours){
42
80
81 IplImage frameRaw = cvLoadImage(
82 "/home/johnflan/workspace/Maple/docs/misc_images/testLeaf.png",
134
135 IplImage frameRaw = cvLoadImage(file.getValue(), CV_LOAD_IMAGE_UNCHANGED);
136
vector.cpp https://github.com/qiqidone/Vectorization.git | C++ | 321 lines
73 // source
74 m_source = cvLoadImage(filename, 1);
75 // gray
182}
183bool Vshader::initial(IplImage* img, IplImage* _edge)
184{
HoughLines.java https://github.com/jmodayil/rlpark.git | Java | 138 lines
9import static com.googlecode.javacv.cpp.opencv_core.cvLine;
10import static com.googlecode.javacv.cpp.opencv_highgui.cvLoadImage;
11import static com.googlecode.javacv.cpp.opencv_imgproc.CV_GRAY2BGR;
26import com.googlecode.javacv.cpp.opencv_core.CvSeq;
27import com.googlecode.javacv.cpp.opencv_core.IplImage;
28
43 String fileName = args.length >= 1 ? args[0] : "pic1.png"; // if no params provided, compute the defaut image
44 IplImage src = cvLoadImage(fileName, 0);
45 IplImage dst;
45 IplImage dst;
46 IplImage colorDst;
47 CvMemStorage storage = cvCreateMemStorage(0);
cximage.cpp https://gitlab.com/brian0218/rk3066_r-box_android4.2.2_sdk | C++ | 397 lines
51
52static CvLoadImageFunc load_image = 0;
53static CvLoadImageMFunc load_image_m = 0;
73
74static IplImage*
75icvRetrieveImage( void* obj )
76{
77 IplImage* img = 0;
78
239 {
240 IplImage* img = (IplImage*)obj;
241 CvMat hdr, *src = cvGetMat( img, &hdr );
366CV_IMPL int
367cvSetImageIOFunctions( CvLoadImageFunc _load_image, CvLoadImageMFunc _load_image_m,
368 CvSaveImageFunc _save_image, CvShowImageFunc _show_image=NULL )
test_optflowpyrlk.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 244 lines
74
75 IplImage* imgI = 0;
76 IplImage* imgJ = 0;
117 sprintf( filename, "%soptflow/%s", ts->get_data_path().c_str(), "rock_1.bmp" );
118 imgI = cvLoadImage( filename, -1 );
119
128 sprintf( filename, "%soptflow/%s", ts->get_data_path().c_str(), "rock_2.bmp" );
129 imgJ = cvLoadImage( filename, -1 );
130
main.c https://github.com/cledersonbd/trab1_multimidia.git | C | 189 lines
23 CvMoments moments;
24 IplImage *frame,
25 *fundo,
52
53 foto = cvLoadImage(argv[1], -1);
54 fotoTMP = cvLoadImage(argv[1], -1);
ImageLoader.cpp https://github.com/NiekHoeijmakers/parlevision.git | C++ | 206 lines
161 //load the image
162 const IplImage* image = cvLoadImage(c_path.c_str(), CV_LOAD_IMAGE_UNCHANGED );
163 if(image != 0)
Matrix.cpp https://gitlab.com/jimador/simple-object-tracking | C++ | 508 lines
106 //res.Resize(img->height, img->width, 3);
107 res.IplImage2Matrix(img);
108 }
177 cout << "Press q to quit" << endl;
178 IplImage *img;
179 cvNamedWindow( "Cam", 0/*CV_WINDOW_AUTOSIZE*/ );
213 //cvInitImageHeader( _iplimg, sz, IPL_DEPTH_8U, _depth, IPL_ORIGIN_TL, 16 );
214 //IplImage *_iplimg = cvCreateImage( sz, IPL_DEPTH_8U, _depth );
215
243
244template<> void Matrixu::IplImage2Matrix(IplImage *img)
245{
275
276template<> void Matrixu::GrayIplImage2Matrix(IplImage *img)
277{
itkOpenCVImageBridgeRGBTest.cxx https://github.com/arnaudgelas/ITK.git | C++ | 319 lines
89template<typename TPixelType>
90IplImage* ConvertIplImageDataType(IplImage* in)
91{
165 //
166 IplImage* inIpl = cvLoadImage(argv0, CV_LOAD_IMAGE_COLOR);
167 if (!inIpl)
206 //
207 // Test itk::Image -> IplImage
208 //
208 //
209 IplImage* outIpl = itk::OpenCVImageBridge::ITKImageToIplImage< ImageType >(baselineImage);
210
211 // check results of itk::Image -> IplImage
212 IplImage* dataConvertedInIpl = ConvertIplImageDataType<ValueType>(inIpl);
213
templatematching.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 253 lines
18
19 IplImage src = cvLoadImage(g[p].getPath(),0);
20
20
21 IplImage tmp = cvLoadImage("d.jpg",0);
22
22
23 IplImage result = cvCreateImage(cvSize(src.width()-tmp.width()+1, src.height()-tmp.height()+1), IPL_DEPTH_32F, 1);
24
imgcodecs_c.h https://gitlab.com/netskink/anotherOpenCVTesty | C Header | 137 lines
74*/
75CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
76CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
102/* decode image stored in the buffer */
103CVAPI(IplImage*) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
104CVAPI(CvMat*) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
126
127#define cvvLoadImage(name) cvLoadImage((name),1)
128#define cvvSaveImage cvSaveImage
image.cpp https://gitlab.com/generic-library/opencv | C++ | 135 lines
12 cout <<
13 "\nThis program shows how to use cv::Mat and IplImages converting back and forth.\n"
14 "It shows reading of images, converting to planes and merging back, color conversion\n"
38 //! [iplimage]
39 Ptr<IplImage> iplimg(cvLoadImage(imagename.c_str())); // Ptr<T> is safe ref-counting pointer class
40 if(!iplimg)
44 }
45 Mat img = cv::cvarrToMat(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
46 // between the old and the new data structures (by default, only the header
47 // is converted, while the data is shared)
48 //! [iplimage]
49#else
49#else
50 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
51 if(img.empty())
main.cpp https://github.com/jgrogers/Door-Sign-Detection.git | C++ | 288 lines
23void cvShowImageSmall(const char* name, const IplImage* img) {
24 // IplImage* img_show =cvCreateImage(cvSize(640,480), img->depth, img->nChannels);
25 // cvResize(img, img_show);
141 do {
142 IplImage* img_in = cvLoadImage(vm["img"].as<std::string>().c_str());
143 IplImage* img_tmp = cvCreateImage(cvSize(1024,768), IPL_DEPTH_8U, 3);
148 if (vm.count ("conv_rect")) {
149 IplImage* img_tmp = cvCreateImage(cvGetSize(img_in), IPL_DEPTH_8U,1);
150 IplImage* img_out;// = cvCreateImage(cvGetSize(img_in), IPL_DEPTH_8U, 1);
158 if (vm.count ("edge")) {
159 IplImage* img_tmp = cvCreateImage(cvGetSize(img_in), IPL_DEPTH_8U,1);
160 IplImage* img_out = cvCreateImage(cvGetSize(img_in), IPL_DEPTH_8U, 1);
169 if (vm.count ("hog")){
170 IplImage* tmp_img = cvCreateImage(cvGetSize(img_in), IPL_DEPTH_8U, 1);
171 cvCvtColor(img_in, tmp_img, CV_BGR2GRAY);
HoughLines.java https://bitbucket.org/cagcontactor/jcurious.git | Java | 116 lines
23 String fileName = args.length >= 1 ? args[0] : "pic1.png"; // if no params provided, compute the defaut image
24 IplImage src = cvLoadImage(fileName, 0);
25 IplImage dst;
25 IplImage dst;
26 IplImage colorDst;
27 CvMemStorage storage = cvCreateMemStorage(0);
image.cpp https://gitlab.com/juan-cardelino/misc_projects | C++ | 109 lines
12#if DEMO_MIXED_API_USE
13 Ptr<IplImage> iplimg = cvLoadImage(imagename); // Ptr<T> is safe ref-conting pointer class
14 if(iplimg.empty())
18 }
19 Mat img(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
20 // between the old and the new data structures (by default, only the header
22#else
23 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
24 if(img.empty())
70#if DEMO_MIXED_API_USE
71 // it's easy to pass the new matrices to the functions that only work with IplImage or CvMat:
72 // step 1) - convert the headers, data will not be copied
72 // step 1) - convert the headers, data will not be copied
73 IplImage cv_planes_0 = planes[0], cv_noise = noise;
74 // step 2) call the function; do not forget unary "&" to form pointers
AAM_CAM.cpp https://github.com/sreedal/GC.git | C++ | 435 lines
60 {
61 IplImage* image = cvLoadImage(img_files[ii].c_str(), -1);
62 Shape.ScaleXY(image->width, image->height);
103 //Get Shape and Texture respectively
104 IplImage* image = cvLoadImage(img_files[i].c_str(), -1);
105
266//============================================================================
267void AAM_CAM::DrawAppearance(IplImage* image, const AAM_Shape& Shape, CvMat* Texture)
268{
368static CvMat* t = 0;//texture instance
369static IplImage* image = 0;
370static AAM_Shape aam_s;
cap_images.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 394 lines
86 virtual bool grabFrame();
87 virtual IplImage* retrieveFrame(int);
88
94
95 IplImage* frame;
96 bool grabbedInOpen;
126 cvReleaseImage(&frame);
127 frame = cvLoadImage(str, CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR);
128 if( frame )
133
134IplImage* CvCapture_Images::retrieveFrame(int)
135{
332 virtual void close();
333 virtual bool writeFrame( const IplImage* );
334
calibrate.cc https://github.com/vbajpai/cameracalibration.git | C++ | 294 lines
21 CvPoint2D32f* corners;
22 IplImage *img, *dest;
23 string filename;
99 filename = imageList[imageIndex];
100 img = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_UNCHANGED);
101
matlab_syntax.py https://bitbucket.org/m4271n/opencv.git | Python | 269 lines
48from cv import *
49from highgui import cvShowImage,cvNamedWindow,cvLoadImage,cvWaitKey
50
121 sz = (X.rows, X.cols, CV_MAT_CN(X.type))
122 # IplImage
123 elif hasattr(X, "nChannels"):
252def imread(fname):
253 return cvLoadImage(fname, -1)
254loadimage = imread
main.cc https://github.com/rapmon/Face.js.git | C++ | 147 lines
58 fc->cascade = (CvHaarClassifierCascade*)cvLoad(xmlCascade, 0, 0, 0);
59 fc->frame = cvLoadImage(fc->filename, 3);
60 face_baton_t *baton = new face_baton_t();
70 face_baton_t *baton = static_cast<face_baton_t *>(req->data);
71 IplImage* gray_frame;
72 gray_frame = nice_my_frame(baton->fc->frame);
main.cpp https://github.com/edilello/OpenPNL.git | C++ | 861 lines
35
36void UpdateMHIImages(IplImage *pMHI, IplImage *pGrayMHI, IplImage *pImage, IplImage *pLastImage)
37{
82
83Buttons GetButton(IplImage *pGrayMHI, Modes Mode, int SubImageWidth, int SubImageHeight, int HStepLength, int VStepLength, IplImage *pImage)
84{
238
239 IplImage *pRock = cvLoadImage( "..\\rps\\pix\\rock.bmp", 1 );
240 IplImage *pPaper = cvLoadImage( "..\\rps\\pix\\paper.bmp", 1);
241 IplImage *pScissors = cvLoadImage( "..\\rps\\pix\\scissors.bmp", 1);
242 IplImage *pExit = cvLoadImage( "..\\rps\\pix\\exit.bmp", 1);
243 IplImage *pStart = cvLoadImage( "..\\rps\\pix\\start.bmp", 1 );
243 IplImage *pStart = cvLoadImage( "..\\rps\\pix\\start.bmp", 1 );
244 IplImage *pSettings = cvLoadImage( "..\\rps\\pix\\settings.bmp", 1 );
245 IplImage *pInfo = cvLoadImage( "..\\rps\\pix\\info.bmp", 1);
find_obj.cpp git://pkgs.fedoraproject.org/opencv | C++ | 323 lines
219
220 IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );
221 IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );
246
247 IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
248 cvCvtColor( object, object_color, CV_GRAY2BGR );
266 CvPoint dst_corners[4];
267 IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
268 cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
HoughLines.java https://gitlab.com/cvtung/javacv | Java | 117 lines
22 String fileName = args.length >= 1 ? args[0] : "pic1.png"; // if no params provided, compute the defaut image
23 IplImage src = cvLoadImage(fileName, 0);
24 IplImage dst;
24 IplImage dst;
25 IplImage colorDst;
26 CvMemStorage storage = cvCreateMemStorage(0);
30 CanvasFrame hough = new CanvasFrame("Hough");
31 OpenCVFrameConverter.ToIplImage sourceConverter = new OpenCVFrameConverter.ToIplImage();
32 OpenCVFrameConverter.ToIplImage houghConverter = new OpenCVFrameConverter.ToIplImage();
facedetect.c https://gitlab.com/zharfi/tutorial-haartraining | C | 215 lines
20
21void detect_and_draw( IplImage* img, double scale_factor, int min_neighbors, int flags, CvSize min_size );
22
29 CvCapture* capture = 0;
30 IplImage *frame, *frame_copy = 0;
31 int optlen = strlen("--cascade=");
125 const char* filename = input_name ? input_name : (char*)"lena.jpg";
126 IplImage* image = cvLoadImage( filename, 1 );
127
147 buf[len] = '\0';
148 image = cvLoadImage( buf, 1 );
149 if( image )
166
167void detect_and_draw( IplImage* img, double scale_factor, int min_neighbors, int flags, CvSize min_size )
168{
main.cpp https://github.com/twelly/OpenCV.git | C++ | 250 lines
17{
18 IplImage *img_in = 0, *img_affine = 0, *img_scene = 0, *img_interp = 0;;
19 int height, width, step, channels;
32// load the distorted image X_c
33 img_in = cvLoadImage(argv[1]);
34 if (!img_in)
interoperability_with_OpenCV_1.cpp https://gitlab.com/geekshabeka/opencv | C++ | 141 lines
15 cout << endl << progName
16 << " shows how to use cv::Mat and IplImages together (converting back and forth)." << endl
17 << "Also contains example for image read, spliting the planes, merging back and " << endl
36#ifdef DEMO_MIXED_API_USE
37 Ptr<IplImage> IplI(cvLoadImage(imagename)); // Ptr<T> is a safe ref-counting pointer class
38 if(!IplI)
44#else
45 Mat I = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
46 if( I.empty() ) // same as if( !I.data )
98#ifdef DEMO_MIXED_API_USE
99 // To pass the new matrices to the functions that only work with IplImage or CvMat do:
100 // step 1) Convert the headers (tip: data will not be copied).
102
103 IplImage cv_planes_0 = planes[0], cv_noise = noisyI;
104 cvAddWeighted(&cv_planes_0, contrast_gain, &cv_noise, 1, -128 + brightness_gain, &cv_planes_0);
train.cpp https://github.com/jgrogers/Door-Sign-Detection.git | C++ | 275 lines
119 }
120 IplImage* img_in = cvLoadImage(fname);
121 IplImage* img_bw = TrainPrepImage(img_in);
129 }
130 IplImage* newsign = cvCreateImage(signsize,
131 IPL_DEPTH_8U,
158
159 IplImage* img_in = cvLoadImage(vm["img"].as<std::string>().c_str());
160 IplImage* img_bw = TrainPrepImage(img_in);
162 do {
163 IplImage* img = cvCloneImage(img_in);
164
232 full_name.c_str());
233 IplImage* img_in = cvLoadImage(full_name.c_str());
234 IplImage* img_bw = TrainPrepImage(img_in);
calc_flows.cxx https://github.com/mbsullivan/plus-one.git | C++ | 304 lines
57 // load the image
58 IplImage *img = NULL, *gray = NULL;
59 img = cvLoadImage(filename.c_str(),1); // scan in color
79
80void Calc_Flows::init(IplImage *initial_img){
81
91 // get initial set for feature detection
92 IplImage* eig = cvCreateImage(cvGetSize(initial_img), 32, 1);
93 IplImage* temp = cvCreateImage(cvGetSize(initial_img), 32, 1);
237
238void Calc_Flows::pair_flow(IplImage* img1, IplImage* img2){
239 // calculate flow and track points (modified Lucas & Kanade algorithm)
295
296IplImage* Calc_Flows::annotate_img(IplImage* img){
297
imgcodecs_c.h https://gitlab.com/geekshabeka/opencv | C Header | 117 lines
70*/
71CVAPI(IplImage*) cvLoadImage( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
72CVAPI(CvMat*) cvLoadImageM( const char* filename, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
95/* decode image stored in the buffer */
96CVAPI(IplImage*) cvDecodeImage( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
97CVAPI(CvMat*) cvDecodeImageM( const CvMat* buf, int iscolor CV_DEFAULT(CV_LOAD_IMAGE_COLOR));
AAM_TDM.cpp https://github.com/sreedal/GC.git | C++ | 313 lines
44 {
45 IplImage* image = cvLoadImage(img_files[i].c_str(), -1);
46
244
245 IplImage* templateimg = cvCreateImage
246 (cvSize(m_warp.Width(), m_warp.Height()), IPL_DEPTH_8U, 3);
246 (cvSize(m_warp.Width(), m_warp.Height()), IPL_DEPTH_8U, 3);
247 IplImage* convexImage = cvCreateImage
248 (cvSize(m_warp.Width(), m_warp.Height()), IPL_DEPTH_8U, 3);
248 (cvSize(m_warp.Width(), m_warp.Height()), IPL_DEPTH_8U, 3);
249 IplImage* TriImage = cvCreateImage
250 (cvSize(m_warp.Width(), m_warp.Height()), IPL_DEPTH_8U, 3);
ImAcq.cpp https://bitbucket.org/sertacolgunsoylu/opentld.git | C++ | 245 lines
100{
101 IplImage *image = cvLoadImage(path);
102
111
112IplImage *imAcqLoadFrame(ImAcq *imAcq, int fNo)
113{
118
119 return cvLoadImage(path);
120}
121
122IplImage *imAcqLoadCurrentFrame(ImAcq *imAcq)
123{
148
149IplImage *imAcqGetImg(ImAcq *imAcq)
150{
Material.cpp https://github.com/hashier/CG2.git | C++ | 247 lines
212bool Material::loadTextureData(const char *textureFile, Texture &texture) {
213 IplImage *image = cvLoadImage(textureFile, CV_LOAD_IMAGE_COLOR);
214 if (image != NULL) {
OpticalFlowTracker.java https://bitbucket.org/cagcontactor/jcurious.git | Java | 94 lines
24 // Load two images and allocate other structures
25 IplImage imgA = cvLoadImage(
26 "image0.png",
27 CV_LOAD_IMAGE_GRAYSCALE);
28 IplImage imgB = cvLoadImage(
29 "image1.png",
34
35 // IplImage imgC = cvLoadImage("OpticalFlow1.png",
36 // CV_LOAD_IMAGE_UNCHANGED);
36 // CV_LOAD_IMAGE_UNCHANGED);
37 IplImage imgC = cvLoadImage(
38 "image0.png",
40 // Get the features for tracking
41 IplImage eig_image = cvCreateImage(img_sz, IPL_DEPTH_32F, 1);
42 IplImage tmp_image = cvCreateImage(img_sz, IPL_DEPTH_32F, 1);
pyramid_segmentation.c https://gitlab.com/Ruggero/SparkEngine_Desktop | C | 99 lines
15
16IplImage* image[2] = { 0, 0 }, *image0 = 0, *image1 = 0;
17CvSize size;
52
53 if( (image[0] = cvLoadImage( filename, 1)) == 0 )
54 {
featureLBPHist.c http://pam-face-authentication.googlecode.com/svn/ | C | 273 lines
32
33double getBIT(IplImage* img,double px,double py,double threshold)
34{
46}
47void featureLBPSum(IplImage * img, double * val)
48{
49 double sum=0;
50 IplImage* imgLBP=cvCreateImage( cvSize(img->width,img->height), 8, img->nChannels );
51 int i,j=0;
199
200 IplImage* img=cvLoadImage(fullpath1,0);
201 IplImage* imgLBP=cvCreateImage( cvSize(img->width,img->height), 8, img->nChannels );
259
260IplImage * img = cvLoadImage("abc.jpg",0);
261int Nx = floor((img->width - 10)/10);
adaptiveskindetector.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 415 lines
81 virtual ~ASDFrameSequencer();
82 virtual IplImage *getNextImage();
83 virtual void close();
147
148IplImage *ASDFrameHolder::getImage()
149{
157
158void ASDFrameHolder::setImage(IplImage *sourceImage)
159{
282
283 IplImage* img = cvLoadImage(fileName);
284
307
308static void displayBuffer(IplImage *rgbDestImage, IplImage *buffer, int rValue, int gValue, int bValue)
309{
newfisheye.cpp https://github.com/aiwenar/Eyes.git | C++ | 164 lines
22{
23 bool processMirror(IplImage * src);
24
24
25 void init_mirrors(IplImage * srcExample),
26 sampleImage(const IplImage* arr, double idx0, double idx1, CvScalar& res),
26 sampleImage(const IplImage* arr, double idx0, double idx1, CvScalar& res),
27 fisheye(IplImage*src, double distortion, pair <int, int> center);
28
40
41 IplImage * mirrorL,
42 * mirrorR,
153 mirror mir;
154 IplImage* src = cvLoadImage( argv[1], 1 );
155 IplImage* newd;
fitellipse.cpp https://gitlab.com/juan-cardelino/misc_projects | C++ | 134 lines
30// Load the source image. HighGUI use.
31IplImage *image02 = 0, *image03 = 0, *image04 = 0;
32
39 // load image and force it to be grayscale
40 if( (image03 = cvLoadImage(filename, 0)) == 0 )
41 return -1;
image.cpp https://gitlab.com/jimador/opencv | C++ | 128 lines
12 cout <<
13 "\nThis program shows how to use cv::Mat and IplImages converting back and forth.\n"
14 "It shows reading of images, converting to planes and merging back, color conversion\n"
32#if DEMO_MIXED_API_USE
33 Ptr<IplImage> iplimg(cvLoadImage(imagename)); // Ptr<T> is safe ref-counting pointer class
34 if(!iplimg)
38 }
39 Mat img = cv::cvarrToMat(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
40 // between the old and the new data structures (by default, only the header
42#else
43 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
44 if(img.empty())
90#if DEMO_MIXED_API_USE
91 // it's easy to pass the new matrices to the functions that only work with IplImage or CvMat:
92 // step 1) - convert the headers, data will not be copied
hog_test.cpp https://gitlab.com/B3h3m0th/ccv | C++ | 106 lines
90 assert(argc == 3);
91 IplImage* image = cvLoadImage(argv[1]);
92 CvMat* gray = cvCreateMat(image->height, image->width, CV_8UC1);
latentsvmdetector.cpp https://github.com/SCS-B3C/OpenCV2-2.git | C++ | 125 lines
80
81 IplImage* image = cvLoadImage(img_path.c_str());
82 if (!image)
image.cpp https://bitbucket.org/venuktan/objdetect.git | C++ | 124 lines
13 cout <<
14 "\nThis program shows how to use cv::Mat and IplImages converting back and forth.\n"
15 "It shows reading of images, converting to planes and merging back, color conversion\n"
28#if DEMO_MIXED_API_USE
29 Ptr<IplImage> iplimg = cvLoadImage(imagename); // Ptr<T> is safe ref-conting pointer class
30 if(iplimg.empty())
34 }
35 Mat img(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
36 // between the old and the new data structures (by default, only the header
38#else
39 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
40 if(img.empty())
86#if DEMO_MIXED_API_USE
87 // it's easy to pass the new matrices to the functions that only work with IplImage or CvMat:
88 // step 1) - convert the headers, data will not be copied
fundamental.cpp https://github.com/joshuaeckroth/SURV-I.git | C++ | 394 lines
192
193 IplImage *east = cvLoadImage("../videos/plse1.png");
194 IplImage *west = cvLoadImage("../videos/plsw1.png");
362
363 IplImage *east_trans = cvCreateImage(imgsize, east->depth, east->nChannels);
364 IplImage *west_trans = cvCreateImage(imgsize, west->depth, west->nChannels);
367
368 IplImage *east_trans_8bit = cvCreateImage(imgsize, east->depth, 1);
369 IplImage *west_trans_8bit = cvCreateImage(imgsize, west->depth, 1);
373 CvStereoBMState *bm = cvCreateStereoBMState();
374 IplImage *disparity = cvCreateImage(imgsize, IPL_DEPTH_16S, 1);
375 IplImage *vdisparity = cvCreateImage(imgsize, IPL_DEPTH_8U, 1);
houghlines.c https://gitlab.com/juan-cardelino/misc_projects | C | 62 lines
11 const char* filename = argc >= 2 ? argv[1] : "pic1.png";
12 IplImage* src = cvLoadImage( filename, 0 );
13 IplImage* dst;
13 IplImage* dst;
14 IplImage* color_dst;
15 CvMemStorage* storage = cvCreateMemStorage(0);
interoperability_with_OpenCV_1.cpp https://bitbucket.org/venuktan/objdetect.git | C++ | 134 lines
13 cout << endl << progName
14 << " shows how to use cv::Mat and IplImages together (converting back and forth)." << endl
15 << "Also contains example for image read, spliting the planes, merging back and " << endl
29#ifdef DEMO_MIXED_API_USE
30 Ptr<IplImage> IplI = cvLoadImage(imagename); // Ptr<T> is safe ref-counting pointer class
31 if(IplI.empty())
37#else
38 Mat I = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
39 if( I.empty() ) // same as if( !I.data )
91#ifdef DEMO_MIXED_API_USE
92 // To pass the new matrices to the functions that only work with IplImage or CvMat do:
93 // step 1) Convert the headers (tip: data will not be copied).
95
96 IplImage cv_planes_0 = planes[0], cv_noise = noisyI;
97 cvAddWeighted(&cv_planes_0, contrast_gain, &cv_noise, 1, -128 + brightness_gain, &cv_planes_0);
MovieCreatorService.java https://gitlab.com/victorbotsales/babySelfie | Java | 174 lines
21
22import static org.bytedeco.javacpp.opencv_imgcodecs.cvLoadImage;
23
106 FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(path + "/video.mp4", 768, 1024);
107 OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage();
108
120 for (int i = 0; i < imgCounter; i++) {
121 opencv_core.IplImage img = cvLoadImage(listOfFiles[i].getAbsolutePath());
122 /*
126 */
127// IplImage dest = cvCreateImage(cvSize(768, 1024), img.depth(), img.nChannels());
128// cvResize(img, dest, CV_INTER_NN);
Trajectory.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 323 lines
19
20 IplImage src = cvLoadImage(g[p].getPath(),0);
21
21
22 IplImage tmp = cvLoadImage("d.jpg",0);
23
23
24 IplImage result = cvCreateImage(cvSize(src.width()-tmp.width()+1, src.height()-tmp.height()+1), IPL_DEPTH_32F, 1);
25
158 long xy[][][]= new long[16][10000][2];
159 IplImage src = cvLoadImage("C:/Users/chens_000/Desktop/MM/new9.jpg",0);
160 // IplImage gray = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, 1);
circle_detection.cpp https://gitlab.com/juan-cardelino/misc_projects | C++ | 29 lines
6{
7 IplImage* img = cvLoadImage("view_0002.png", 1);;
8 IplImage* gray = cvCreateImage(cvGetSize(img), 8, 1);
BlobDemo.java https://gitlab.com/cvtung/javacv | Java | 271 lines
39 else if(k == 2) { RawImage = cvLoadImage("Shapes2.jpg"); MinArea = 250; ErodeCount = 0; DilateCount = 1; }
40 else if(k == 3) { RawImage = cvLoadImage("Blob1.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; }
41 else if(k == 4) { RawImage = cvLoadImage("Blob2.jpg"); MinArea = 2800; ErodeCount = 1; DilateCount = 1; }
121 canvas.setCanvasSize(width, height);
122 OpenCVFrameConverter converter = new OpenCVFrameConverter.ToIplImage();
123 canvas.showImage(converter.convert(image));
125
126 public static void Highlight(IplImage image, int [] inVec)
127 {
214 // Counterclockwise small angle rotation by skewing - Does not stretch border pixels
215 public static IplImage SkewGrayImage(IplImage Src, double angle) // angle is in radians
216 {
259
260 public static IplImage TransposeImage(IplImage SrcImage)
261 {
OcvImage.h https://github.com/trainman419/pr2_rubiks_solver.git | C Header | 245 lines
65 inline void toGreyScale(int format) {
66 IplImage *conved = cvCreateImage(cvSize(iplimage->width,iplimage->height),IPL_DEPTH_8U,1);
67 cvCvtColor(iplimage,conved,format);
87 inline void rotate(float cx, float cy, float theta) {
88 IplImage *conved = cvCreateImage(cvSize(iplimage->width, iplimage->height),iplimage->depth, iplimage->nChannels);
89 float m[6];
107 if (destination==NULL)
108 conved = new OcvImage<T>(iplimage->width, iplimage->height,iplimage->depth, iplimage->nChannels);
109 else
127 inline void crop(float removeTop,float removeBottom,float removeLeft, float removeRight) {
128 IplImage *conved = cvCreateImage(cvSize(iplimage->width-removeLeft-removeRight, iplimage->height-removeTop-removeBottom),iplimage->depth, iplimage->nChannels);
129 float m[6];
178
179 roi.iplimage->imageData=iplimage->imageData+y*iplimage->widthStep+x*iplimage->nChannels;
180 roi.iplimage->widthStep=iplimage->widthStep;
histogram_tut.cpp https://bitbucket.org/iankits/opencv_development.git | C++ | 158 lines
40
41 IplImage* src;
42 if( argc == 2 && (src=cvLoadImage(argv[1], 1))!= 0) {
44 //
45 IplImage* hsv = cvCreateImage( cvGetSize(src), 8, 3 );
46 cvCvtColor( src, hsv, CV_BGR2HSV );
46 cvCvtColor( src, hsv, CV_BGR2HSV );
47 IplImage* h_plane = cvCreateImage( cvGetSize(src), 8, 1 );
48 IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );
48 IplImage* s_plane = cvCreateImage( cvGetSize(src), 8, 1 );
49 IplImage* v_plane = cvCreateImage( cvGetSize(src), 8, 1 );
50 IplImage* planes[] = { h_plane, s_plane };
74 int scale = 10;
75 IplImage* hist_img = cvCreateImage(
76 cvSize( h_bins * scale, s_bins * scale ),
ComponentHSVBackgroundSubtractionColor.cpp https://github.com/roboshepherd/swistrackplus.git | C++ | 148 lines
28 if (filename.IsOk()) {
29 mBackgroundImage = cvLoadImage(filename.GetFullPath().mb_str(wxConvFile), CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR);
30 }
54void THISCLASS::OnStep() {
55 IplImage *inputimage = mCore->mDataStructureImageColor.mImage;
56 //Check the images
87 //Make a temporary clone of the image in 3 seperate channels
88 IplImage* tmpImage[3];
89 for (int i = 0;i < 3;i++)
extract.h http://nise.googlecode.com/svn/trunk/ | C Header | 338 lines
57class Image {
58 IplImage *cv;
59
76 scale = 1.0;
77 cv = cvLoadImage(path.c_str(), color ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);
78 //BOOST_VERIFY(cv != 0);
102 }
103 IplImage *old = cv;
104 cv = cvCreateImage(size, old->depth, old->nChannels);
135 }
136 IplImage *old = cv;
137 cv = cvCreateImage(size, old->depth, old->nChannels);
main.cpp https://github.com/kaorun55/kinect_sdk_sandbox.git | C++ | 158 lines
59 ::cvNamedWindow( windowName );
60 cv::Ptr< IplImage > videoImg = ::cvCreateImage( cvSize(video.Width(), video.Height()), IPL_DEPTH_8U, 4 );
61
62 // 画像を読み込んでKinectにあわせて変換する
63 cv::Ptr< IplImage > face = ::cvLoadImage( "lena.jpg" );
64 cv::Ptr< IplImage > faceImg = ::cvCreateImage( cvSize(face->width, face->height), IPL_DEPTH_8U, 4 );
103 ::cvSetImageROI( videoImg, rect );
104 cv::Ptr< IplImage > resizeImg = ::cvCreateImage( cvSize( rect.width, rect.height), faceImg->depth, faceImg->nChannels );
105 ::cvResize( faceImg, resizeImg );
latentsvmdetect.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 83 lines
20
21static void detect_and_draw_objects( IplImage* image, CvLatentSvmDetector* detector, int numThreads = -1)
22{
58 }
59 IplImage* image = cvLoadImage(image_filename);
60 if (!image)
lottoscan.cpp https://github.com/twelly/OpenCV.git | C++ | 143 lines
80 // Load template fle
81 IplImage* tmpl_0_to_9_img = cvLoadImage(tmpl_0_to_9_img_file, 0);
82
88 // Load ticket image
89 IplImage* lotto_ticket_img = cvLoadImage(lotto_ticket_img_file, 0);
90
95
96 IplImage* tmp_ticket_img = cvCreateImage(cvGetSize(lotto_ticket_img), lotto_ticket_img->depth, 1);
97
BeforeAfter.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 161 lines
84 long xy[][][]= new long[16][10000][2];
85 IplImage src = cvLoadImage("C:/Users/chens_000/Desktop/new2/click.jpg",0);
86 // IplImage gray = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, 1);
main.cpp https://github.com/twelly/OpenCV.git | C++ | 28 lines
7 CvMat* warp_matrix = cvCreateMat(3,3,CV_32FC1);
8 IplImage *src, *dst;
9 float mat_test[4][2] = {96.0f,236.0f,226.0f,305.0f,408.0f,94.0f,498.0f,106.0f};
11
12 if( argc == 2 && ((src=cvLoadImage(argv[1],1)) != 0 ))
13 {
Eigen.java https://gitlab.com/Ap00rvSaxena/FaceRecognition-in-E-Attendance | Java | 57 lines
18import static org.bytedeco.javacpp.opencv_highgui.*;
19import static org.bytedeco.javacpp.opencv_imgcodecs.cvLoadImage;
20import static org.bytedeco.javacpp.opencv_imgproc.*;
41
42 IplImage img=null;
43 int counter = 0;
46 for (File image : imageFiles) {
47 img = cvLoadImage(image.getAbsolutePath());
48 String temp= image.getName();
feature_densedescriptors.cpp https://github.com/makerere-compute/ocula.git | C++ | 129 lines
43
44 IplImage* image;
45 if (strcmp(featuretype,"OpponentSURF")==0 || strcmp(featuretype,"OpponentSIFT")==0) {
45 if (strcmp(featuretype,"OpponentSURF")==0 || strcmp(featuretype,"OpponentSIFT")==0) {
46 image = cvLoadImage(filename);
47 }
48 else {
49 image = cvLoadImage(filename, CV_LOAD_IMAGE_GRAYSCALE );
50 }
Blobs.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 80 lines
24 BufferedImage bimage1 = ImageIO.read(file1);
25 IplImage before = IplImage.createFrom(bimage1);
26
27 BufferedImage bimage2 = ImageIO.read(file2);
28 IplImage after = IplImage.createFrom(bimage2);
29
30
31 IplImage diff = IplImage.createCompatible(before);
32
32
33 IplImage src = cvLoadImage("example.jpg");
34 cvAbsDiff(before, after, diff);
35
36 IplImage diffg = IplImage.create(cvGetSize(before),8,1);
37 opencv_imgproc.cvCvtColor(diff, diffg, CV_RGB2GRAY);
OpenCVImage.cpp https://gitlab.com/jimador/Online_Adaptive_Multi-Object_Tracking | C++ | 261 lines
8 ReadColorImage(fname,rgbImage,paddedX,paddedY);
9 IplImage *image=rgbImage->getIplImage();
10 ncols=image->width;
22 IplImage *image,*image_b;
23 image=cvLoadImage(fname);
24 if(image==NULL)
42 assert(rgbImage!=NULL&&rgbImage->getIplImage()!=NULL);
43 IplImage *image=rgbImage->getIplImage();
44 if(!cvSaveImage(fname,image))
59 assert(rgbImage!=NULL&&img!=NULL);
60 IplImage *iplImg=rgbImage->getIplImage();
61 IplImage *greyImg=cvCreateImage(cvSize(iplImg->width,iplImg->height),iplImg->depth,1);
108 assert(Patch!=NULL);
109 IplImage *patch=Patch->getIplImage();
110 assert(patch!=NULL&&histVector!=NULL);
main_v3_SetForOpenCV.cpp https://bitbucket.org/lokisnake/setopencv | C++ | 238 lines
31// IMAGES
32IplImage* source_frame = NULL;
33IplImage* raw_image = NULL;
33IplImage* raw_image = NULL;
34IplImage* draw_image = NULL;
35IplImage* binary_image = NULL;
141 if (file_is_present (BUFFER)) // from file_handling.h
142 source_frame = cvLoadImage( BUFFER ); // grab the file if it's present
143 else if (source_frame != NULL)
feature_densesift.cpp https://github.com/makerere-compute/ocula.git | C++ | 125 lines
43
44 IplImage* image = cvLoadImage(filename, CV_LOAD_IMAGE_GRAYSCALE );
45
faceRecognition.cpp https://hg.codeplex.com/facecomparerdis | C++ | 434 lines
136 int i=0;
137 IplImage *bigImg;
138 IplImage *smallImg;
150 fscanf_s(fp,"%s\n",sPath, PATH_MAX_LEN);
151 bigImg = cvLoadImage(sPath, 0);
152 assert(bigImg != NULL);
Face.cpp https://gitlab.com/shinvdu/rcs-db | C++ | 69 lines
15
16int detect_and_draw_faces( IplImage* image, CvHaarClassifierCascade* cascade)
17{
41 CvHaarClassifierCascade *classifier = NULL;
42 IplImage* image = NULL;
43 int faces;
50
51 image = cvLoadImage( input_file );
52 if (image == NULL) {
test_chesscorners_timing.cpp https://gitlab.com/Ruggero/SparkEngine_Desktop | C++ | 184 lines
68
69 IplImage* img = 0;
70 IplImage* gray = 0;
70 IplImage* gray = 0;
71 IplImage* thresh = 0;
72
107
108 img = cvLoadImage( filename );
109
tp2diff.c https://bitbucket.org/a0viedo/orga2tp2.git | C | 195 lines
86 // Cargo las imagenes
87 IplImage *src_a = 0;
88 IplImage *src_b = 0;
88 IplImage *src_b = 0;
89 IplImage *dst = 0;
90 int width;
92
93 if( (src_a = cvLoadImage (filename_a, CV_LOAD_IMAGE_GRAYSCALE)) == 0 )
94 {
99
100 if( (src_b = cvLoadImage (filename_b, CV_LOAD_IMAGE_GRAYSCALE)) == 0 )
101 {
118
119 // Creo una IplImage para cada salida esperada
120 if( (dst = cvCreateImage (cvGetSize(src_a), IPL_DEPTH_8U, 1) ) == 0 ) {
try.c https://bitbucket.org/jialongl/pad.git | C | 117 lines
12 char window_name[] = "try";
13 IplImage *averaged;
14 CvSize imgSize;
18
19 IplImage* imgReds[N_IMAGES];
20 IplImage* imgGreens[N_IMAGES];
20 IplImage* imgGreens[N_IMAGES];
21 IplImage* imgBlues[N_IMAGES];
22
23 for (int i=0;i<N_IMAGES;i++) {
24 IplImage* img;
25 char filename[8];
26 sprintf(filename, "%d.jpg", (i+1));
27 img = cvLoadImage(filename, CV_LOAD_IMAGE_COLOR);
28 imgReds[i] = cvCreateImage(cvGetSize(img), 8, 1);
EnrollDlg.cpp http://facerecog.googlecode.com/svn/trunk/ | C++ | 359 lines
20 m_thrdFace = NULL;
21 noface = cvLoadImage("noface.bmp");
22}
141
142 IplImage *pic1 = cvCloneImage(m_frame);
143 m_lstPic.AddTail(pic1);
filter_test.cpp https://gitlab.com/B3h3m0th/ccv | C++ | 25 lines
8 assert(argc == 3);
9 IplImage* image = cvLoadImage(argv[1]);
10 CvMat* gray = cvCreateMat(image->height, image->width, CV_32FC1);
dft.c https://gitlab.com/juan-cardelino/misc_projects | C | 139 lines
66 const char* filename = argc >=2 ? argv[1] : "lena.jpg";
67 IplImage * im;
68
68
69 IplImage * realInput;
70 IplImage * imaginaryInput;
70 IplImage * imaginaryInput;
71 IplImage * complexInput;
72 int dft_M, dft_N;
73 CvMat* dft_A, tmp;
74 IplImage * image_Re;
75 IplImage * image_Im;
77
78 im = cvLoadImage( filename, CV_LOAD_IMAGE_GRAYSCALE );
79 if( !im )
findLocation.cpp https://github.com/yianni/cappocacciaactivevision.git | C++ | 216 lines
48
49 frame_temp = (IplImage*)image->getIplImage();
50
69 system("/home/gabriele/siftWin32.exe <object.pgm >tmp1.txt");
70 IplImage *image1 = cvLoadImage("object.pgm");
71
113
114 frame_temp = (IplImage*)image->getIplImage();
115
128 system("/home/gabriele/siftWin32.exe <object_test.pgm >tmp2.txt");
129 IplImage *image2 = cvLoadImage("object_test.pgm");
130 FILE* fp1new=fopen("tmp2.txt","rb");
159 //matching
160 //IplImage *imagematch = cvLoadImage("blue2.pgm");
161 float *bestmatchx = (float*)malloc(sizeof(float)*temp1);
main.cpp https://github.com/straiki/VisionCup-Deep-Team.git | C++ | 118 lines
30 for(;;){
31 IplImage *image = video->next_frame();
32
104 // detect.DrawSezOblic();
105//img = cvLoadImage("test/1.jpg");
106// detect.setFrame(img);
david_scanner.cc https://github.com/AsherBond/MondocosmOS.git | C++ | 628 lines
89 //loading an empty frame
90 IplImage* image_empty;
91 IplImage* image;
93 sprintf(empty_name,"%s/%08d.ppm",path,empty);
94 if ((image_empty=cvLoadImage(empty_name,1))==NULL){
95 cout<<"Cannot load empty frame...check input name"<<endl;
195 cout<<name<<endl;
196 if ((image =cvLoadImage(name))==NULL){
197 cout<<"cannot load image: "<<name<<endl;
200 //do difference between current frame and the empty frame with no laser
201 IplImage* diff = cvCloneImage(image);
202 cvAbsDiff(image_empty, image, diff);
244 int threshold = 50; //original threshold for Hough transform, incremented if too many groups of lines found
245 IplImage* color_dst;
246 IplImage* tmpImage;
iplimage.cpp https://github.com/jordoh/ruby-opencv.git | C++ | 576 lines
15 *
16 * IplImage is subclass of CvMat. IplImage support ROI(region of interest) and COI(color of interest).
17 * Most of CvMat method support ROI, and some of CvMat method support COI.
25__NAMESPACE_BEGIN_OPENCV
26__NAMESPACE_BEGIN_IPLIMAGE
27
129 IplImage *image;
130 if ((image = cvLoadImage(StringValueCStr(filename), _iscolor)) == NULL) {
131 rb_raise(rb_eStandardError, "file does not exist or invalid format image.");
232 else {
233 cvSetImageCOI(IPLIMAGE(self), NUM2INT(coi));
234 }
258 * call-seq:
259 * IplImage.smoothness(<i>lowFreqRatio, blankDensity, messyDensity, highFreqRatio</i>) -> [ symbol, float, float ]
260 *
MYdisplay.cpp https://github.com/straiki/VisionCup-Deep-Team.git | C++ | 56 lines
14// bez odkliknuti
15char MYdisplay::ShowImage(IplImage * image, const char * winName, int x, int y){
16 if( image != NULL){
21
22char MYdisplay::ShowImage(IplImage * image, char cvKey, const char * winName,int x, int y){
23 if( image != NULL){
43
44void MYdisplay::DrawPoint(IplImage * image, CvPoint P, int delka, int tloustka, CvScalar barva){
45 cvLine(image,cvPoint(P.x-delka,P.y),cvPoint(P.x+delka,P.y),barva,tloustka,8,0);
48
49int MYdisplay::LoadImage(IplImage** image,const char * imgPath){
50 *image = cvLoadImage(imgPath);
background.cpp http://moya-kinect.googlecode.com/svn/trunk/ | C++ | 162 lines
16
17bool transBackground( IplImage *initImage, IplImage *endImage, IplImage *dstImage, int startTime, int endTime, int currentTime){
18 //int startTime = ;
44
45void initScrollBackground( IplImage* scrollImage, IplImage* bgImage, IplImage* endImage, int *backnum, bool *bScrollBackground, int *startCount, int *endCount, int count, string dir_path){
46 initScrollBackground( scrollImage, bgImage, endImage, backnum, bScrollBackground, startCount, endCount, count, dir_path, SCROLL_TIME);
49// ?????????????
50void initScrollBackground( IplImage* scrollImage, IplImage* bgImage, IplImage* endImage, int *backnum, bool *bScrollBackground, int *startCount, int *endCount, int count, string dir_path, int time){
51 *bScrollBackground = 1;
77// ??????????????
78void initTransBackground( IplImage* initImage, IplImage** endImage, IplImage* bImage, int *backnum, bool *bTransBackground, int *startCount, int *endCount, int count, string dir_path){
79 initTransBackground( initImage, endImage, bImage, backnum, bTransBackground, startCount, endCount, count, dir_path, TRANS_TIME);
141
142bool startChangeBackground( IplImage* scrollImage, IplImage* bgImage, IplImage* startImage, IplImage** endImage,
143 int *backnum, bool *bTransBackground, bool *bScrollBackground, int *startCount, int *endCount, int count, string dir_path, std::vector<BgElement>* bgList){
fitline.cpp https://gitlab.com/tomtana/PalletDetectionCpp | C++ | 73 lines
33{
34 //IplImage *inputImage=NULL;
35 Image<uchar> *inputImage=NULL;
52
53 //inputImage = cvLoadImage(imageName.c_str(),0);
54 inputImage = ImageIO::LoadPGM(imageName.c_str());
sift.cpp git://pkgs.fedoraproject.org/fawkes | C++ | 259 lines
101 //#endif
102 __obj_img = cvLoadImage( object_file, 1 );
103 if ( ! __obj_img ) {
168 //#endif
169 //std::cout << "SiftClassifier(classify): convert frame to IplImage" << std::endl;
170 convert(YUV422_PLANAR, BGR, _src, (unsigned char *)__image->imageData, _width, _height);
image.cpp https://github.com/SCS-B3C/OpenCV2-2.git | C++ | 125 lines
14 cout <<
15 "\nThis program shows how to use cv::Mat and IplImages converting back and forth.\n"
16 "It shows reading of images, converting to planes and merging back, color conversion\n"
29#if DEMO_MIXED_API_USE
30 Ptr<IplImage> iplimg = cvLoadImage(imagename); // Ptr<T> is safe ref-conting pointer class
31 if(iplimg.empty())
35 }
36 Mat img(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
37 // between the old and the new data structures (by default, only the header
39#else
40 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
41 if(img.empty())
87#if DEMO_MIXED_API_USE
88 // it's easy to pass the new matrices to the functions that only work with IplImage or CvMat:
89 // step 1) - convert the headers, data will not be copied
OpenCVThresholdAndExtractBlobs.cpp http://icode-mda.googlecode.com/svn/trunk/ | C++ | 199 lines
27
28 // Declare 4 IplImages
29 IplImage* sourceImg;
29 IplImage* sourceImg;
30 IplImage* colorThresh;
31 IplImage* gray;
31 IplImage* gray;
32 IplImage* grayThresh;
33 // Declare and set thresholds
38 // Load source image
39 sourceImg = cvLoadImage(argv[1], 1);
40
86 // Image containing binary blob image.
87 IplImage *inputBlob = cvCreateImage(cvSize(grayThresh->width+2,grayThresh->height+2),IPL_DEPTH_8U,1);
88 IplImage *blobMask = cvCreateImage(cvSize(grayThresh->width, grayThresh->height), IPL_DEPTH_8U, 1);
main.cpp https://github.com/itrufeng/learncv.git | C++ | 50 lines
11 // intit
12 IplImage *srcImage;
13 cvNamedWindow("srcImage",CV_WINDOW_AUTOSIZE);
13 cvNamedWindow("srcImage",CV_WINDOW_AUTOSIZE);
14 IplImage *erodeImage;
15 cvNamedWindow("erodeImage",CV_WINDOW_AUTOSIZE);
15 cvNamedWindow("erodeImage",CV_WINDOW_AUTOSIZE);
16 IplImage *dilateImage;
17 cvNamedWindow("dilateImage",CV_WINDOW_AUTOSIZE);
17 cvNamedWindow("dilateImage",CV_WINDOW_AUTOSIZE);
18 IplImage *gaojiImage;
19 cvNamedWindow("gaojiImage",CV_WINDOW_AUTOSIZE);
22 // load image
23 srcImage = cvLoadImage(argv[1],CV_LOAD_IMAGE_ANYCOLOR);
24 cvShowImage("srcImage",srcImage);
loadcvimage.cpp https://github.com/yianni/cappocacciaactivevision.git | C++ | 136 lines
23
24 IplImage* tempimg = cvLoadImage( filename.c_str(), -1);
25 if(!tempimg) { std::cerr << "LoadCVImage::load()::ERROR::ERROR opening file [" << filename << "]\n"; return NULL; }
51 cvReleaseImage(&tempimg);
52 if(tempimg) { std::cerr << "LoadCVImage::load()::ERROR::Failed to release IplImage\n"; return NULL; }
53
57
58CVImage* LoadCVImage::load(IplImage* InputImage) {
59 if(m_checkfileexistence) {
64
65 IplImage* tempimg = cvCloneImage(InputImage);
66 if(!tempimg) { std::cerr << "LoadCVImage::load()::ERROR::ERROR opening file ]\n"; return NULL; }
92 cvReleaseImage(&tempimg);
93 if(tempimg) { std::cerr << "LoadCVImage::load()::ERROR::Failed to release IplImage\n"; return NULL; }
94
MovieCreator.java https://gitlab.com/victorbotsales/babySelfie | Java | 119 lines
20
21import static org.bytedeco.javacpp.opencv_imgcodecs.cvLoadImage;
22
54 FFmpegFrameRecorder recorder = new FFmpegFrameRecorder("file://" + path + "/video.mp4", 768, 1024);
55 OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage();
56
68 for (int i = 0; i < imgCounter; i++) {
69 opencv_core.IplImage img = cvLoadImage(listOfFiles[i].getAbsolutePath());
70// long time = (i+1) * imageTime;
label.cpp https://github.com/jgrogers/Door-Sign-Detection.git | C++ | 204 lines
72//returns bw image resized, also resizes source image
73void DrawCurrentRects(IplImage* img, const std::vector<CvRect>& pos,
74 const std::vector<CvRect>& neg) {
157 full_name.c_str());
158 IplImage* img_in = cvLoadImage(full_name.c_str());
159 IplImage* img_bw = TrainPrepImage(img_in);
161 do {
162 IplImage* img = cvCloneImage(img_in);
163 DrawCurrentRects(img, pos,neg);
FaceMngr_complete.cpp http://facerecog.googlecode.com/svn/trunk/ | C++ | 429 lines
56{
57 IplImage *tpic8 = NULL;
58 bool isrgb = false;
65 }
66 else tpic8 = (IplImage *)pic;
67
114 CString path = strPath;
115 IplImage *pic = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
116 if (!pic) return false;
174 CString path = m_rtPath + (iter->picPath).TrimLeft('\\');
175 IplImage *pic = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
176 if (!pic) continue; // ??????
319 path += testIter->picPath;
320 IplImage *img = cvLoadImage(path, CV_LOAD_IMAGE_GRAYSCALE);
321 if (! PicRecognize(img, flag, &info))
contours.cpp https://gitlab.com/vyablokov/opencvtest | C++ | 40 lines
12
13 IplImage *img = cvLoadImage(argv[1]);
14 IplImage *bin_img = cvCreateImage(cvGetSize(img), 8, 1);
DLL.cpp https://github.com/makerere-compute/ocula.git | C++ | 196 lines
102
103 IplImage* object = cvLoadImage( in_file);
104 CvSeq *objectKeypoints = 0, *objectDescriptors = 0;
111
112 IplImage* imcolour;
113
151
152 IplImage* img = cvCreateImage(cvGetSize(object), IPL_DEPTH_8U, 1);
153 cvCvtColor(object, img, CV_BGR2GRAY);
154
155 IplImage* bigimage=cvCreateImage(cvSize(640,480), IPL_DEPTH_8U, 1);
156 cvResize(img,bigimage,0);
reading_and_writing_images_and_video.rst git://pkgs.fedoraproject.org/opencv | ReStructuredText | 535 lines
11
12.. ocv:cfunction:: IplImage* cvDecodeImage( const CvMat* buf, int iscolor=CV_LOAD_IMAGE_COLOR)
13
59
60.. ocv:cfunction:: IplImage* cvLoadImage( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
61
61
62.. ocv:cfunction:: CvMat* cvLoadImageM( const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR )
63
307
308.. ocv:cfunction:: IplImage* cvRetrieveFrame( CvCapture* capture, int streamIdx=0 )
309
326
327.. ocv:cfunction:: IplImage* cvQueryFrame(CvCapture* capture)
328
warp.cpp https://github.com/joshuaeckroth/SURV-I.git | C++ | 55 lines
9 CvMat* warp_matrix = cvCreateMat(3,3,CV_32FC1);
10 IplImage *src, *dst;
11if( argc == 2 && ((src=cvLoadImage(argv[1],1)) != 0 )) {
tp2diff.c https://gitlab.com/mcaravario/orga2-tps | C | 202 lines
90 // Cargo las imagenes
91 IplImage *src_a = 0;
92 IplImage *src_b = 0;
92 IplImage *src_b = 0;
93 IplImage *dst = 0;
94 int width;
96
97 if( (src_a = cvLoadImage (filename_a, CV_LOAD_IMAGE_UNCHANGED)) == 0 )
98 {
103
104 if( (src_b = cvLoadImage (filename_b, CV_LOAD_IMAGE_UNCHANGED)) == 0 )
105 {
122
123 // Creo una IplImage para cada salida esperada
124 if( (dst = cvCreateImage (cvGetSize(src_a), IPL_DEPTH_8U, 1) ) == 0 ) {
irtkFileOpenCVToImage.cc https://gitlab.com/mariadeprez/irtk-public | C++ | 62 lines
27{
28 IplImage *pimage = NULL;
29 pimage= cvLoadImage(filename,0);
39 _pimage = NULL;
40 _pimage= cvLoadImage(filename,0);
41
ImageReader.java https://github.com/ptII/ptII.git | Java | 119 lines
29
30import static name.audet.samuel.javacv.jna.highgui.cvLoadImage;
31import name.audet.samuel.javacv.jna.cxcore.IplImage;
97 if (_image == null) {
98 _image = cvLoadImage(pathNameString, 1);
99 if (_image == null) {
117
118 private IplImage _image;
119}
MyCapture.cpp https://github.com/p1r4nh4/CellTrack.git | C++ | 133 lines
8 files = files_;
9 if(!(frame = cvLoadImage(files[0].mb_str()))){
10 wxLogError(_T("Failed to read image file [ %s ]. Corrupt file or unsupported codec."), files[0].c_str());
73// image parameters from frame obtained upon the first queryFrame call.
74IplImage* MyCapture::queryFrame(int pos_){
75 if (!step) {
80}
81IplImage* MyCapture_Files::queryFrame(int pos_)
82{
91 }
92 if (!(frame = cvLoadImage(files[pos].mb_str()))) {
93 wxLogError(_T("Failed to read image file [ %s ]. Corrupt file or unsupported codec. Frame %d is replaced with a blank image."), files[0].c_str(), pos);
98}
99IplImage* MyCapture_Movie::queryFrame(int pos_){
100 if ( pos_ >= 0 )
LibFace.cpp git://pkgs.fedoraproject.org/digikam | C++ | 480 lines
150{
151 IplImage* image = LibFaceUtils::charToIplImage(arr, width, height, step, depth, channels);
152 return d->detectionCore->detectFaces(image);
183{
184 IplImage* img = cvLoadImage(filename.data(), CV_LOAD_IMAGE_GRAYSCALE); // grayscale
185 return this->recognise(img, faces, scaleFactor);
247{
248 IplImage* img = LibFaceUtils::charToIplImage(arr, width, height, step, depth, channels);
249 return this->recognise(img, faces, scaleFactor);
383{
384 IplImage* img = LibFaceUtils::charToIplImage(arr, width, height, step, depth, channels);
385 return this->update(img, faces, scaleFactor);
389{
390 IplImage* img = cvLoadImage(filename.data(), CV_LOAD_IMAGE_GRAYSCALE); //grayscale
391 return this->update(img, faces, scaleFactor);
ffilldemo.c https://gitlab.com/juan-cardelino/misc_projects | C | 187 lines
13
14IplImage* color_img0;
15IplImage* mask;
15IplImage* mask;
16IplImage* color_img;
17IplImage* gray_img0 = NULL;
17IplImage* gray_img0 = NULL;
18IplImage* gray_img = NULL;
19int ffill_case = 1;
73
74 if( (color_img0 = cvLoadImage(filename,1)) == 0 )
75 return 0;
calcsurf.cpp https://github.com/makerere-compute/ocula.git | C++ | 67 lines
35 CvMemStorage* storage = cvCreateMemStorage(0);
36 IplImage* image = cvLoadImage(filename, CV_LOAD_IMAGE_GRAYSCALE );
37 CvSeq *objectKeypoints = 0, *objectDescriptors = 0;
Thinkingtime_special.java https://bitbucket.org/yan_chen/pc-image-processing.git | Java | 362 lines
19
20 IplImage src = cvLoadImage(g[p].getPath(),0);
21
23 {
24 IplImage tmp1 = cvLoadImage("e.jpg",0);
25 IplImage result1 = cvCreateImage(cvSize(src.width()-tmp1.width()+1, src.height()-tmp1.height()+1), IPL_DEPTH_32F, 1);
48 }
49 IplImage tmp = cvLoadImage("d.jpg",0);
50
50
51 IplImage result = cvCreateImage(cvSize(src.width()-tmp.width()+1, src.height()-tmp.height()+1), IPL_DEPTH_32F, 1);
52 cvZero(result);
eigenfacerecognizer.cpp https://gitlab.com/CarlosRA97/visual-control | C++ | 224 lines
92 //allocate space for an IplImage array
93 images = (IplImage **) cvAlloc(sizeof(IplImage *) * numTrainedImages);
94
98 {
99 images[currentImage] = cvLoadImage(current->first.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
100
134
135 eigenVectors = (IplImage**)cvAlloc(sizeof(IplImage*) * numEigenvalues);
136
170
171 IplImage faceToRecognize = (IplImage) face;
172 //IplImage *faceToRecognize = cvLoadImage("s1/1.pgm", CV_LOAD_IMAGE_GRAYSCALE);
RecogDlg.cpp http://facerecog.googlecode.com/svn/trunk/ | C++ | 288 lines
18 m_thrdMatch = NULL;
19 noface = cvLoadImage("noface.bmp");
20 resss = cvLoadImage("result.bmp");
123
124 IplImage *ming = cvLoadImage(matchInfo.picPath);
125 if (!ming) ming = cvLoadImage("noimage.bmp"); // ????????
182 CString path = fileDlg.GetPathName();
183 IplImage *queryimg = cvLoadImage(path, CV_LOAD_IMAGE_COLOR);
184 if (!queryimg) return;
227 // ??????
228 IplImage *mimg = cvLoadImage(matchInfo.picPath);
229 if (!mimg) mimg = cvLoadImage("noimage.bmp");
cvtest2.c https://github.com/i03nomura1y/Sample.git | C | 75 lines
16 float *ranges[] = { range_0 };
17 IplImage *src_img = 0, *dst_img[4] = { 0, 0, 0, 0 }, *hist_img;
18 CvHistogram *hist;
21 if(argc < 2 ||
22 (src_img = cvLoadImage(argv[1], CV_LOAD_IMAGE_ANYCOLOR)) == 0){
23 fprintf(stderr,"Usage: $ %s img_file\n",argv[0]);
distrans.c https://gitlab.com/juan-cardelino/misc_projects | C | 189 lines
18// The output and temporary images
19IplImage* dist = 0;
20IplImage* dist8u1 = 0;
20IplImage* dist8u1 = 0;
21IplImage* dist8u2 = 0;
22IplImage* dist8u = 0;
22IplImage* dist8u = 0;
23IplImage* dist32s = 0;
24
24
25IplImage* gray = 0;
26IplImage* edge = 0;
26IplImage* edge = 0;
27IplImage* labels = 0;
28
main.cpp https://github.com/yianni/imagepublisher.git | C++ | 119 lines
78 vector<string> filenames;
79 IplImage *img = NULL;
80 CvFont font;
97 for (vector<string>::iterator itr = filenames.begin(); itr != filenames.end(); ++itr) {
98 img = cvLoadImage(itr->c_str());
99 if(!img)
AAM_Basic.cpp https://github.com/sreedal/GC.git | C++ | 375 lines
121 {
122 IplImage* image = cvLoadImage(img_files[i].c_str(), -1);
123 AAM_Shape Shape;
191//============================================================================
192double AAM_Basic::EstResidual(const IplImage* image, const CvMat* c_q,
193 CvMat* s, CvMat* t_m,
224//============================================================================
225void AAM_Basic::InitParams(const IplImage* image)
226{
239//============================================================================
240void AAM_Basic::Fit(const IplImage* image, AAM_Shape& Shape,
241 int max_iter /* = 30 */,bool showprocess /* = false */)
248 int k;
249 IplImage* Drawimg = 0;
250
opencv_demo_thumb.cpp https://bitbucket.org/m4271n/opencv.git | C++ | 102 lines
18 printf("Load Image \r\n");
19 IplImage *src = cvLoadImage( lettername, CV_LOAD_IMAGE_COLOR );
20
31 printf("Convert to greyscale\r\n");
32 IplImage *gsrc = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );
33 cvCvtColor(src,gsrc,CV_RGB2GRAY);
test_chesscorners_timing.cpp git://pkgs.fedoraproject.org/opencv | C++ | 189 lines
68
69 IplImage* img = 0;
70 IplImage* gray = 0;
70 IplImage* gray = 0;
71 IplImage* thresh = 0;
72
107
108 img = cvLoadImage( filename );
109
morphology.c https://gitlab.com/Ruggero/SparkEngine_Desktop | C | 130 lines
5
6IplImage* src = 0;
7IplImage* dst = 0;
81 filename = argc == 2 ? argv[1] : (char*)"baboon.jpg";
82 if( (src = cvLoadImage(filename,1)) == 0 )
83 {
gtk-facemanager.c http://pam-face-authentication.googlecode.com/svn/ | C | 604 lines
55
56IplImage *frame,*frameNew, *frame_copy = 0;
57CvPoint pLeftEye;
72
73void loadCVPIXBUF(GtkWidget *imgCapturedFace,IplImage* image)
74{
101
102 IplImage* image =0;
103 image=cvLoadImage( fullPath, 1 );
284 inpDialog = GTK_WIDGET (gtk_builder_get_object (builder, "dlgSampleFace"));
285 IplImage *face;
286 face = cvCreateImage( cvSize(120,140),8,3);
287 cvZero(face);
288 face=cvLoadImage(fileNameImage("1",value), 1 );
289 if (face!=0)
gtk-facemanager.c http://pam-face-authentication.googlecode.com/svn/ | C | 687 lines
53
54IplImage *frame,*frameNew, *frame_copy = 0;
55CvPoint pLeftEye;
62int (*faceDetect)( IplImage* ,CvPoint *,CvPoint *,CvMemStorage* ,CvMemStorage* ,CvMemStorage* ,CvMemStorage* ,CvHaarClassifierCascade* ,CvHaarClassifierCascade* ,CvHaarClassifierCascade* ,CvHaarClassifierCascade* );
63int (*preprocess)( IplImage* ,CvPoint ,CvPoint, IplImage* );
64void (*learn)();
73
74void loadCVPIXBUF(GtkWidget *imgCapturedFace,IplImage* image)
75{
102
103 IplImage* image =0;
104 image=cvLoadImage( fullPath, 1 );
285 inpDialog = GTK_WIDGET (gtk_builder_get_object (builder, "dlgSampleFace"));
286 IplImage *face;
287 face = cvCreateImage( cvSize(120,140),8,3);
demhist.c https://github.com/hcl3210/opencv.git | C | 125 lines
18float* ranges[] = { range_0 };
19IplImage *src_image = 0, *dst_image = 0, *hist_image = 0;
20CvHistogram *hist;
90 // Load the source image. HighGUI use.
91 src_image = cvLoadImage( argc == 2 ? argv[1] : file_name, 0 );
92
ipl.cpp https://github.com/rodrigob/cudatemplates.git | C++ | 68 lines
32 data with e.g. shared pointers and there the user has to be sure to
33 delete the constructed IplImage and the cudatemplates
34 representation of it in the right order.
41 // read test input image (grayscale mode)
42 IplImage* image_input = cvLoadImage( "cameraman.png", 0);
43
43
44 // create reference to IplImage for use with CUDA classes:
45 Cuda::IplReference<PixelType, 2> host_image_input(image_input);
47 // create empty Ipl output image:
48 IplImage* image_output = cvCreateImage( cvGetSize(image_input) , image_input->depth,
49 image_input->nChannels );
facedetect.cpp https://github.com/usmanghani/Misc.git | C++ | 39 lines
3
4vector<RECT> facedetect (IplImage* image, CvHaarClassifierCascade* cascade)
5{
6 //CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)cvLoad(classifierfilename);
7 //IplImage* image = cvLoadImage(imagefilename);
8 CvMemStorage* storage = cvCreateMemStorage ( );
CVImgUtils.cpp https://code.google.com/p/plinth-engine/ | C++ | 156 lines
98 cv::flip(dimg, dimg2, 0);
99 IplImage bla = dimg2;
100 LOG(logDEBUG) << "Got this far... " << temp.rows << "x" << temp.cols;
113 cv::flip(dimg, dimg2, 0);
114 IplImage bla = dimg2;
115 LOG(logDEBUG) << "Got this far... " << temp.rows << "x" << temp.cols;
126 cv::flip(dimg, dimg2, 0);
127 IplImage bla = dimg2;
128 LOG(logDEBUG) << "Got this far... " << temp.rows << "x" << temp.cols;
136{
137 IplImage* tempImg = cvLoadImage(fn.c_str());
138 cv::Mat loadIm(tempImg); // = cv::imread(fn);
fisheye.cpp https://github.com/aiwenar/Eyes.git | C++ | 132 lines
9
10 void sampleImage(const IplImage* arr, double idx0, double idx1, CvScalar& res)
11 {
74 {
75 IplImage* src = cvLoadImage( argv[1], 1 );
76 IplImage* dst = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
76 IplImage* dst = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
77 IplImage* dst2 = cvCreateImage(cvGetSize(src),src->depth,src->nChannels);
78 double K=atof(argv[3]);
cvtest.c https://github.com/i03nomura1y/Sample.git | C | 47 lines
13int main (int argc, char **argv){
14 IplImage *src_img, *dst_img, *tmp_img;
15
17 if (argc != 2 ||
18 (src_img = cvLoadImage (argv[1], CV_LOAD_IMAGE_GRAYSCALE)) == 0){
19 fprintf(stderr,"Usage: $ %s img_file\n",argv[0]);
edge.c https://gitlab.com/juan-cardelino/misc_projects | C | 70 lines
15
16IplImage *image = 0, *cedge = 0, *gray = 0, *edge = 0;
17
37
38 if( (image = cvLoadImage( filename, 1)) == 0 )
39 return -1;
process_test.cpp http://marine-detection.googlecode.com/svn/trunk/ | C++ | 200 lines
65 char c;
66 IplImage *tempBuf=0;
67 IplImage *in_image;
67 IplImage *in_image;
68 IplImage *processed_image;
69
109
110 tempBuf=cvLoadImage( filename, 1 );
111 imgSize=cvGetSize(tempBuf);
calibrate.cc https://github.com/AsherBond/MondocosmOS.git | C++ | 139 lines
68
69 IplImage *img = cvLoadImage(images[0], CV_LOAD_IMAGE_GRAYSCALE);
70 IplImage *imgColor = cvCreateImage(cvGetSize(img), 8, 3);
88 for(int imagesLoaded = 0; imagesLoaded < loadImageCnt; imagesLoaded++) {
89 img = cvLoadImage(images[imagesLoaded], CV_LOAD_IMAGE_GRAYSCALE);
90
image.cpp https://gitlab.com/dlts/opencv | C++ | 130 lines
12 cout <<
13 "\nThis program shows how to use cv::Mat and IplImages converting back and forth.\n"
14 "It shows reading of images, converting to planes and merging back, color conversion\n"
33 //! [iplimage]
34 Ptr<IplImage> iplimg(cvLoadImage(imagename)); // Ptr<T> is safe ref-counting pointer class
35 if(!iplimg)
39 }
40 Mat img = cv::cvarrToMat(iplimg); // cv::Mat replaces the CvMat and IplImage, but it's easy to convert
41 // between the old and the new data structures (by default, only the header
42 // is converted, while the data is shared)
43 //! [iplimage]
44#else
44#else
45 Mat img = imread(imagename); // the newer cvLoadImage alternative, MATLAB-style function
46 if(img.empty())