IplImage* cvCreateImage(CvSize cvSize(int width, int height), int depth, int channels);
depth:
IPL_DEPTH_8U - 8位无符号整数
IPL_DEPTH_8S - 8位符号整数
IPL_DEPTH_16U - 16位无符号整数
IPL_DEPTH_16S - 16位符号整数
IPL_DEPTH_32S - 32位符号整数
IPL_DEPTH_32F - 单精度浮点数
IPL_DEPTH_64F - 双精度浮点数
channels:
1 / 2 / 3 / 4
参考文档： cvCreateImage函数说明
opencv 2.0:
#include <opencv2/opencv.hpp>
#include <highgui.h>
int main(int argc, char* argv[])
{
cv::Mat img = cv::imread(argv[1]);
if (img.empty())
{
std::cout << "!!! imread() failed to open target image" << std::endl;
return -1;
}
/* Set Region of Interest */
int offset_x = 129;
int offset_y = 129;
cv::Rect roi;
roi.x = offset_x;
roi.y = offset_y;
roi.width = img.size().width - (offset_x*2);
roi.height = img.size().height - (offset_y*2);
/* Crop the original image to the defined ROI */
cv::Mat crop = img(roi);
cv::imshow("crop", crop);
cv::waitKey(0);
cv::imwrite("noises_cropped.png", crop);
return 0;
}
opencv 1.0:
cvNamedWindow("Example", CV_WINDOW_AUTOSIZE);
IplImage* imagergb = cvLoadImage("1.jpg", CV_LOAD_IMAGE_GRAYSCALE);
CvRect drawRect = cvRect(100,100,200,200);
cvSetImageROI(imagergb, drawRect);
IplImage* img_roi = cvCreateImage(cvSize(drawRect.width, drawRect.height), IPL_DEPTH_8U, 1);
cvCopy(imagergb, img_roi);
cvShowImage("Example", img_roi);
cvWaitKey(0);
cvResetImageROI(imagergb);
cvShowImage("Example3", imagergb);
cvWaitKey(0);
cvReleaseImage(&imagergb);
cvReleaseImage(&img_roi);
cvDestroyWindow("Example");
参考文档：
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
#include "cxvideocap.hpp"
bool cropVideo(const char* videoname, CvRect dstRect_) {
CxVideoReader capture_;
if(capture_.load(videoname) == false ) {
std::cout << "InitCapture: failed to load video" << std::endl;
return false;
}
std::string filename = videoname;
filename.erase(filename.rfind('.')); // rfind(".mov")
filename.append("_crop.avi");
CxVideoWriter* writer_ = new CxVideoWriter(filename.c_str(),
capture_.fps(),
CV_FOURCC('D', 'I', 'V', 'X'));
IplImage* frame = capture_.query();
while(!(nullptr == frame || capture_.eof())) {
/* transpose and mirror(flip) to rotate 90 degree */
IplImage* img = nullptr;
if (frame->width > frame->height) {
img = cvCreateImage(cvSize(frame->height, frame->width), IPL_DEPTH_8U, 3);
cvTranspose(frame, img);
} else {
img = cvCreateImage(cvSize(frame->width, frame->height), IPL_DEPTH_8U, 3);
cvCopy(frame,img);
}
cvMirror(img, img, 1);
/* reset realityRect to make width equal to height */
CvRect realityRect = dstRect_;
if (dstRect_.width > dstRect_.height) {
realityRect.height = dstRect_.width;
realityRect.y = dstRect_.y - (abs(dstRect_.height - dstRect_.width) >> 1);
realityRect.y = realityRect.y > 0 ? realityRect.y : 0;
} else {
realityRect.width = dstRect_.height;
realityRect.x = dstRect_.x - (abs(dstRect_.height - dstRect_.width) >> 1);
realityRect.x = realityRect.x > 0 ? realityRect.x : 0;
}
/* reset realityRect according to processed frame */
if (realityRect.x + realityRect.width > img->width) {
realityRect.width = img->width - realityRect.x;
}
if (realityRect.y + realityRect.height > img->height) {
realityRect.height = img->height - realityRect.y;
}
cvSetImageROI(img, realityRect);
IplImage* img_roi = cvCreateImage(cvSize(realityRect.width, realityRect.height), IPL_DEPTH_8U, 3);
cvCopy(img, img_roi);
int crop_w_h = (realityRect.width > realityRect.height) ? realityRect.width : realityRect.height;
IplImage* crop_d = cvCreateImage(cvSize(crop_w_h, crop_w_h), IPL_DEPTH_8U, 3);
int x = realityRect.width > realityRect.height ? 0 : (realityRect.height-realityRect.width)>>1;
int y = realityRect.width > realityRect.height ? (realityRect.width-realityRect.height)>>1 : 0;
CvRect drawRect = cvRect(x, y, realityRect.width, realityRect.height);
cvSetImageROI(crop_d, drawRect);
memset(crop_d->imageData, 0, crop_d->imageSize);
cvCopy(img_roi, crop_d);
cvResetImageROI(crop_d);
writer_->write(crop_d);
cvReleaseImage(&img);
cvReleaseImage(&img_roi);
cvReleaseImage(&crop_d);
frame = capture_.query();
}
capture_.release();
if (nullptr != writer_)
delete writer_;
return true;
}
void cvResize(
const CvArr* src,
CvArr* dst,
Int interpolation = CV_INTER_LINEAR
);
CV_INTER_NN 含义：最近邻插值
CV_INTER_LINER 含义：双线性插值
CV_INTER_AREA 含义：区域插值
CV_INTER_CUBIC 含义：三次样条插值
一般情况下，我们期望源图像和重采样后的目标图像之间的映射尽可能地平滑。参数interpolation就是控制如何进行映射。当缩小图像时，目标图像的像素会映射为源图像中的多个参数，这时需要进行插值。当放大图像时，目标图像上的像素可能无法在源图像中找到精确对应的像素，也需要进行插值。最简单的方法试将目标图像各点的像素值设为源图像中与其距离最近的像素值，这就是当interpolation设为CV_INTER_NN时用的算法。
采用双线性插值算法（CV_INTER_LINER），将根据源图像附件的4个邻近像素的线性加权计算得出，权重由这4个像素到精确目标点的距离决定。
采用区域插值（CV_INTER_AREA）是用新的像素点覆盖原来的像素点，然后求取覆盖区域的平均值。
采用三次样条插值（CV_INTER_CUBIC）是对源图像附件的4X4个邻近像素进行三次样条拟合，然后将目标像素对应的三次样条值作为目标图像对应像素点的值。
#include "cv.h"
#include "cxcore.h"
#include "highgui.h"
int main(int argc, char** argv) {
IplImage *src = cvLoadImage("icon.png");
IplImage *desc;
CvSize sz;
double scale = 0.5;
if(src) {
sz.width = src->width*scale;
sz.height = src->height*scale;
desc = cvCreateImage(sz,src->depth,src->nChannels);
cvResize(src,desc,CV_INTER_CUBIC);
cvNamedWindow("src",CV_WINDOW_AUTOSIZE);
cvNamedWindow("desc",CV_WINDOW_AUTOSIZE);
cvShowImage("src",src);
cvShowImage("desc",desc);
cvWaitKey(0);
cvReleaseImage(&src);
cvReleaseImage(&desc);
cvDestroyWindow("src");
cvDestroyWindow("desc");
return 0;
}
return 0;
}
参考文档：
参考文档：OpenCV学习笔记：绘图操作
#include <cv.h>
#include <highgui.h>
int main()
{
IplImage *Image1;
IplImage *RedImage,*GreenImage,*BlueImage;
IplImage *Channel1,*Channel2,*Channel3;
CvSize Size1;
Image1=cvLoadImage("grotto.jpg",1);
Size1=cvGetSize(Image1);
Channel1=cvCreateImage(Size1,IPL_DEPTH_8U,1);
Channel2=cvCreateImage(Size1,IPL_DEPTH_8U,1);
Channel3=cvCreateImage(Size1,IPL_DEPTH_8U,1);
cvSplit(Image1,Channel1,Channel2,Channel3,0); //分割
BlueImage=cvCreateImage(Size1,IPL_DEPTH_8U,3);
GreenImage=cvCreateImage(Size1,IPL_DEPTH_8U,3);
RedImage=cvCreateImage(Size1,IPL_DEPTH_8U,3);
cvMerge(Channel1,0,0,0,BlueImage); //合并
cvMerge(0,Channel2,0,0,GreenImage);//合并
cvMerge(0,0,Channel3,0,RedImage); //合并
cvNamedWindow("Red pic",1);
cvShowImage("Red pic",RedImage);
cvNamedWindow("Green pic",1);
cvShowImage("Green pic",GreenImage);
cvNamedWindow("Blue pic",1);
cvShowImage("Blue pic",BlueImage);
cvWaitKey(0);
}
参考文档：
参考文档：
参考文档:
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "iostream"
using namespace cv;
using namespace std;
int main( ) {
Mat image;
image = imread("lena.jpg", CV_LOAD_IMAGE_COLOR);
if(! image.data ) {
cout << "Could not open or find the image" << std::endl ;
return -1;
}
// Create a new matrix to hold the gray image
Mat gray;
// convert RGB image to gray
cvtColor(image, gray, CV_BGR2GRAY);
namedWindow( "Display window", CV_WINDOW_AUTOSIZE );
imshow( "Display window", image );
namedWindow( "Result window", CV_WINDOW_AUTOSIZE );
imshow( "Result window", gray );
waitKey(0);
return 0;
}
参考文档： OpenCV example to convert RGB to gray / other color spaces
参考文档: opencv影像读取
参考文档: OpenCV image loading for OpenGL Texture
参考文档: How can I get one single frame from a video file?
/*opencv1.0*/
#include "opencv\cv.h"
#include "opencv\cxcore.h"
#include "opencv\highgui.h"
//#include "opencv\cxvideocap.hpp"
int main(int argc, char* argv[]) {
cvNamedWindow("Example2", CV_WINDOW_AUTOSIZE);
CvCapture* capture = cvCreateFileCapture("IMG_0018.MOV");
int cap_width = (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH);
int cap_height = (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT);
int cap_fps = (int)cvGetCaptureProperty(capture, CV_CAP_PROP_FPS);
IplImage* frame = nullptr;
IplImage* rotate = cvCreateImage(cvSize(cap_height, cap_width), IPL_DEPTH_8U, 3);
CvVideoWriter* writer = cvCreateVideoWriter("new.avi",
CV_FOURCC('M','J','P','G'),
cap_fps,
cvSize(cap_height, cap_width));
while(1) {
frame = cvQueryFrame(capture);
if (!frame) break;
cvTranspose(frame, rotate);
cvFlip(rotate, rotate, 1);
cvShowImage("Example2", rotate);
cvWriteFrame(writer, rotate);
if (cvWaitKey(33) == 27) break;
}
cvReleaseImage(&rotate);
cvReleaseCapture(&capture);
cvReleaseVideoWriter(&writer);
cvDestroyWindow("Example2");
return 0;
}
/*opencv2.0*/
#include "opencv2\opencv.hpp"
int main() {
cv::namedWindow("Example2", CV_WINDOW_AUTOSIZE);
cv::VideoCapture vc;
if (!vc.open("IMG_0018.MOV")) {
cv::destroyWindow("Example2");
return 1;
}
cv::VideoWriter wr;
if (!wr.open("new.MOV", CV_FOURCC('m','p','4','v'), vc.get(CV_CAP_PROP_FPS), cv::Size(480, 640))) {
vc.release();
cv::destroyWindow("Example2");
return 2;
}
cv::Mat frame, rotate, res, roi;
int count = vc.get(CV_CAP_PROP_FRAME_COUNT);
while(1) {
if (vc.get(CV_CAP_PROP_POS_FRAMES) == count)
vc.set(CV_CAP_PROP_POS_FRAMES, 0);
if (!vc.read(frame))
break;
cv::transpose(frame, rotate);
cv::flip(rotate, rotate, 1);
#if 1
// opencv1.0: cvSetImageROI(frame, cvRect(150, 300, 480, 640));
roi = rotate(cv::Rect(150, 300, 480, 640));
cv::imshow("Example2", roi);
wr.write(roi);
if (cv::waitKey(33) == 27) break;
#else
cv::resize(rotate, res, cv::Size(480, 640));
cv::imshow("Example2", res);
wr.write(res);
if (cv::waitKey(10) == 27) break;
#endif
}
wr.release();
vc.release();
cv::destroyWindow("Example2");
return 0;
}
#include <stdio.h>
#include <opencv2/highgui/highgui_c.h>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core/core_c.h>
int main (int argc, const char * argv[])
{
if ( argc != 2 )
{
fprintf(stderr, "Expected 2 arguments. Usage: program <filename>\n");
exit(1);
}
IplImage* image = cvLoadImage(argv[1], CV_LOAD_IMAGE_UNCHANGED);
if ( image == NULL )
{
fprintf(stderr, "Couldn't load image.\n");
exit(1);
}
IplImage* header1 = cvCreateImageHeader( cvSize(20, 30), image->depth, image->nChannels );
IplImage* header2 = cvCreateImageHeader( cvSize(20, 30), image->depth, image->nChannels );
// Point to pixel (5,10)
header1->imageData = image->imageData + (5 * image->nChannels) + (10 * image->widthStep);
header1->origin = image->origin;
header1->widthStep = image->widthStep;
// Point to pixel (50,60)
header2->imageData = image->imageData + (50 * image->nChannels) + (60 * image->widthStep);
header2->origin = image->origin;
header2->widthStep = image->widthStep;
cvNot(header1, header1);
cvNot(header2, header2);
cvNamedWindow("Image", CV_WINDOW_AUTOSIZE);
cvShowImage("Image", image);
cvWaitKey(0);
cvReleaseImage(&image);
cvReleaseImage(&header1);
cvReleaseImage(&header2);
return 0;
}