CV_INLINE void CvvImage::Destroy()
{
cvReleaseImage( &m_img );
}
int main()
{
#ifdef VISP_HAVE_OPENCV
try {
vpVideoReader reader;
reader.setFileName("video-postcard.mpeg");
vpImage<unsigned char> I;
reader.acquire(I);
#if (VISP_HAVE_OPENCV_VERSION < 0x020408)
IplImage * cvI = NULL;
#else
cv::Mat cvI;
#endif
vpImageConvert::convert(I, cvI);
// Display initialisation
vpDisplayOpenCV d(I, 0, 0, "Klt tracking");
vpDisplay::display(I);
vpDisplay::flush(I);
vpKltOpencv tracker;
// Set tracker parameters
tracker.setMaxFeatures(200);
tracker.setWindowSize(10);
tracker.setQuality(0.01);
tracker.setMinDistance(15);
tracker.setHarrisFreeParameter(0.04);
tracker.setBlockSize(9);
tracker.setUseHarris(1);
tracker.setPyramidLevels(3);
// Initialise the tracking
tracker.initTracking(cvI);
while ( ! reader.end() )
{
reader.acquire(I);
std::cout << "acquire image " << reader.getFrameIndex() << std::endl;
vpDisplay::display(I);
vpImageConvert::convert(I, cvI);
//! [Re-init tracker]
// Restart the initialization to detect new keypoints
if (reader.getFrameIndex() == 25) {
std::cout << "Re initialize the tracker" << std::endl;
#if (VISP_HAVE_OPENCV_VERSION >= 0x020408)
// Save of previous features
std::vector<cv::Point2f> prev_features = tracker.getFeatures();
// Start a new feature detection
tracker.initTracking(cvI);
std::vector<cv::Point2f> new_features = tracker.getFeatures();
// Add previous features if they are not to close to detected one
double distance, minDistance_ = tracker.getMinDistance();
bool is_redundant;
for (size_t i=0; i < prev_features.size(); i++) {
// Test if a previous feature is not redundant with one of the newly detected
is_redundant = false;
for (size_t j=0; j < new_features.size(); j++){
distance = sqrt(vpMath::sqr(new_features[j].x-prev_features[i].x) + vpMath::sqr(new_features[j].y-prev_features[i].y));
if(distance < minDistance_){
is_redundant = true;
break;
}
}
if(is_redundant){
continue;
}
//std::cout << "Add previous feature with index " << i << std::endl;
tracker.addFeature(prev_features[i]);
}
#else
// Save of previous features
int prev_nfeatures = tracker.getNbFeatures();
float x,y;
long id;
int j=0;
CvPoint2D32f *prev_features = (CvPoint2D32f*)cvAlloc(prev_nfeatures*sizeof(CvPoint2D32f));
for (int i=0; i <prev_nfeatures ; i ++) {
tracker.getFeature(i, id, x, y);
prev_features[i].x=x;
prev_features[i].y=y;
//printf("prev feature %d: id %d coord: %g %g\n", i, id, x, y);
}
// Start a new feature detection
tracker.initTracking(cvI);
std::cout << "Detection of " << tracker.getNbFeatures() << " new features" << std::endl;
// Add previous features if they are not to close to detected one
double distance, minDistance_ = tracker.getMinDistance();
for(int i = tracker.getNbFeatures() ;
j<prev_nfeatures && i<tracker.getMaxFeatures() ;
j++){
// Test if a previous feature is not redundant with new the one that are newly detected
bool is_redundant = false;
for(int k=0; k<tracker.getNbFeatures(); k++){
tracker.getFeature(k,id,x,y);
//printf("curr feature %d: id %d coord: %g %g\n", k, id, x, y);
distance = sqrt(vpMath::sqr(x-prev_features[j].x) + vpMath::sqr(y-prev_features[j].y));
if(distance < minDistance_){
is_redundant = true;
break;
}
}
if(is_redundant){
continue;
}
//std::cout << "Add previous feature with index " << i << std::endl;
tracker.addFeature(i, prev_features[j].x, prev_features[j].y);
i++;
}
cvFree(&prev_features);
#endif
}
// Track the features
tracker.track(cvI);
//! [Re-init tracker]
std::cout << "tracking of " << tracker.getNbFeatures() << " features" << std::endl;
tracker.display(I, vpColor::red);
vpDisplay::flush(I);
}
vpDisplay::getClick(I);
#if (VISP_HAVE_OPENCV_VERSION < 0x020408)
cvReleaseImage(&cvI);
#endif
return 0;
}
catch(vpException &e) {
std::cout << "Catch an exception: " << e << std::endl;
}
#endif
}
bool CvCaptureCAM_DC1394_v2_CPP::initVidereRectifyMaps( const char* info,
IplImage* ml[2], IplImage* mr[2] )
{
float identity_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
CvMat l_rect = cvMat(3, 3, CV_32F, identity_data), r_rect = l_rect;
float l_intrinsic_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
float r_intrinsic_data[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
CvMat l_intrinsic = cvMat(3, 3, CV_32F, l_intrinsic_data);
CvMat r_intrinsic = cvMat(3, 3, CV_32F, r_intrinsic_data);
float l_distortion_data[] = {0,0,0,0,0}, r_distortion_data[] = {0,0,0,0,0};
CvMat l_distortion = cvMat(1, 5, CV_32F, l_distortion_data);
CvMat r_distortion = cvMat(1, 5, CV_32F, r_distortion_data);
IplImage* mx = cvCreateImage(cvGetSize(ml[0]), IPL_DEPTH_32F, 1);
IplImage* my = cvCreateImage(cvGetSize(ml[0]), IPL_DEPTH_32F, 1);
int k, j;
for( k = 0; k < 2; k++ )
{
const char* section_name = k == 0 ? "[left_camera]" : "[right_camera]";
static const char* param_names[] = { "f ", "fy", "Cx", "Cy" "kappa1", "kappa2", "tau1", "tau2", "kappa3", 0 };
const char* section_start = strstr( info, section_name );
CvMat* intrinsic = k == 0 ? &l_intrinsic : &r_intrinsic;
CvMat* distortion = k == 0 ? &l_distortion : &r_distortion;
CvMat* rectification = k == 0 ? &l_rect : &r_rect;
IplImage** dst = k == 0 ? ml : mr;
if( !section_start )
break;
section_start += strlen(section_name);
for( j = 0; param_names[j] != 0; j++ )
{
const char* param_value_start = strstr(section_start, param_names[j]);
float val=0;
if(!param_value_start)
break;
sscanf(param_value_start + strlen(param_names[j]), "%f", &val);
if( j < 4 )
intrinsic->data.fl[j == 0 ? 0 : j == 1 ? 4 : j == 2 ? 2 : 5] = val;
else
distortion->data.fl[j - 4] = val;
}
if( param_names[j] != 0 )
break;
// some sanity check for the principal point
if( fabs(mx->width*0.5 - intrinsic->data.fl[2]) > mx->width*0.1 ||
fabs(my->height*0.5 - intrinsic->data.fl[5]) > my->height*0.1 )
{
cvScale( &intrinsic, &intrinsic, 0.5 ); // try the corrected intrinsic matrix for 2x lower resolution
if( fabs(mx->width*0.5 - intrinsic->data.fl[2]) > mx->width*0.05 ||
fabs(my->height*0.5 - intrinsic->data.fl[5]) > my->height*0.05 )
cvScale( &intrinsic, &intrinsic, 2 ); // revert it back if the new variant is not much better
intrinsic->data.fl[8] = 1;
}
cvInitUndistortRectifyMap( intrinsic, distortion,
rectification, intrinsic, mx, my );
cvConvertMaps( mx, my, dst[0], dst[1] );
}
cvReleaseImage( &mx );
cvReleaseImage( &my );
return k >= 2;
}
// parameters:
// img - input video frame
// dst - resultant motion picture
// args - optional parameters
void update_mhi( IplImage* img, IplImage* dst, int diff_threshold )
{
double timestamp = (double)clock()/CLOCKS_PER_SEC; // get current time in seconds
CvSize size = cvSize(img->width,img->height); // get current frame size
int i, idx1 = last, idx2;
IplImage* silh;
CvSeq* seq;
CvRect comp_rect;
double count;
double angle;
CvPoint center;
double magnitude;
CvScalar color;
// allocate images at the beginning or
// reallocate them if the frame size is changed
if( !mhi || mhi->width != size.width || mhi->height != size.height ) {
if( buf == 0 ) {
buf = (IplImage**)malloc(N*sizeof(buf[0]));
memset( buf, 0, N*sizeof(buf[0]));
}
for( i = 0; i < N; i++ ) {
cvReleaseImage( &buf[i] );
buf[i] = cvCreateImage( size, IPL_DEPTH_8U, 1 );
cvZero( buf[i] );
}
cvReleaseImage( &mhi );
cvReleaseImage( &orient );
cvReleaseImage( &segmask );
cvReleaseImage( &mask );
mhi = cvCreateImage( size, IPL_DEPTH_32F, 1 );
cvZero( mhi ); // clear MHI at the beginning
orient = cvCreateImage( size, IPL_DEPTH_32F, 1 );
segmask = cvCreateImage( size, IPL_DEPTH_32F, 1 );
mask = cvCreateImage( size, IPL_DEPTH_8U, 1 );
}
cvCvtColor( img, buf[last], CV_BGR2GRAY ); // convert frame to grayscale
idx2 = (last + 1) % N; // index of (last - (N-1))th frame
last = idx2;
silh = buf[idx2];
cvAbsDiff( buf[idx1], buf[idx2], silh ); // get difference between frames
cvThreshold( silh, silh, diff_threshold, 1, CV_THRESH_BINARY ); // and threshold it
cvUpdateMotionHistory( silh, mhi, timestamp, MHI_DURATION ); // update MHI
// convert MHI to blue 8u image
cvCvtScale( mhi, mask, 255./MHI_DURATION,
(MHI_DURATION - timestamp)*255./MHI_DURATION );
cvZero( dst );
cvMerge( mask, 0, 0, 0, dst );
// calculate motion gradient orientation and valid orientation mask
cvCalcMotionGradient( mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3 );
printf("Nonzero count %d\n", cvCountNonZero(mask));
if( !storage )
storage = cvCreateMemStorage(0);
else
cvClearMemStorage(storage);
// segment motion: get sequence of motion components
// segmask is marked motion components map. It is not used further
seq = cvSegmentMotion( mhi, segmask, storage, timestamp, MAX_TIME_DELTA );
// iterate through the motion components,
// One more iteration (i == -1) corresponds to the whole image (global motion)
for( i = -1; i < seq->total; i++ ) {
if( i < 0 ) { // case of the whole image
comp_rect = cvRect( 0, 0, size.width, size.height );
color = CV_RGB(255,255,255);
magnitude = 100;
}
else { // i-th motion component
comp_rect = ((CvConnectedComp*)cvGetSeqElem( seq, i ))->rect;
if( comp_rect.width + comp_rect.height < 100 ) // reject very small components
continue;
color = CV_RGB(255,0,0);
magnitude = 30;
}
// select component ROI
cvSetImageROI( silh, comp_rect );
cvSetImageROI( mhi, comp_rect );
cvSetImageROI( orient, comp_rect );
cvSetImageROI( mask, comp_rect );
// calculate orientation
angle = cvCalcGlobalOrientation( orient, mask, mhi, timestamp, MHI_DURATION);
angle = 360.0 - angle; // adjust for images with top-left origin
count = cvNorm( silh, 0, CV_L1, 0 ); // calculate number of points within silhouette ROI
cvResetImageROI( mhi );
cvResetImageROI( orient );
cvResetImageROI( mask );
cvResetImageROI( silh );
// check for the case of little motion
if( count < comp_rect.width*comp_rect.height * 0.05 )
continue;
// draw a clock with arrow indicating the direction
center = cvPoint( (comp_rect.x + comp_rect.width/2),
(comp_rect.y + comp_rect.height/2) );
cvCircle( dst, center, cvRound(magnitude*1.2), color, 3, CV_AA, 0 );
cvLine( dst, center, cvPoint( cvRound( center.x + magnitude*cos(angle*CV_PI/180)),
cvRound( center.y - magnitude*sin(angle*CV_PI/180))), color, 3, CV_AA, 0 );
}
}
/*
// Getting feature map for the selected subimage
//
// API
// int getFeatureMaps(const IplImage * image, const int k, featureMap **map);
// INPUT
// image - selected subimage
// k - size of cells
// OUTPUT
// map - feature map
// RESULT
// Error status
*/
int getFeatureMaps(const IplImage* image, const int k, CvLSVMFeatureMap **map)
{
int sizeX, sizeY;
int p, px, stringSize;
int height, width, numChannels;
int i, j, kk, c, ii, jj, d;
float * datadx, * datady;
//номер канала в цикле
int ch;
//переменные вычисления магнитуды
float magnitude, x, y, tx, ty;
IplImage * dx, * dy;
int *nearest;
float *w, a_x, b_x;
// ядро для вычисления градиентов изображение по осям x и y
float kernel[3] = {-1.f, 0.f, 1.f};
CvMat kernel_dx = cvMat(1, 3, CV_32F, kernel);
CvMat kernel_dy = cvMat(3, 1, CV_32F, kernel);
// грачение градиента
float * r;
// новер сектора куда попало значение градиента
// четные иннексы не контрастное изображение
// не четные иннексы контрастное изображение
int * alfa;
// векторы границ секторов
float boundary_x[NUM_SECTOR + 1];
float boundary_y[NUM_SECTOR + 1];
float max, dotProd;
int maxi;
height = image->height;
width = image->width ;
numChannels = image->nChannels;
dx = cvCreateImage(cvSize(image->width, image->height),
IPL_DEPTH_32F, 3);
dy = cvCreateImage(cvSize(image->width, image->height),
IPL_DEPTH_32F, 3);
sizeX = width / k;
sizeY = height / k;
px = 3 * NUM_SECTOR; // контрастное и не контрастное изображение
p = px;
stringSize = sizeX * p;
allocFeatureMapObject(map, sizeX, sizeY, p);
cvFilter2D(image, dx, &kernel_dx, cvPoint(-1, 0));
cvFilter2D(image, dy, &kernel_dy, cvPoint(0, -1));
float arg_vector;
for(i = 0; i <= NUM_SECTOR; i++)
{
arg_vector = ( (float) i ) * ( (float)(PI) / (float)(NUM_SECTOR) );
boundary_x[i] = cosf(arg_vector);
boundary_y[i] = sinf(arg_vector);
}/*for(i = 0; i <= NUM_SECTOR; i++) */
r = (float *)malloc( sizeof(float) * (width * height));
alfa = (int *)malloc( sizeof(int ) * (width * height * 2));
for(j = 1; j < height - 1; j++)
{
datadx = (float*)(dx->imageData + dx->widthStep * j);
datady = (float*)(dy->imageData + dy->widthStep * j);
for(i = 1; i < width - 1; i++)
{
c = 0;
x = (datadx[i * numChannels + c]);
y = (datady[i * numChannels + c]);
r[j * width + i] =sqrtf(x * x + y * y);
for(ch = 1; ch < numChannels; ch++)
{
tx = (datadx[i * numChannels + ch]);
ty = (datady[i * numChannels + ch]);
magnitude = sqrtf(tx * tx + ty * ty);
if(magnitude > r[j * width + i])
{
r[j * width + i] = magnitude;
c = ch;
x = tx;
y = ty;
}
}/*for(ch = 1; ch < numChannels; ch++)*/
max = boundary_x[0] * x + boundary_y[0] * y;
maxi = 0;
for (kk = 0; kk < NUM_SECTOR; kk++)
{
dotProd = boundary_x[kk] * x + boundary_y[kk] * y;
if (dotProd > max)
{
max = dotProd;
maxi = kk;
}
else
{
if (-dotProd > max)
{
max = -dotProd;
maxi = kk + NUM_SECTOR;
}
}
}
alfa[j * width * 2 + i * 2 ] = maxi % NUM_SECTOR;
alfa[j * width * 2 + i * 2 + 1] = maxi;
}/*for(i = 0; i < width; i++)*/
}/*for(j = 0; j < height; j++)*/
//подсчет весов и смещений
nearest = (int *)malloc(sizeof(int ) * k);
w = (float*)malloc(sizeof(float) * (k * 2));
for(i = 0; i < k / 2; i++)
{
nearest[i] = -1;
}/*for(i = 0; i < k / 2; i++)*/
for(i = k / 2; i < k; i++)
{
nearest[i] = 1;
}/*for(i = k / 2; i < k; i++)*/
for(j = 0; j < k / 2; j++)
{
b_x = k / 2 + j + 0.5f;
a_x = k / 2 - j - 0.5f;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = 0; j < k / 2; j++)*/
for(j = k / 2; j < k; j++)
{
a_x = j - k / 2 + 0.5f;
b_x =-j + k / 2 - 0.5f + k;
w[j * 2 ] = 1.0f/a_x * ((a_x * b_x) / ( a_x + b_x));
w[j * 2 + 1] = 1.0f/b_x * ((a_x * b_x) / ( a_x + b_x));
}/*for(j = k / 2; j < k; j++)*/
//интерполяция
for(i = 0; i < sizeY; i++)
{
for(j = 0; j < sizeX; j++)
{
for(ii = 0; ii < k; ii++)
{
for(jj = 0; jj < k; jj++)
{
if ((i * k + ii > 0) &&
(i * k + ii < height - 1) &&
(j * k + jj > 0) &&
(j * k + jj < width - 1))
{
d = (k * i + ii) * width + (j * k + jj);
(*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 ]] +=
r[d] * w[ii * 2] * w[jj * 2];
(*map)->map[ i * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2] * w[jj * 2];
if ((i + nearest[ii] >= 0) &&
(i + nearest[ii] <= sizeY - 1))
{
(*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
(*map)->map[(i + nearest[ii]) * stringSize + j * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 ];
}
if ((j + nearest[jj] >= 0) &&
(j + nearest[jj] <= sizeX - 1))
{
(*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2] * w[jj * 2 + 1];
(*map)->map[i * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2] * w[jj * 2 + 1];
}
if ((i + nearest[ii] >= 0) &&
(i + nearest[ii] <= sizeY - 1) &&
(j + nearest[jj] >= 0) &&
(j + nearest[jj] <= sizeX - 1))
{
(*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 ] ] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
(*map)->map[(i + nearest[ii]) * stringSize + (j + nearest[jj]) * (*map)->numFeatures + alfa[d * 2 + 1] + NUM_SECTOR] +=
r[d] * w[ii * 2 + 1] * w[jj * 2 + 1];
}
}
}/*for(jj = 0; jj < k; jj++)*/
}/*for(ii = 0; ii < k; ii++)*/
}/*for(j = 1; j < sizeX - 1; j++)*/
}/*for(i = 1; i < sizeY - 1; i++)*/
cvReleaseImage(&dx);
cvReleaseImage(&dy);
free(w);
free(nearest);
free(r);
free(alfa);
return LATENT_SVM_OK;
}
// Runs the dot detector and sends detected dots to server on port TODO Implement headless. Needs more config options and/or possibly a config file first though
int run( const char *serverAddress, const int serverPort, char headless ) {
char calibrate_exposure = 0, show = ~0, flip = 0, vflip = 0, done = 0, warp = 0; //"Boolean" values used in this loop
char noiceReduction = 2; //Small counter, so char is still ok.
int i, sockfd; //Generic counter
int dp = 0, minDist = 29, param1 = 0, param2 = 5; // Configuration variables for circle detection
int minDotRadius = 1;
int detected_dots; //Detected dot counter
int returnValue = EXIT_SUCCESS;
int captureControl; //File descriptor for low-level camera controls
int currentExposure = 150;
int maxExposure = 1250; //Maximum exposure supported by the camera TODO Get this from the actual camera
Color min = { 0, 70, 0, 0 }; //Minimum color to detect
Color max = { 255, 255, 255, 0 }; //Maximum color to detect
CvScalar colorWhite = cvScalar( WHITE ); //Color to draw detected dots on black and white surface
BoundingBox DD_mask; //The box indicating what should and what should not be considered for dot search
BoundingBox DD_transform; //The box indicating the plane we are looking at( and as such is the plane we would transform from )
BoundingBox DD_transform_to; //The plane we are transforming to
CvCapture *capture = NULL; //The camera
CvMemStorage *storage; //Low level memory area used for dynamic structures in OpenCV
CvSeq *seq; //Sequence to store detected dots in
IplImage *grabbedImage = NULL; //Raw image from camera( plus some overlay in the end )
IplImage *imgThreshold = NULL; //Image with detected dots
IplImage *mask = NULL; //Mask to be able to remove uninteresting areas
IplImage *coloredMask = NULL; //Mask to be able to indicate above mask on output image
CvFont font; //Font for drawing text on images
SendQueue *queue; //Head of the linked list that is the send queue
char strbuf[255]; //Generic buffer for text formatting( with sprintf())
struct timeval oldTime, time, diff; //Structs for measuring FPS
float lastKnownFPS = 0; //Calculated FPS
CvMat* pointRealMat = cvCreateMat( 1,1,CV_32FC2 ); //Single point matrix for point transformation
CvMat* pointTransMat = cvCreateMat( 1,1,CV_32FC2 ); //Single point matrix for point transformation
CvMat* transMat = cvCreateMat( 3,3,CV_32FC1 ); //Translation matrix for transforming input to a straight rectangle
ClickParams clickParams = { TOP_LEFT, NULL, &DD_transform_to, transMat }; //Struct holding data needed by mouse-click callback function
// Set up network
sockfd = initNetwork( serverAddress, serverPort );
if( sockfd == -1 ) {
fprintf( stderr, "ERROR: initNetwork returned -1\n");
return EXIT_FAILURE;
}
queue = initSendQueue();
if( openCamera( &capture, &captureControl ) == 0 ) {
fprintf( stderr, "ERROR: capture is NULL \n" );
return EXIT_FAILURE;
}
if( ( disableAutoExposure( captureControl ) ) == -1 ) {
fprintf( stderr, "ERROR: Cannot disable auto exposure \n" );
//return EXIT_FAILURE;
}
if( ( updateAbsoluteExposure( captureControl, currentExposure ) ) == 0 ) {
fprintf( stderr, "ERROR: Cannot set exposure\n");
}
// Create a window in which the captured images will be presented
cvNamedWindow( imagewindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL );
// Create a window to hold the configuration sliders and the detection frame TODO This is kind of a hack. Make a better solution
cvNamedWindow( configwindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL );
// Create a window to hold the transformed image. Handy to see how the dots are translated, but not needed for functionality
if( warp ) cvNamedWindow( warpwindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL );
// Create sliders to adjust the lower color boundry
cvCreateTrackbar( red_lable , configwindowname, &min.red, 255, NULL );
cvCreateTrackbar( green_lable, configwindowname, &min.green, 255, NULL );
cvCreateTrackbar( blue_lable , configwindowname, &min.blue, 255, NULL );
//Create sliters for the contour based dot detection
cvCreateTrackbar( min_area_lable, configwindowname, &minDotRadius,255, NULL );
/* Slider for manual exposure setting */
cvCreateTrackbar( exposure_lable, configwindowname, ¤tExposure, maxExposure, NULL );
//Create the memory storage
storage = cvCreateMemStorage( 0 );
// void cvInitFont( font, font_face, hscale, vscale, shear=0, thickness=1, line_type=8 )
cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, 1, 1, 0, 1, 8 );
// Grab an initial image to be able to fetch image size before the main loop.
grabbedImage = cvQueryFrame( capture );
//Move the two windows so both are visible at the same time
cvMoveWindow( imagewindowname, 0, 10 );
cvMoveWindow( configwindowname, grabbedImage->width+2, 10 );
//TODO Move these three inits to a function
// Set masking defaults TODO load from file? Specify file for this file loading?
DD_mask.topLeft.x = 0;
DD_mask.topLeft.y = 0;
DD_mask.topRight.x = grabbedImage->width-1;
DD_mask.topRight.y = 0;
DD_mask.bottomLeft.x = 0;
DD_mask.bottomLeft.y = grabbedImage->height-1;
DD_mask.bottomRight.x = grabbedImage->width-1;
DD_mask.bottomRight.y = grabbedImage->height-1;
// Set transformation defaults TODO load from file? Specify file for this file loading?
DD_transform.topLeft.x = 0;
DD_transform.topLeft.y = 0;
DD_transform.topRight.x = grabbedImage->width-1;
DD_transform.topRight.y = 0;
DD_transform.bottomLeft.x = 0;
DD_transform.bottomLeft.y = grabbedImage->height-1;
DD_transform.bottomRight.x = grabbedImage->width-1;
DD_transform.bottomRight.y = grabbedImage->height-1;
// Set the transformation destination
DD_transform_to.topLeft.x = 0;
DD_transform_to.topLeft.y = 0;
DD_transform_to.topRight.x = grabbedImage->width-1;
DD_transform_to.topRight.y = 0;
DD_transform_to.bottomLeft.x = 0;
DD_transform_to.bottomLeft.y = grabbedImage->height-1;
DD_transform_to.bottomRight.x = grabbedImage->width-1;
DD_transform_to.bottomRight.y = grabbedImage->height-1;
calculateTransformationMatrix( &DD_transform, &DD_transform_to, transMat );
// Set callback function for mouse clicks
cvSetMouseCallback( imagewindowname, calibrateClick, ( void* ) &clickParams );
gettimeofday( &oldTime, NULL );
// Main loop. Grabbs an image from cam, detects dots, sends dots,and prints dots to images and shows to user
while( !done ) {
//PROFILING_PRO_STAMP(); //Uncomment this and the one in the end of the while-loop, and comment all other PROFILING_* to profile main-loop
// ------ Common actions
cvClearMemStorage( storage );
detected_dots = 0;
//Grab a fram from the camera
PROFILING_PRO_STAMP();
grabbedImage = cvQueryFrame( capture );
PROFILING_POST_STAMP( "cvQueryFrame");
if( grabbedImage == NULL ) {
fprintf( stderr, "ERROR: frame is null...\n" );
getchar();
returnValue = EXIT_FAILURE;
break;
}
//Flip images to act as a mirror.
if( show && flip ) {
cvFlip( grabbedImage, grabbedImage, 1 );
}
if( show && vflip ) {
cvFlip( grabbedImage, grabbedImage, 0 );
}
// ------ State based actions
switch( state ) {
case GRAB_DOTS:
//Create detection image
imgThreshold = cvCreateImage( cvGetSize( grabbedImage ), 8, 1 );
cvInRangeS( grabbedImage, cvScalar( DD_COLOR( min )), cvScalar( DD_COLOR( max )), imgThreshold );
//Mask away anything not in our calibration area
mask = cvCreateImage( cvGetSize( grabbedImage ), 8, 1 );
cvZero( mask );
cvFillConvexPoly( mask, ( CvPoint* ) &DD_mask, 4, cvScalar( WHITE ), 1, 0 );
cvAnd( imgThreshold, mask, imgThreshold, NULL );
// Invert mask, increase the number of channels in it and overlay on grabbedImage //TODO Tint the mask red before overlaying
cvNot( mask, mask );
coloredMask = cvCreateImage( cvGetSize( grabbedImage ), grabbedImage->depth, grabbedImage->nChannels );
cvCvtColor( mask, coloredMask, CV_GRAY2BGR );
cvAddWeighted( grabbedImage, 0.95, coloredMask, 0.05, 0.0, grabbedImage );
// Reduce noise.
// Erode is kind of floor() of pixels, dilate is kind of ceil()
// I'm not sure which gives the best result.
switch( noiceReduction ) {
case 0: break; //No noice reduction at all
case 1: cvErode( imgThreshold, imgThreshold, NULL, 2 ); break;
case 2: cvDilate( imgThreshold, imgThreshold, NULL, 2 ); break;
}
// Warp the warp-image. We are reusing the coloredMask variable to save some space
PROFILING_PRO_STAMP();
if( show && warp ) cvWarpPerspective( grabbedImage, coloredMask, transMat, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll( 0 ));
PROFILING_POST_STAMP( "Warping perspective" );
// Find all dots in the image
PROFILING_PRO_STAMP();
// Clear old data from seq
seq = 0;
// Find the dots
cvFindContours(
imgThreshold,
storage,
&seq,
sizeof( CvContour ),
CV_RETR_LIST,
CV_CHAIN_APPROX_SIMPLE,
cvPoint( 0,0 )
);
// cvFindContours destroys the original image, so we wipe it here
// and then repaints the detected dots later
cvZero( imgThreshold );
PROFILING_POST_STAMP( "Dot detection" );
//Process all detected dots
PROFILING_PRO_STAMP();
for( ; seq != 0; seq = seq->h_next ) {
// Calculate radius of the detected contour
CvRect rect =( ( CvContour * )seq )->rect;
float relCenterX = rect.width / 2;
float relCenterY = rect.height / 2;
// Make sure the dot is big enough
if( relCenterX < minDotRadius || relCenterY < minDotRadius ) {
continue;
}
// Note that we have found another dot
++detected_dots;
// Transform the detected dot according to transformation matrix.
float absCenter[] = { rect.x + relCenterX, rect.y + relCenterY };
pointRealMat->data.fl = absCenter;
cvPerspectiveTransform( pointRealMat, pointTransMat, transMat );
// Draw the detected contour back to imgThreshold
// Draw the detected dot both to real image and to warped( if warp is active )
if( show ) {
cvDrawContours( imgThreshold, seq, colorWhite, colorWhite, -1, CV_FILLED, 8, cvPoint( 0,0 ) );
drawCircle( absCenter[0], absCenter[1], ( relCenterX + relCenterY ) / 2, grabbedImage );
if( warp ) {
drawCircle( pointTransMat->data.fl[0], pointTransMat->data.fl[1], ( relCenterX + relCenterY ) / 2, coloredMask );
}
}
// Add detected dot to to send queue
addPointToSendQueue( pointTransMat->data.fl, queue );
}
PROFILING_POST_STAMP("Painting dots");
//Calculate framerate
gettimeofday( &time, NULL );
timeval_subtract( &diff, &time, &oldTime );
lastKnownFPS = lastKnownFPS * 0.7 + ( 1000000.0 / diff.tv_usec ) * 0.3; //We naïvly assume we have more then 1 fps
oldTime = time;
//Send the dots detected this frame to the server
PROFILING_PRO_STAMP();
sendQueue( sockfd, queue );
clearSendQueue( queue );
PROFILING_POST_STAMP( "Sending dots" );
/* If calibrating, do the calibration */
if( calibrate_exposure ) {
int ret;
ret = calibrateExposureLow( captureControl, detected_dots, ¤tExposure, DD_MAX_EXPOSURE, lastKnownFPS );
switch( ret ) {
case 0: // We are done. Let's leave calibration mode
calibrate_exposure = 0;
printf( "done\n" );
break;
case -1: // We hit the upper limit with no detected dots
fprintf( stderr, "Reached upper limit (%d). Aborting!\n", DD_MAX_EXPOSURE );
calibrate_exposure = 0;
break;
case -2: // We hit lower limit with more then one dot detected
fprintf( stderr, "Too bright. More then one dot found even with minimal exposure. Aborting!\n");
calibrate_exposure = 0;
break;
case -3: //No conclusive results.
fprintf( stderr, "No conclusive results. Giving up\n" );
calibrate_exposure = 0;
break;
}
}
break; //End of GRAB_DOTS
case SELECT_TRANSFORM:
//Falling through here. Poor man's multi-case clause. Not putting this in default as we might
//want to do different things in these two some day.
case SELECT_MASK:
snprintf( strbuf, sizeof( strbuf ), "Select %s point", pointTranslationTable[clickParams.currentPoint]);
cvDisplayOverlay( imagewindowname, strbuf, 5 );
break; //End of SELECT_MASK and SELECT_TRANSFORM
}
// Paint the corners of the detecting area and the calibration area
paintOverlayPoints( grabbedImage, &DD_transform );
//Print some statistics to the image
if( show ) {
snprintf( strbuf, sizeof( strbuf ), "Dots: %i", detected_dots ); //Print number of detected dots to the screen
cvPutText( grabbedImage, strbuf, cvPoint( 10, 20 ), &font, cvScalar( WHITE ));
snprintf( strbuf, sizeof( strbuf ), "FPS: %.1f", lastKnownFPS );
cvPutText( grabbedImage, strbuf, cvPoint( 10, 40 ), &font, cvScalar( WHITE ));
cvCircle( grabbedImage, cvPoint( 15, 55 ), minDotRadius, cvScalar( min.blue, min.green, min.red, min.alpha ), -1, 8, 0 ); // Colors given in order BGR-A, Blue, Green, Red, Alpha
}
//Show images
PROFILING_PRO_STAMP();
if( show ) {
cvShowImage( configwindowname, imgThreshold );
cvShowImage( imagewindowname, grabbedImage );
if( warp ) cvShowImage( warpwindowname, coloredMask );
}
PROFILING_POST_STAMP("Showing images");
//Release the temporary images
cvReleaseImage( &imgThreshold );
cvReleaseImage( &mask );
cvReleaseImage( &coloredMask );
/* Update exposure if needed */
updateAbsoluteExposure( captureControl, currentExposure );
cvSetTrackbarPos( exposure_lable, configwindowname, currentExposure );
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7( linux version ),
//remove higher bits using AND operator
i = ( cvWaitKey( 10 ) & 0xff );
switch( i ) {
case 'g':
makeCalibrate( &DD_transform, &DD_transform_to, transMat, capture, captureControl, 20 );
updateAbsoluteExposure( captureControl, currentExposure+1 );
break;
case 'e':
toggleCalibrationMode( &calibrate_exposure, ¤tExposure );
break; /* Toggles calibration mode */
case 'c':
openCamera( &capture, &captureControl );
break;
case 's':
show = ~show;
break; //Toggles updating of the image. Can be useful for performance of slower machines... Or as frame freeze
case 'm':
state = SELECT_MASK;
clickParams.currentPoint = TOP_LEFT;
clickParams.DD_box = &DD_mask;
break; //Starts selection of masking area. Will return to dot detection once all four points are set
case 't':
state = SELECT_TRANSFORM;
clickParams.currentPoint = TOP_LEFT;
clickParams.DD_box = &DD_transform;
break; //Starts selection of the transformation area. Returns to dot detection when done.
case 'f':
flip = ~flip;
break; //Toggles horizontal flipping of the image
case 'v':
vflip = ~vflip;
break; //Toggles vertical flipping of the image
case 'w':
warp = ~warp;
toggleWarpOutput( warp );
break; //Toggles showing the warped image
case 'n':
noiceReduction = ( noiceReduction + 1 ) % 3;
break; //Cycles noice reduction algorithm
case 'q': //falling through here to quit
case 27:
done = 1;
break; //ESC. Kills the whole thing( in a nice and controlled manner )
}
fflush( stdout ); //Make sure everything in the buffer is printed before we go on
//PROFILING_POST_STAMP("Main loop");
} //End of main while-loop
// Release the capture device and do some housekeeping
cvReleaseImage( &grabbedImage );
cvReleaseCapture( &capture );
cvReleaseMemStorage( &storage );
cvDestroyWindow( imagewindowname );
cvDestroyWindow( configwindowname );
if( warp ) cvDestroyWindow( warpwindowname ); //If now warp it is already destroyed
destroySendQueue( queue );
close( sockfd );
close( captureControl );
return returnValue;
}
int main(int argc, char **argv) {
int i,index=0;
int width_img=0; // Frame width
int height_img=0; // Frame height
double fps=0.0; // FPS (Frames Per Second)
int frame=0; // Frame number (index)
int msec;
int total_frames=0; // Total frames
int marked_frames=0; // Marked frame
int *check_frames; // Contains indeces of marked frames
int *list_of_frames; // List of frames
double *ecr;
IplImage *previous_frame; // Previous frame
IplImage *current_frame; // Current frame
IplImage *bgr_frame; // Frame
IplImage *new_frame; // Frame
CvCapture* capture=0; // Capture struct
CvSize size; // Size of frame (width x height)
FILE *fp; // TXT file pointer
clock_t start, stop, diff; // Timer
// Text variables
CvScalar black = CV_RGB(255,0,0);
CvFont font1;
int thickness = 2.0;
char text1[20] = "0"; // frame number
char text2[20] = "0"; // frame msec positiion
double hscale = 1.0;
double vscale = 1.0;
double shear = 0.0;
// Check if the user gave arguments
if(argc != 4) {
fprintf(stderr, "\nUSAGE: %s <input_video_file> <output_video_file> <output_TXT_file>\n", argv[0]);
return EXIT_FAILURE;
}
/**** STAGE 1: PROCESS FRAMES ****/
capture = cvCreateFileCapture(argv[1]); // Open video file to start capture
if(!capture) {
printf("Error opening video file! (cvCreateFileCapture)\n");
return EXIT_FAILURE;
}
fp=fopen(argv[3],"w"); // Open file to write stats
if(fp == NULL) {
printf("Error opening file! (fopen)\n");
return EXIT_FAILURE;
}
fps = cvGetCaptureProperty(capture,CV_CAP_PROP_FPS); // Get FPS
width_img = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH); // Get frame width
height_img = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT); // Get frame height
total_frames = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_COUNT); // Get total frames
size = cvSize(width_img,height_img); // Get size of frames
check_frames = (int *)malloc(sizeof(*check_frames) * total_frames);
list_of_frames = (int *)malloc(sizeof(*list_of_frames) * total_frames);
ecr = (double *)malloc(sizeof(*ecr) * total_frames);
if (check_frames == NULL || list_of_frames == NULL || ecr == NULL) {
printf("Error allocating memory!\n");
return EXIT_FAILURE;
}
// Initialize arrays
for(i=0;i<total_frames;i++) {
ecr[i]=0.0;
check_frames[i]=0;
list_of_frames[i]=0;
}
cvInitFont(&font1,CV_FONT_HERSHEY_SIMPLEX,hscale,vscale,shear,thickness,CV_AA);
CvPoint pt1 = cvPoint(5,30);
CvPoint pt2 = cvPoint(5,70);
fprintf(fp,"Filename\t:\t%s\n\nFrame width\t:\t%d\nFrame height\t:\t%d\nFPS\t\t:\t%f\nTotal frames\t:\t%d\n\n\n\n",argv[1],width_img,height_img,fps,total_frames);
printf("Filename\t:\t%s\n\nFrame width\t:\t%d\nFrame height\t:\t%d\nFPS\t\t:\t%f\nTotal frames\t:\t%d\n\n\n\n",argv[1],width_img,height_img,fps,total_frames);
printf("Start processing frames...\n\n");
start = clock(); // Start timer
bgr_frame=cvQueryFrame(capture); // Grab first frame
previous_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the previous frame
current_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the current frame
cvCopy(bgr_frame,previous_frame,NULL); // Save the copy
// Grab frames from the video until NULL
while((bgr_frame=cvQueryFrame(capture)) != NULL) {
/* When entering this loop, we have already grabbed a frame
* so the frame counter starts from 2
*/
frame = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES); // Get the current frame number
cvCopy(bgr_frame,current_frame,NULL); // Save the copy
/**** START PROCESSING ****/
ecrdiff_v2(current_frame, previous_frame, size, frame, fp, &index);
/**** END PROCESSING ****/
cvCopy(bgr_frame,previous_frame,NULL); // Save the copy
if(index==1) {
check_frames[frame]=1; // It means that the specific frame is marked
}
printf("Processing frame %d...\r",frame);
fflush(stdout);
}
cvReleaseImage(&bgr_frame); // Release bgr_frame
cvReleaseImage(&previous_frame); // Release previous_frame
cvReleaseImage(¤t_frame); // Release current_frame
cvReleaseCapture(&capture); // Release capture
stop = clock(); // Stop timer
diff = stop - start; // Get difference between start time and current time;
printf("\n\nTotal time processing frames : %f minutes\t%f seconds\n", (((float)diff)/CLOCKS_PER_SEC)/60, ((float)diff)/CLOCKS_PER_SEC);
printf("Processing completed!\n");
fprintf(fp,"\n\n\n\nMarked frames\n\n");
printf("\n\n\n\nMarked frames\n\n");
for(i=0;i<total_frames;i++) {
if(check_frames[i]==1) {
list_of_frames[i]=i;
fprintf(fp,"frame %d\n",i); // Write to file only marked frames
printf("frame %d\n",i); // Write to file only marked frames
marked_frames++;
}
}
fprintf(fp,"\n\nTotal marked frames\t:\t%d\n",marked_frames);
printf("\n\nTotal marked frames\t:\t%d\n\n",marked_frames);
//If there is no markeed frames, exit
if(marked_frames == 0) {
return EXIT_SUCCESS;
}
/**** STAGE 2: WRITE VIDEO ****/
capture = cvCreateFileCapture(argv[1]); // Re-Open video file to start capture
if(!capture) {
printf("Error opening video file! (cvCreateFileCapture)\n");
return EXIT_FAILURE;
}
CvVideoWriter *writer = cvCreateVideoWriter(argv[2],CV_FOURCC('F','M','P','4'),fps,size,1);
printf("Start writing frames...\n\n");
start = clock(); // Start timer
bgr_frame = cvQueryFrame(capture); // Retrieve frame
new_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the new frame
do {
frame = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES); // Get the current frame number
msec = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_MSEC);
msec=msec/1000;
// If the index number of the current frame is equal to the frame we want, then write it to the stream.
if(frame == list_of_frames[frame]) {
cvCopy(bgr_frame,new_frame,NULL); // Save the copy
sprintf(text1,"%d frame",frame); // int to char via sprintf()
cvPutText(new_frame,text1,pt1,&font1,black); // frame number
sprintf(text2,"%d sec",msec); // int to char via sprintf()
cvPutText(new_frame,text2,pt2,&font1,black); // frame msec position
cvWriteFrame(writer, new_frame); // Write frame to video stream
} else {
cvWriteFrame(writer, new_frame); // Write frame to video stream
}
printf("Writing frame %d...\r",frame);
fflush(stdout); // For '/r' to work we have to flush the output stream
} while((bgr_frame=cvQueryFrame(capture)) != NULL);
stop = clock(); // Stop timer
diff = stop - start; // Get difference between start time and current time;
printf("\n\nTotal time writing frames : %f minutes\t%f seconds\n", (((float)diff)/CLOCKS_PER_SEC)/60, ((float)diff)/CLOCKS_PER_SEC);
printf("Writing completed!\n\n");
fclose(fp); // Close file pointer
free(list_of_frames); // Free list_of_frames
free(check_frames); // Free check_frames
free(ecr); // Free ecr
cvReleaseImage(&bgr_frame); // Release bgr_frame
cvReleaseImage(&new_frame); // Release new_frame
cvReleaseCapture(&capture); // Release capture
return EXIT_SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////////
//以彩色图像显示每一尺度的张量信息
////////////////////////////////////////////////////////////////////////////////////
void Tensor::ShowTensorByColorImage()
{
double ret_minr=0.0;
double ret_maxr=0.0;
double ret_ming=0.0;
double ret_maxg=0.0;
double ret_minb=0.0;
double ret_maxb=0.0;
int x,y,i;
//纹理特征
IplImage **pImg= new IplImage *[m_levels];
for (i = 0;i < m_levels;i++)
{
pImg[i] = cvCreateImage( cvGetSize(m_img), m_img->depth, 3);
cvZero(pImg[i]);
}
CString * ptitle=new CString [m_levels];
for (i=0;i<m_levels;i++)
{
//找到每幅图像颜色通道的上限与下限值
for (y=0; y<m_h;y++)
{
for (x=0;x<m_w;x++)
{
if((*m_pImageTensorRGB[i])(x,y).r>ret_maxr)
{
ret_maxr=(*m_pImageTensorRGB[i])(x,y).r;
}
if ((*m_pImageTensorRGB[i])(x,y).r<ret_minr)
{
ret_minr=(*m_pImageTensorRGB[i])(x,y).r;
}
if((*m_pImageTensorRGB[i])(x,y).g>ret_maxg)
{
ret_maxg=(*m_pImageTensorRGB[i])(x,y).g;
}
if ((*m_pImageTensorRGB[i])(x,y).g<ret_ming)
{
ret_ming=(*m_pImageTensorRGB[i])(x,y).g;
}
if((*m_pImageTensorRGB[i])(x,y).b>ret_maxb)
{
ret_maxb=(*m_pImageTensorRGB[i])(x,y).b;
}
if ((*m_pImageTensorRGB[i])(x,y).b<ret_minb)
{
ret_minb=(*m_pImageTensorRGB[i])(x,y).b;
}
}
}
uchar * dst=(uchar *)pImg[i]->imageData;
for (y=0; y<m_h;y++)
{
for (x=0;x<m_w;x++)
{
int temp=y*(pImg[i]->widthStep)+3*x;
dst[temp+2]=(uchar)(((*m_pImageTensorRGB[i])(x,y).r-ret_minr)/(ret_maxr-ret_minr)*256);
dst[temp+1]=(uchar)(((*m_pImageTensorRGB[i])(x,y).g-ret_ming)/(ret_maxg-ret_ming)*256);
dst[temp+0]=(uchar)(((*m_pImageTensorRGB[i])(x,y).b-ret_minb)/(ret_maxb-ret_minb)*256);
}
}
ptitle[i].Format(_T("Image Texture of Level %d"),i);
cvNamedWindow((char *)(LPCTSTR)ptitle[i],CV_WINDOW_AUTOSIZE);
cvShowImage((char *)(LPCTSTR)ptitle[i],pImg[i]);
}
if (pImg != NULL)
{
for (i=0;i<m_levels;i++)
{
cvReleaseImage(&pImg[i]);
}
delete [] pImg;
}
}
int main(int argc, char* argv[])
{
IplImage *m_pPreImage = NULL;
IplImage *m_pGrayImage = NULL;
IplImage *m_pSmoothImage = NULL;
IplImage *pPrev = NULL;
IplImage *pCurr = NULL;
IplImage *pDest = NULL;
IplImage *pMask = NULL;
IplImage *pMaskDest = NULL;
IplImage *dst = NULL;
CvMat *pPrevF = NULL;
CvMat *pCurrF = NULL;
CvSize imgSize;
CvCapture *m_pCapture = NULL;
CvVideoWriter *writer = 0;
IplConvKernel* element;
CvSeq* contour = 0;
CvMemStorage* storage = cvCreateMemStorage(0);
CvRect r;
// IplConvKernel* element;
cvNamedWindow( "VideoDisplay1", 1 );
cvNamedWindow( "VideoDisplay2", 1 );
cvNamedWindow( "VideoDisplay3", 1 );
cvNamedWindow( "VideoDisplay4", 1 );
// Capture
m_pCapture = cvCreateFileCapture("MVI_8833.AVI");
contour = cvCreateSeq(CV_SEQ_ELTYPE_POINT,sizeof(CvSeq),sizeof(CvPoint),storage);
if( !m_pCapture )
{
fprintf(stderr,"Could not initialize capturing! \n");
return -1;
}
// Display
while ( (m_pPreImage = cvQueryFrame(m_pCapture)))
{
imgSize = cvSize(m_pPreImage->width, m_pPreImage->height);
if(!m_pGrayImage)
m_pGrayImage = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!pCurr)
pCurr = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!m_pSmoothImage)
m_pSmoothImage = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
//图像预处理
cvCvtColor(m_pPreImage, m_pGrayImage, CV_BGR2GRAY);//转化为灰度图像
cvSmooth(m_pGrayImage,m_pSmoothImage,CV_GAUSSIAN,3,0,0,0 );//GAUSSIAN平滑去噪声
cvEqualizeHist(m_pSmoothImage,pCurr );//直方图均衡
if(!pPrevF)
pPrevF = cvCreateMat(m_pGrayImage->width,m_pPreImage->height, CV_32FC1);
if(!pCurrF)
pCurrF = cvCreateMat(m_pGrayImage->width,m_pPreImage->height, CV_32FC1);
if(!pPrev)
pPrev = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!pMask)
pMask = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!pMaskDest)
pMaskDest = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!dst)
dst = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
if(!pDest)
{
pDest = cvCreateImage(imgSize, IPL_DEPTH_8U, 1);
}
cvAbsDiff(pPrev, pCurr, pDest); //帧差
cvCopy(pCurr, pPrev, NULL); // 当前帧存入前一帧
cvThreshold(pDest, pMask, 80, 255, CV_THRESH_BINARY); // 二值化
element = cvCreateStructuringElementEx( 9, 9, 3, 3, CV_SHAPE_RECT, NULL);
cvMorphologyEx( pMask, pMaskDest, NULL, element, CV_MOP_CLOSE, 1);//形态学处理
//查找并且画出团块轮廓
cvFindContours( pMaskDest, storage, &contour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
//画出包含目标的最小矩形
for(;contour;contour=contour->h_next)
{
r=((CvContour*)contour)->rect;
if(r.height*r.width>100)
{
cvRectangle(m_pPreImage,cvPoint(r.x,r.y),cvPoint(r.x+r.width,r.y+r.height),CV_RGB(255,0,0),1,CV_AA,0);
}
}
cvShowImage( "VideoDisplay1", m_pPreImage );
cvShowImage( "VideoDisplay2", pMask);
cvShowImage( "VideoDisplay3", pMaskDest );
cvShowImage( "VideoDisplay4", pPrev );
if(cvWaitKey(50)>0)
return 0;
}
// Realease
cvReleaseImage( &m_pPreImage );
cvReleaseImage( &m_pGrayImage );
cvReleaseImage( &m_pSmoothImage );
cvReleaseImage( &pCurr );
cvReleaseImage( &pDest );
cvReleaseImage( &pMask );
cvReleaseImage( &pMaskDest );
cvReleaseImage( &dst );
cvReleaseMemStorage( &storage );
cvDestroyWindow("VideoDisplay1");
cvDestroyWindow("VideoDisplay2");
cvDestroyWindow("VideoDisplay3");
cvDestroyWindow("VideoDisplay4");
cvReleaseStructuringElement( &element );
return 0;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Tensor::Tensor(const IplImage *cv_image, BOOL isComputeGradient)
{
//保存原图像的副本
m_img=cvCreateImage(cvSize(cv_image->width,cv_image->height),cv_image->depth,3);
cvCopyImage(cv_image,m_img);
//获取非线性多尺度结构张量的参数值
m_levels = 2;
ASSERT(m_levels > 0 );
m_dim = m_levels * SiNGLE_TENSOR_DIM; //SiNGLE_TENSOR_DIM单一张量
//SiNGLE_TENSOR_DIM=n(n+1)/2;反解n=m_axes_cnt，m_axes_cnt为坐标抽的维数
m_axes_cnt = (unsigned int)(sqrt(2 * SiNGLE_TENSOR_DIM + 0.25) - 0.5); // 2
m_grad_dim = m_levels * m_axes_cnt; //m_grad_dim
////////////////////////////////////////////////////////////////////////////
//将多通道转化为单通道，默认为三个通道
unsigned int x,y,i,n;
m_w = cv_image->width;
m_h = cv_image->height;
IplImage *cv_channels[3];
for (n = 0;n < 3;n++)
{
cv_channels[n] = cvCreateImage( cvGetSize(cv_image), cv_image->depth, 1 );
}
cvSplit(cv_image, cv_channels[0], cv_channels[1], cv_channels[2], NULL);
////////////////////////////////////////////////////////////////////////////
//初始化m_tensor，CMatrix(m_h,m_w)创建一个矩阵，其元素全为0
m_tensor = new CMatrix *[m_dim];
for (i=0;i<m_dim;i++)
{
m_tensor[i] = new CMatrix(m_h,m_w);
}
////////////////////////////////////////////////////////////////////////////
//将每一尺度的张量转化为彩色图像存储起来，申请空间
m_pImageTensorRGB=new Image<Color_RGB> *[m_levels];
for (i=0;i<m_levels;i++)
{
m_pImageTensorRGB[i] = new Image<Color_RGB> (m_w,m_h);
}
//初始化m_gradient
if (isComputeGradient)
{
m_gradient = new CMatrix *[m_grad_dim];
for (i=0;i<m_grad_dim;i++)
{
m_gradient[i] = new CMatrix(m_h,m_w);
}
}
else
{
m_gradient = NULL;
}
//辅助矩阵
CMatrix image(m_h, m_w);
CMatrix dx(m_h,m_w);
CMatrix dy(m_h,m_w);
CMatrix dx2(m_h,m_w);
CMatrix dy2(m_h,m_w);
CMatrix dxdy(m_h,m_w);
//利用固定数据创建一个矩阵
CvMat cv_dx2 = cvMat(m_h, m_w, CV_64FC1, dx2.GetData());
CvMat cv_dy2 = cvMat(m_h, m_w, CV_64FC1, dy2.GetData());
CvMat cv_dxdy =cvMat(m_h, m_w, CV_64FC1, dxdy.GetData());
//完成IplImage向CMatrix类型的转换，对每一个颜色通道分别进行处理
for (n = 0;n <3;n++) //n表示通道数，默认为3
{
//将每一个通道的元素拷贝到image中
for (y = 0; y < m_h; y++)
{
for (x = 0; x < m_w; x++)
{
uchar* dst = &CV_IMAGE_ELEM( cv_channels[n], uchar, y, x );
image.SetElement(y, x, (double)(dst[0]));
}
}
//计算每一个颜色通道的梯度(x方向,y方向)并分别赋给dx，dy
image.centdiffX(dx);
image.centdiffY(dy);
//将dx，dy分别赋给cv_dx，cv_dy
CvMat cv_dx = cvMat(m_h, m_w, CV_64FC1, dx.GetData());
CvMat cv_dy = cvMat(m_h, m_w, CV_64FC1, dy.GetData());
//初始化cv_tensor0，cv_tensor1，cv_tensor2，此时m_tensor[0],m_tensor[1],m_tensor[2]均初始化0
CvMat cv_tensor0 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[0])->GetData());
CvMat cv_tensor1 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[1])->GetData());
CvMat cv_tensor2 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[2])->GetData());
//计算图像的梯度，保存在cv_gradX，cv_gradY中，并赋值给m_gradient[0],m_gradient[1]
if (isComputeGradient)
{
//cv_gradX,cv_gradY初始化并计算
CvMat cv_gradX = cvMat(m_h, m_w, CV_64FC1, (m_gradient[0])->GetData());
CvMat cv_gradY = cvMat(m_h, m_w, CV_64FC1, (m_gradient[1])->GetData());
cvAdd(&cv_gradX, &cv_dx, &cv_gradX);//对于三个通道进行累加
cvAdd(&cv_gradY, &cv_dy, &cv_gradY);
}
//计算结构张量，cv_tensor0=dx*dx,cv_tensor1=dy*dy,cv_tensor2=dx*dy
cvMul(&cv_dx, &cv_dx, &cv_dx2);
cvAdd(&cv_tensor0, &cv_dx2, &cv_tensor0);
cvMul(&cv_dy, &cv_dy, &cv_dy2);
cvAdd(&cv_tensor1, &cv_dy2, &cv_tensor1);
cvMul(&cv_dx, &cv_dy, &cv_dxdy);
cvAdd(&cv_tensor2, &cv_dxdy, &cv_tensor2);
//单尺度计算完毕，以下为多尺度非线性结构张量的计算方法
if (m_levels > 1)
{
unsigned int wavelet_levels = m_levels - 1; //-1的原因是因为之前没有if (m_levels==1)的判断语句
double dMaxValue,dMinValue;
cvMinMaxLoc(cv_channels[n], &dMinValue, &dMaxValue);//Finds global minimum, maximum
//将图像的像素值归一化到[0,1]
Wavelet *wave = new Wavelet(&image, dMinValue, dMaxValue, wavelet_levels); //调用Wavelet的构造函数
//新建WaveletDetailImages结构体的数组
WaveletDetailImages *D_images = new WaveletDetailImages[wavelet_levels];
for (i = 0; i < wavelet_levels; i++)
{
D_images[i].Detail_1 = new CMatrix(m_h, m_w);
D_images[i].Detail_2 = new CMatrix(m_h, m_w);
}
wave->execute(D_images);//得到D(s,x),D(s,y)
for (i = 0; i < wavelet_levels; i++)
{
//默认多尺度结构张量的比例因子a=2
double scale = pow((float)0.25, (int)(i + 1)); //见公式(2-15)
CvMat cv_dx = cvMat(m_h, m_w, CV_64FC1, D_images[i].Detail_1->GetData());
CvMat cv_dy = cvMat(m_h, m_w, CV_64FC1, D_images[i].Detail_2->GetData());
CvMat cv_tensor0 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[(i+1) * SiNGLE_TENSOR_DIM])->GetData());
CvMat cv_tensor1 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[(i+1) * SiNGLE_TENSOR_DIM + 1])->GetData());
CvMat cv_tensor2 = cvMat(m_h, m_w, CV_64FC1, (m_tensor[(i+1) * SiNGLE_TENSOR_DIM + 2])->GetData());
//计算梯度
if (isComputeGradient)
{
CvMat cv_gradX = cvMat(m_h, m_w, CV_64FC1, (m_gradient[(i+1) * m_axes_cnt])->GetData());
CvMat cv_gradY = cvMat(m_h, m_w, CV_64FC1, (m_gradient[(i+1) * m_axes_cnt + 1])->GetData());
cvAdd(&cv_gradX, &cv_dx, &cv_gradX);
cvAdd(&cv_gradY, &cv_dy, &cv_gradY);
}
//计算张量
cvMul(&cv_dx, &cv_dx, &cv_dx2, scale);
cvAdd(&cv_tensor0, &cv_dx2, &cv_tensor0);
cvMul(&cv_dy, &cv_dy, &cv_dy2, scale);
cvAdd(&cv_tensor1, &cv_dy2, &cv_tensor1);
cvMul(&cv_dx, &cv_dy, &cv_dxdy, scale);
cvAdd(&cv_tensor2, &cv_dxdy, &cv_tensor2);
}
for (i = 0; i < wavelet_levels; i++)
{
delete D_images[i].Detail_1;
delete D_images[i].Detail_2;
}
delete [] D_images;
delete wave;
}
cvReleaseImage(&cv_channels[n]);
}
//将每一尺度的结构张量转换为彩色图像存储起来
for (i=0;i<m_levels;i++)
{
for (y=0;y<m_h;y++)
{
for (x=0;x<m_w;x++)
{
(*m_pImageTensorRGB[i])(x,y).r=(m_tensor[i*SiNGLE_TENSOR_DIM])->GetElement(y,x);
(*m_pImageTensorRGB[i])(x,y).g=(m_tensor[i*SiNGLE_TENSOR_DIM+1])->GetElement(y,x);
(*m_pImageTensorRGB[i])(x,y).b=(m_tensor[i*SiNGLE_TENSOR_DIM+2])->GetElement(y,x);
}
}
}
m_tensors = NULL;
}
Tensor::~Tensor()
{
if (m_tensor != NULL)
{
for (int i=0;i<m_dim;i++)
{
if (m_tensor[i] != NULL)
{
delete m_tensor[i];
m_tensor[i] = NULL;
}
}
delete [] m_tensor;
m_tensor = NULL;
}
if (m_pImageTensorRGB != NULL)
{
for (int i=0;i<m_levels;i++)
{
if (m_pImageTensorRGB[i] != NULL)
{
delete m_pImageTensorRGB[i];
m_pImageTensorRGB[i] = NULL;
}
}
delete [] m_pImageTensorRGB;
m_pImageTensorRGB = NULL;
}
if (m_gradient != NULL)
{
for (int i=0;i<m_grad_dim;i++)
{
if (m_gradient[i] != NULL)
{
delete m_gradient[i];
m_gradient[i] = NULL;
}
}
delete [] m_gradient;
m_gradient = NULL;
}
if (m_tensors != NULL)
{
unsigned int x,y;
for (y = 0; y < m_h; y++)
{
for (x = 0; x < m_w; x++)
{
if ((*m_tensors)(x,y) != NULL)
{
delete (*m_tensors)(x,y);
(*m_tensors)(x,y) = NULL;
}
}
}
delete m_tensors;
m_tensors = NULL;
}
if (m_img!=NULL)
{
cvReleaseImage(&m_img);
m_img=NULL;
}
}
COpenCVMFCDoc::~COpenCVMFCDoc()
{
// Release Image
if (pImg)
cvReleaseImage(&pImg);
}
static IplImage *_threshold(IplImage *in) {
IplImage *img = cvCreateImage(cvGetSize(in), 8, 1);
// convert to grayscale
cvCvtColor(in, img, CV_BGR2GRAY);
// compute the mean intensity. This is used to adjust constant_reduction value below.
long total = 0;
for (int x = 0; x < img->width; ++x) {
for (int y = 0; y < img->height; ++y) {
CvScalar s = cvGet2D(img, y, x);
total += s.val[0];
}
}
int mean_intensity = (int)(total / (img->width * img->height));
// apply thresholding (converts it to a binary image)
// block_size observations: higher value does better for images with variable lighting (e.g.
// shadows).
// may eventually need to paramaterize this, to some extent, because the different callers
// seem to do better with different values (e.g. contour location is better with smaller numbers,
// but cage location is better with larger...) but for now, have been able to settle on value
// which works pretty well for most cases.
int block_size = (int)(img->width / 9);
if ((block_size % 2) == 0) {
// must be odd
block_size += 1;
}
// constant_reduction observations: magic, but adapting this value to the mean intensity of the
// image as a whole seems to help.
int constant_reduction = (int)(mean_intensity / 3.6 + 0.5);
IplImage *threshold_image = cvCreateImage(cvGetSize(img), 8, 1);
cvAdaptiveThreshold(img, threshold_image, 255, CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY_INV,
block_size, constant_reduction);
cvReleaseImage(&img);
// try to get rid of "noise" spots.
int min_blob_size = 2;
for (int x = 0; x < threshold_image->width; ++x) {
for (int y = 0; y < threshold_image->height; ++y) {
CvScalar s = cvGet2D(threshold_image, y, x);
int ink_neighbors = 0;
if (s.val[0] == 255) {
for (int dx = -1; dx <= 1; ++dx) {
if ((x + dx >= 0) && (x + dx < threshold_image->width)) {
for (int dy = -1; dy <= 1; ++dy) {
if ((y + dy >= 0) && (y + dy < threshold_image->height)) {
if (! ((dy == 0) && (dx == 0))) {
CvScalar m = cvGet2D(threshold_image, y + dy, x + dx);
if (m.val[0] == 255) {
++ink_neighbors;
if (ink_neighbors > min_blob_size) {
break;
}
}
}
}
}
if (ink_neighbors > min_blob_size) {
break;
}
}
}
if (ink_neighbors <= min_blob_size) {
s.val[0] = 0;
cvSet2D(threshold_image, y, x, s);
}
}
}
}
return threshold_image;
}
const CvPoint2D32f* locate_puzzle(IplImage *in, IplImage **annotated) {
IplImage *grid_image = _grid(in);
*annotated = cvCloneImage(in);
// find lines using Hough transform
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* lines = 0;
double distance_resolution = 1;
double angle_resolution = CV_PI / 60;
int threshold = 60;
int minimum_line_length = in->width / 2;
int maximum_join_gap = in->width / 10;
lines = cvHoughLines2(grid_image, storage, CV_HOUGH_PROBABILISTIC, distance_resolution, angle_resolution, threshold, minimum_line_length, maximum_join_gap);
cvCvtColor(grid_image, *annotated, CV_GRAY2RGB);
cvReleaseImage(&grid_image);
double most_horizontal = INFINITY;
for (int i = 0; i < lines->total; ++i) {
CvPoint *line = (CvPoint*)cvGetSeqElem(lines,i);
double dx = abs(line[1].x - line[0].x);
double dy = abs(line[1].y - line[0].y);
double slope = INFINITY;
if (dx != 0) {
slope = dy / dx;
}
if (slope != INFINITY) {
if (slope < most_horizontal) {
//printf("most horizontal seen: %0.2f\n", slope);
most_horizontal = slope;
}
}
}
int top = -1;
int left = -1;
int bottom = -1;
int right = -1;
for (int i = 0; i < lines->total; i++) {
CvPoint* line = (CvPoint*)cvGetSeqElem(lines,i);
double dx = abs(line[1].x - line[0].x);
double dy = abs(line[1].y - line[0].y);
double slope = INFINITY;
if (dx) {
slope = dy / dx;
}
cvLine(*annotated, line[0], line[1], CV_RGB(255, 0, 0), 1, 8, 0);
if (abs(slope - most_horizontal) <= 1) {
if ((top == -1) || (line[1].y < ((CvPoint*)cvGetSeqElem(lines,top))[1].y)) {
top = i;
}
if ((bottom == -1) || (line[1].y > ((CvPoint*)cvGetSeqElem(lines,bottom))[1].y)) {
bottom = i;
}
} else {
if ((left == -1) || (line[1].x < ((CvPoint*)cvGetSeqElem(lines,left))[1].x)) {
left = i;
}
if ((right == -1) || (line[1].x > ((CvPoint*)cvGetSeqElem(lines,right))[1].x)) {
right = i;
}
}
}
//printf("number of lines: %d\n", lines->total);
if ((top == -1) || (left == -1) || (bottom == -1) || (right == -1)) {
return NULL;
}
CvPoint *top_line = (CvPoint*)cvGetSeqElem(lines,top);
cvLine(*annotated, top_line[0], top_line[1], CV_RGB(0, 0, 255), 6, 8, 0);
CvPoint *bottom_line = (CvPoint*)cvGetSeqElem(lines,bottom);
cvLine(*annotated, bottom_line[0], bottom_line[1], CV_RGB(0, 255, 255), 6, 8, 0);
CvPoint *left_line = (CvPoint*)cvGetSeqElem(lines,left);
cvLine(*annotated, left_line[0], left_line[1], CV_RGB(0, 255, 0), 6, 8, 0);
CvPoint *right_line = (CvPoint*)cvGetSeqElem(lines,right);
cvLine(*annotated, right_line[0], right_line[1], CV_RGB(255, 255, 0), 6, 8, 0);
CvPoint2D32f *coordinates;
coordinates = malloc(sizeof(CvPoint2D32f) * 4);
// top left
intersect(top_line, left_line, &(coordinates[0]));
cvLine(*annotated, cvPointFrom32f(coordinates[0]), cvPointFrom32f(coordinates[0]), CV_RGB(255, 255, 0), 10, 8, 0);
//printf("top_left: %.0f, %.0f\n", coordinates[0].x, coordinates[0].y);
// top right
intersect(top_line, right_line, &(coordinates[1]));
cvLine(*annotated, cvPointFrom32f(coordinates[1]), cvPointFrom32f(coordinates[1]), CV_RGB(255, 255, 0), 10, 8, 0);
//printf("top_right: %.0f, %.0f\n", coordinates[1].x, coordinates[1].y);
// bottom right
intersect(bottom_line, right_line, &(coordinates[2]));
cvLine(*annotated, cvPointFrom32f(coordinates[2]), cvPointFrom32f(coordinates[2]), CV_RGB(255, 255, 0), 10, 8, 0);
//printf("bottom_right: %.0f, %.0f\n", coordinates[2].x, coordinates[2].y);
// bottom left
intersect(bottom_line, left_line, &(coordinates[3]));
cvLine(*annotated, cvPointFrom32f(coordinates[3]), cvPointFrom32f(coordinates[3]), CV_RGB(255, 255, 0), 10, 8, 0);
//printf("bottom_left: %.0f, %.0f\n", coordinates[3].x, coordinates[3].y);
return coordinates;
}
void Capture::setPreviousFrame(IplImage* image) {
if (previousFrame != NULL) cvReleaseImage(&previousFrame);
previousFrame = image;
}
//添加矩形处理函数
void CRecognitionTextView::OnAdd()
{
//获取实际位置
int up = int((downPoint.y+m_nVScrollPos) * resizeY);
int down = int((upPoint.y+m_nVScrollPos) * resizeY);
int left = int(downPoint.x - xSt)* resizeX;
int right = int(upPoint.x - xSt) * resizeX;
int new_width = right - left;
int new_height = down - up;
//判断是否接收处理
if(new_width*new_height < 9)
return;
if(lines.size() <= 0)
return;
//获取位置然后获取该区域
IplImage *newSrc = cvCreateImage(cvSize(new_width,new_height),8,1);
CopyData(src,newSrc,left,up);
//cvSmooth(newSrc,newSrc);
tools.Normal(newSrc);
cvSmooth(newSrc,newSrc);
//获取边缘
IplImage *edge = cvCreateImage(cvSize(new_width,new_height),8,1);
tools.getEdge(newSrc,edge);
//二值化
IplImage *throld = cvCreateImage(cvSize(new_width,new_height),8,1);
tools.OtsuTheld(edge,throld);
/*cvShowImage("",throld);
cvWaitKey();*/
int xSt = new_width,xEn = 0;
int ySt = new_height,yEn = 0;
for(int i = 2 ;i < throld->width -2 ;i++)
{
for(int j = 2;j < throld->height - 2;j++)
{
if((uchar)throld->imageData[j*throld->widthStep + i] == 0)
{
if(i < xSt)
xSt = i;
if(i > xEn)
xEn = i;
if(j < ySt)
ySt = j;
if(j > yEn)
yEn = j;
}
}
}
/*for(int i = xSt;i < xEn ;i++)
{
for(int j = ySt; j< yEn ;j++)
{
newSrc->imageData[j*newSrc->widthStep + i] = 0;
}
}*/
struct OutLine tempoutline;
tempoutline.xSt = xSt + left;
tempoutline.xEnd = xEn + left;
tempoutline.ySt = ySt + up;
tempoutline.yEnd = yEn + up;
//判断在哪一行
int cent = (ySt + yEn)/2 + up;
int temp = 1000;
int mark;
for(int i = 0;i<lines.size();i++)
{
if(abs(cent - lines[i]) < temp)
{
temp = abs(cent - lines[i]);
mark = i;
}
}
//插入改行
bool st = false;
int tempCode = 0;
for(int i = mark;i < outlineSs.size();i++)
{
for(int j = 0; j< outlineSs.at(i).size();j++)
{
if(outlineSs.at(i).at(j).Code > tempCode)
tempCode = outlineSs.at(i).at(j).Code;
if(!st && i== mark && j == outlineSs.at(i).size()-1)
{
tempoutline.Code = tempCode;
outlineSs.at(i).push_back(tempoutline);
st = true;
j++;
}
if(outlineSs.at(i).at(j).Code == -1)
continue;
if(!st)
{
if(outlineSs.at(i).at(j).xSt > tempoutline.xSt)
{
tempoutline.Code = outlineSs.at(i).at(j).Code;
//outlineSs.at(i).at(j).Code ++;
//插入该元素
outlineSs.at(i).insert(outlineSs.at(i).begin()+j,tempoutline);
st = true;
}
}
else
{
outlineSs.at(i).at(j).Code++;
}
}
}
cvReleaseImage(&newSrc);
cvReleaseImage(&edge);
cvReleaseImage(&throld);
OnPaint();
}
IplImage* Panoramic::StitchFace(const char *leftName, const char *centerName,const char *rightName)
{
IplImage *leftHsvImg,*centerHsvImg,*rightHsvImg;
vector<Coordinate> leftCoord;
vector<Coordinate> rightCoord;
vector<Coordinate> centerCoord;
vector<Coordinate> profileCoord(3);
vector<Coordinate> centerAffineCoord(3);
IplImage *leftAffineImg = cvCreateImage(cvSize(m_width,m_height),8,1);
IplImage *rightAffineImg = cvCreateImage(cvSize(m_width,m_height),8,1);
IplImage *leftFeatureImg = cvLoadImage(leftName,1);
IplImage *centerFeatureImg = cvLoadImage(centerName,1);
IplImage *rightFeatureImg = cvLoadImage(rightName,1);
cvZero(rightAffineImg);
cvZero(leftAffineImg);
//Using red color threshold to find the features from input image
leftHsvImg = GetHsvFeature(leftFeatureImg ,0,255,255,51,51,51);
centerHsvImg= GetHsvFeature(centerFeatureImg ,0,255,255,51,51,51);
rightHsvImg = GetHsvFeature(rightFeatureImg ,0,255,255,51,51,51);
//FindFeatureCoord will decide whether it continues or not.
leftCoord = FindFeatureCoord(leftHsvImg);
rightCoord = FindFeatureCoord(rightHsvImg);
centerCoord = FindFeatureCoord(centerHsvImg);
if(m_do_sttich)//when all number of feature coord = 12,it will be true,it decide in function:"FindFeatureCoord"
{
RearrangeCoord(leftCoord);
RearrangeCoord(rightCoord);
RearrangeCoord(centerCoord);
for(int i = 0; i < m_numFeature; i++)
{
m_centerCood[i] = centerCoord[i];
}
if(m_debug)
{
ShowFeature(leftCoord);
ShowFeature(centerCoord);
ShowFeature(rightCoord);
}
Graphic FindLine;
for(int numStitch = 0; numStitch < 2;numStitch++)
{
for(int num = 0;num < 3;num++)
{
if(numStitch == 1)
{
if(num==0)
{
profileCoord[0] = leftCoord[1];
centerAffineCoord[0] = centerCoord[1];
}
else
{
profileCoord[num] = leftCoord[num+2];
centerAffineCoord[num] = centerCoord[num+2];
}
}
else
{
if(num==0)
{
profileCoord[0] = rightCoord [7];
centerAffineCoord[0] = centerCoord[7];
}
else
{
profileCoord[num] = rightCoord [num+8];
centerAffineCoord[num] = centerCoord[num+8];
}
}
}
//Á_¦X¥ª°¼Áy
if(numStitch == 1)
{
FindLine.Line(centerAffineCoord,0,centerAffineCoord,2,m_slope,m_intercept);
DoAffineTrsform(m_leftImg,leftAffineImg,profileCoord,centerAffineCoord);
if(m_debug)
{
cvNamedWindow("leftAffineImg",0);
cvShowImage("leftAffineImg",leftAffineImg);
}
ShowStitch(leftAffineImg,m_centerImg); //°¼ÁyÁ_¦X¡B½u©Ê¼Ò½k¤Æ
}
//Á_¦X¥k°¼Áy
else
{
FindLine.Line(centerAffineCoord,0,centerAffineCoord,2,m_slope,m_intercept);
DoAffineTrsform(m_rightImg,rightAffineImg,profileCoord,centerAffineCoord);
if(m_debug)
{
cvNamedWindow("rightAffineImg",0);
cvShowImage("rightAffineImg",rightAffineImg);
}
ShowStitch(rightAffineImg,m_centerImg);
}
m_saveSlope[numStitch] = m_slope;
m_saveIntercept[numStitch] = m_intercept;
}
//Á_¦X¥¿Áy
for(int j = 0;j < m_height;j++)
{
for(int i = 0;i < m_width;i++)
{
double linePostionright = m_saveSlope[0]*i + m_saveIntercept[0]-j;
double linePostionleft = m_saveSlope[1]*i + m_saveIntercept[1]-j;
if(linePostionright > m_lineT && linePostionleft > m_lineT)
{
double pixel = cvGetReal2D(m_centerImg,j,i);
cvSetReal2D(m_PanoramicFace,j,i,pixel) ;
}
}
}
if(m_debug)
{
cvNamedWindow("PanoramicFace",0);
cvShowImage("PanoramicFace",m_PanoramicFace);
cvWaitKey(0);
}
cvReleaseImage(&leftHsvImg); cvReleaseImage(¢erHsvImg); cvReleaseImage(&rightHsvImg);
cvReleaseImage(&leftAffineImg); cvReleaseImage(&rightAffineImg);
cvReleaseImage(&leftFeatureImg);cvReleaseImage(¢erFeatureImg); cvReleaseImage(&rightFeatureImg);
return m_PanoramicFace;
}
else
{
printf("Error when stich image....");
return NULL;
}
}
int main( int argc, char** argv )
{
IplImage *tpl = 0;
IplImage *ref = 0;
IplImage *poc = 0;
char String[255];
if( argc < 3 ) {
fprintf( stderr, "Usage: phase_correlation <url1> <url2>\n" );
return 1;
}
sprintf(String, "wget %s -O image1.jpg", argv[1]);
system(String);
sprintf(String, "wget %s -O image2.jpg", argv[2]);
system(String);
/* load reference image */
ref = cvLoadImage( "image1.jpg", CV_LOAD_IMAGE_GRAYSCALE );
/* always check */
if( ref == 0 ) {
fprintf( stderr, "Cannot load %s!\n", argv[1] );
return 1;
}
/* load template image */
tpl = cvLoadImage( "image2.jpg", CV_LOAD_IMAGE_GRAYSCALE );
/* always check */
if( tpl == 0 ) {
fprintf( stderr, "Cannot load %s!\n", argv[2] );
return 1;
}
/* both images' size should be equal */
if( ( tpl->width != ref->width ) || ( tpl->height != ref->height ) ) {
fprintf( stderr, "Both images must have equal width and height!\n" );
return 1;
}
/* create a new image, to store phase correlation result */
poc = cvCreateImage( cvSize( tpl->width, tpl->height ), IPL_DEPTH_64F, 1 );
/* get phase correlation of input images */
phase_correlation( ref, tpl, poc );
/* find the maximum value and its location */
CvPoint minloc, maxloc;
double minval, maxval;
cvMinMaxLoc( poc, &minval, &maxval, &minloc, &maxloc, 0 );
/* print it */
fprintf( stdout, "Maxval at (%d, %d) = %2.4f\n", maxloc.x, maxloc.y, maxval );
fprintf(stdout,"percentage comparision= %2.4f \n",maxval*100);
/* display images and free memory */
cvNamedWindow( "tpl", CV_WINDOW_AUTOSIZE );
cvNamedWindow( "ref", CV_WINDOW_AUTOSIZE );
cvShowImage( "tpl", tpl );
cvShowImage( "ref", ref );
cvWaitKey( 0 );
cvDestroyWindow( "tpl" );
cvDestroyWindow( "ref" );
cvReleaseImage( &tpl );
cvReleaseImage( &ref );
cvReleaseImage( &poc );
return 0;
}
int main(int argc, const char **argv)
{
//Variables
int degrees,PosRelX,PosRelY;
float radians,Dlaser,ODM_ang, ang;
int width = 500, height = 500; //Create the size of the map here (in pixel)
int centroX = (width / 2);
int centroY = (height / 2);
playerc_client_t *client;
playerc_laser_t *laser;
playerc_position2d_t *position2d;
CvPoint pt,pt1,pt2;
CvScalar cinzaE,preto,cinzaC;
char window_name[] = "Map";
IplImage* image = cvCreateImage( cvSize(width,height), 8, 3 );
cvNamedWindow(window_name, 1 );
preto = CV_RGB(0, 0, 0); //for indicating obstacles
cinzaE = CV_RGB(92, 92, 92); //To indicate the stranger
cinzaC = CV_RGB(150, 150, 150); //To indicate free spaces
client = playerc_client_create(NULL, "localhost", 6665);
if (playerc_client_connect(client) != 0)
return -1;
laser = playerc_laser_create(client, 0);
if (playerc_laser_subscribe(laser, PLAYERC_OPEN_MODE))
return -1;
position2d = playerc_position2d_create(client, 0);
if (playerc_position2d_subscribe(position2d, PLAYERC_OPEN_MODE) != 0) {
fprintf(stderr, "error: %s\n", playerc_error_str());
return -1;
}
if (playerc_client_datamode (client, PLAYERC_DATAMODE_PULL) != 0) {
fprintf(stderr, "error: %s\n", playerc_error_str());
return -1;
}
if (playerc_client_set_replace_rule (client, -1, -1, PLAYER_MSGTYPE_DATA, -1, 1) != 0) {
fprintf(stderr, "error: %s\n", playerc_error_str());
return -1;
}
playerc_position2d_enable(position2d, 1); // initialise motors
playerc_position2d_set_odom(position2d, 0, 0, 0); // Set odometer to zero
cvSet(image, cinzaE,0); //set the image colour to dark
pt.x = centroX; // Zero coordinate for x
pt.y = centroY; // Zero coordinate for y
while(1) {
playerc_client_read(client);
cvSaveImage("mapa.jpg",image);
playerc_client_read(client);
for (degrees = 2; degrees <= 360; degrees+=2) {
Dlaser = laser->scan[degrees][0];
if (Dlaser < 8) {
radians = graus2rad (degrees/2); //Convert the angle of the laser to radians
ODM_ang = position2d->pa; //Obtain the angle relative to the robot
ang = ((1.5*PI)+radians+ODM_ang); //Converte the angle relative to the world
PosRelX = arredonda(position2d->px); //Position x relative to robot
PosRelY = arredonda(position2d->py); //Position y relative to robot
pt1.y = (centroY-PosRelY); //Co-ordinated global y of the robot
pt1.x = (centroX+PosRelX); //Co-ordinated global x of the robot
//t converts polar coordinates for rectangular (global)
pt.y = (int)(pt1.y-(sin(ang)*Dlaser*10));
pt.x = (int)(pt1.x+(cos(ang)*Dlaser*10));
//The free area draws cvline
cvLine(image, pt1,pt,cinzaC, 1,4,0);
//marks the object in the map
cvLine(image, pt,pt,preto, 1,4,0);
//Shows the result of the map to the screen
cvShowImage(window_name, image );
cvWaitKey(10);
}
}
}
//Disconnect player
playerc_laser_unsubscribe(laser);
playerc_laser_destroy(laser);
playerc_client_disconnect(client);
playerc_client_destroy(client);
//Destroy the OpenCV window cvReleaseImage
cvReleaseImage(&image);
cvDestroyWindow(window_name);
return 0;
}
/*
* This function overlays the illumination frame translucently
* over the original image.
* It also draws the worm's boundary and the worm's head and tail.
*
*/
void DisplayWormHUDS(WormAnalysisData* Worm, WormAnalysisParam* Params, Frame* IlluminationFrame,char* WindowName){
IplImage* TempImage =cvCreateImage(Worm->SizeOfImage,IPL_DEPTH_8U,1);
CreateWormHUDS(TempImage,Worm,Params,IlluminationFrame);
cvShowImage(WindowName,TempImage);
cvReleaseImage(&TempImage);
}
int calc_hsv_colors(IplImage *frame)
{
if(!frame)
return -1;
IplImage* image=0, *hsv=0, *dst=0, *dst2=0, *color_indexes=0, *dst3=0;
image = cvCloneImage(frame);
hsv = cvCreateImage( cvGetSize(image), IPL_DEPTH_8U, 3 );
cvCvtColor( image, hsv, CV_BGR2HSV );
// for store results
dst = cvCreateImage( cvGetSize(image), IPL_DEPTH_8U, 3 );
dst2 = cvCreateImage( cvGetSize(image), IPL_DEPTH_8U, 3 );
color_indexes = cvCreateImage( cvGetSize(image), IPL_DEPTH_8U, 1 ); // store color indexes
// для хранения RGB-х цветов
CvScalar rgb_colors[NUM_COLOR_TYPES];
int i=0, j=0, x=0, y=0;
// reset colors
memset(colorCount, 0, sizeof(colorCount));
for(i=0; i<NUM_COLOR_TYPES; i++) {
rgb_colors[i] = cvScalarAll(0);
}
for (y=0; y<hsv->height; y++) {
for (x=0; x<hsv->width; x++) {
// get HSV pixel
uchar H = CV_PIXEL(uchar, hsv, x, y)[0]; // Hue
uchar S = CV_PIXEL(uchar, hsv, x, y)[1]; // Saturation
uchar V = CV_PIXEL(uchar, hsv, x, y)[2]; // Value (Brightness)
// define pixel color type
int ctype = getPixelColorType(H, S, V);
// set values
CV_PIXEL(uchar, dst, x, y)[0] = cCTHue[ctype]; // Hue
CV_PIXEL(uchar, dst, x, y)[1] = cCTSat[ctype]; // Saturation
CV_PIXEL(uchar, dst, x, y)[2] = cCTVal[ctype]; // Value
// collect RGB
rgb_colors[ctype].val[0] += CV_PIXEL(uchar, image, x, y)[0]; // B
rgb_colors[ctype].val[1] += CV_PIXEL(uchar, image, x, y)[1]; // G
rgb_colors[ctype].val[2] += CV_PIXEL(uchar, image, x, y)[2]; // R
// сохраняем к какому типу относится цвет
CV_PIXEL(uchar, color_indexes, x, y)[0] = ctype;
// подсчитываем :)
colorCount[ctype]++;
}
}
// усреднение RGB-составляющих
for(i=0; i<NUM_COLOR_TYPES; i++) {
rgb_colors[i].val[0] /= colorCount[i];
rgb_colors[i].val[1] /= colorCount[i];
rgb_colors[i].val[2] /= colorCount[i];
}
// теперь загоним массив в вектор и отсортируем :)
std::vector< std::pair< int, uint > > colors;
colors.reserve(NUM_COLOR_TYPES);
for(i=0; i<NUM_COLOR_TYPES; i++){
std::pair< int, uint > color;
color.first = i;
color.second = colorCount[i];
colors.push_back( color );
}
// сортируем
std::sort( colors.begin(), colors.end(), colors_sort );
// для отладки - выводим коды, названия цветов и их количество
for(i=0; i<colors.size(); i++){
printf("[i] color %d (%s) - %d\n", colors[i].first, sCTypes[colors[i].first], colors[i].second );
}
// выдаём код первых цветов
printf("[i] color code: \n");
for(i=0; i<NUM_COLOR_TYPES; i++)
printf("%02d ", colors[i].first);
printf("\n");
printf("[i] color names: \n");
for(i=0; i<NUM_COLOR_TYPES; i++)
printf("%s ", sCTypes[colors[i].first]);
printf("\n");
#if 0
cvSaveImage("image.bmp", image);
#endif
cvReleaseImage(&image);
cvReleaseImage(&hsv);
cvReleaseImage(&dst);
cvReleaseImage(&dst2);
cvReleaseImage(&color_indexes);
cvReleaseImage(&dst3);
return 0;
}
/*
* Smooths, thresholds and finds the worms contour.
* The original image must already be loaded into Worm.ImgOrig
* The Smoothed image is deposited into Worm.ImgSmooth
* The thresholded image is deposited into Worm.ImgThresh
* The Boundary is placed in Worm.Boundary
*
*/
void FindWormBoundary(WormAnalysisData* Worm, WormAnalysisParam* Params){
/** This function currently takes around 5-7 ms **/
/**
* Before I forget.. plan to make this faster by:
* a) using region of interest
* b) decimating to make it smaller (maybe?)
* c) resize
* d) not using CV_GAUSSIAN for smoothing
*/
/** Smooth the Image **/
TICTOC::timer().tic("cvSmooth");
cvSmooth(Worm->ImgOrig,Worm->ImgSmooth,CV_GAUSSIAN,Params->GaussSize*2+1);
TICTOC::timer().toc("cvSmooth");
/** Dilate and Erode **/
// cvDilate(Worm->ImgSmooth, Worm->ImgSmooth,NULL,3);
// cvErode(Worm->ImgSmooth, Worm->ImgSmooth,NULL,2);
/** Threshold the Image **/
TICTOC::timer().tic("cvThreshold");
cvThreshold(Worm->ImgSmooth,Worm->ImgThresh,Params->BinThresh,255,CV_THRESH_BINARY );
TICTOC::timer().toc("cvThreshold");
/** Dilate and Erode **/
if (Params->DilateErode==1){
TICTOC::timer().tic("DilateAndErode");
cvDilate(Worm->ImgThresh, Worm->ImgThresh,NULL,3);
cvErode(Worm->ImgThresh, Worm->ImgThresh,NULL,2);
TICTOC::timer().toc("DilateAndErode");
}
/** Find Contours **/
CvSeq* contours;
IplImage* TempImage=cvCreateImage(cvGetSize(Worm->ImgThresh),IPL_DEPTH_8U,1);
cvCopy(Worm->ImgThresh,TempImage);
TICTOC::timer().tic("cvFindContours");
cvFindContours(TempImage,Worm->MemStorage, &contours,sizeof(CvContour),CV_RETR_EXTERNAL,CV_CHAIN_APPROX_NONE,cvPoint(0,0));
TICTOC::timer().toc("cvFindContours");
CvSeq* rough;
/** Find Longest Contour **/
TICTOC::timer().tic("cvLongestContour");
if (contours) LongestContour(contours,&rough);
TICTOC::timer().toc("cvLongestContour");
cvReleaseImage(&TempImage);
/** Smooth the Boundary **/
if (Params->BoundSmoothSize>0){
TICTOC::timer().tic("SmoothBoundary");
CvSeq* smooth=smoothPtSequence(rough,Params->BoundSmoothSize,Worm->MemStorage);
Worm->Boundary=cvCloneSeq(smooth);
TICTOC::timer().toc("SmoothBoundary");
} else {
Worm->Boundary=cvCloneSeq(rough);
}
}
/**
* @brief Main principal
* @param argc El número de argumentos del programa
* @param argv Cadenas de argumentos del programa
* @return Nada si es correcto o algún número negativo si es incorrecto
*/
int main( int argc, char** argv ) {
if( argc < 4 )
return -1;
// Declaración de variables
gsl_rng *rng;
IplImage *frame, *hsv_frame;
histogram **ref_histos, *histo_aux;
CvCapture *video;
particle **particles, **aux, **nuevas_particulas;
CvScalar color_rojo = CV_RGB(255,0,0), color_azul = CV_RGB(0,0,255);
CvRect *regions;
int num_objects = 0;
int i = 1, MAX_OBJECTS = atoi(argv[3]), PARTICLES = atoi(argv[2]);
FILE *datos;
char name[45], num[3], *p1, *p2;
clock_t t_ini, t_fin;
double ms;
video = cvCaptureFromFile( argv[1] );
if( !video ) {
printf("No se pudo abrir el fichero de video %s\n", argv[1]);
exit(-1);
}
first_frame = cvQueryFrame( video );
num_objects = get_regions( ®ions, MAX_OBJECTS, argv[1] );
if( num_objects == 0 )
exit(-1);
t_ini = clock();
hsv_frame = bgr2hsv( first_frame );
histo_aux = (histogram*) malloc( sizeof(histogram) );
histo_aux->n = NH*NS + NV;
nuevas_particulas = (particle**) malloc( num_objects * sizeof( particle* ) );
for( int j = 0; j < num_objects; ++j )
nuevas_particulas[j] = (particle*) malloc( PARTICLES * sizeof( particle ) );
// Computamos los histogramas de referencia y distribuimos las partículas iniciales
ref_histos = compute_ref_histos( hsv_frame, regions, num_objects );
particles = init_distribution( regions, num_objects, PARTICLES );
// Mostramos el tracking
if( show_tracking ) {
// Mostramos todas las partículas
if( show_all )
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j )
display_particle( first_frame, particles[k][j], color_azul );
// Dibujamos la partícula más prometedora de cada objeto
for( int k = 0; k < num_objects; ++k )
display_particle( first_frame, particles[k][0], color_rojo );
cvNamedWindow( "Video", 1 );
cvShowImage( "Video", first_frame );
cvWaitKey( 5 );
}
// Exportamos los histogramas de referencia y los frames
if( exportar ) {
export_ref_histos( ref_histos, num_objects );
export_frame( first_frame, 1 );
for( int k = 0; k < num_objects; ++k ) {
sprintf( num, "%02d", k );
strcpy( name, REGION_BASE);
p1 = strrchr( argv[1], '/' );
p2 = strrchr( argv[1], '.' );
strncat( name, (++p1), p2-p1 );
strcat( name, num );
strcat( name, ".txt" );
datos = fopen( name, "a+" );
if( ! datos ) {
printf("Error creando fichero para datos\n");
return -1;
}
fprintf( datos, "%d\t%f\t%f\n", 0, particles[k][0].x, particles[k][0].y );
fclose( datos );
}
}
cvReleaseImage( &hsv_frame );
// Inicializamos el generador de números aleatorios
gsl_rng_env_setup();
rng = gsl_rng_alloc( gsl_rng_mt19937 );
gsl_rng_set(rng, (unsigned long) time(NULL));
// Recordar que frame no se puede liberar debido al cvQueryFrame
while( frame = cvQueryFrame( video ) ) {
hsv_frame = bgr2hsv( frame );
// Realizamos la predicción y medición de probabilidad para cada partícula
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j ) {
transition( &particles[k][j], frame->width, frame->height, rng );
particles[k][j].w = likelihood( hsv_frame, &particles[k][j], ref_histos[k], histo_aux );
}
// Normalizamos los pesos y remuestreamos un conjunto de partículas no ponderadas
normalize_weights( particles, num_objects, PARTICLES );
for (int k = 0; k < num_objects; ++k )
resample( particles[k], PARTICLES, nuevas_particulas[k] );
aux = particles;
particles = nuevas_particulas;
nuevas_particulas = aux;
// Mostramos el tracking
if( show_tracking ) {
// Mostramos todas las partículas
if( show_all )
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j )
display_particle( frame, particles[k][j], color_azul );
// Dibujamos la partícula más prometedora de cada objeto
for( int k = 0; k < num_objects; ++k )
display_particle( frame, particles[k][0], color_rojo );
cvNamedWindow( "Video", 1 );
cvShowImage( "Video", frame );
cvWaitKey( 5 );
}
// Exportamos los histogramas de referencia y los frames
if( exportar ) {
export_frame( frame, i+1 );
for( int k = 0; k < num_objects; ++k ) {
sprintf( num, "%02d", k );
strcpy( name, REGION_BASE);
p1 = strrchr( argv[1], '/' );
p2 = strrchr( argv[1], '.' );
strncat( name, (++p1), p2-p1 );
strcat( name, num );
strcat( name, ".txt" );
datos = fopen( name, "a+" );
if( ! datos ) {
printf("Error abriendo fichero para datos\n");
return -1;
}
fprintf( datos, "%d\t%f\t%f\n", i, particles[k][0].x, particles[k][0].y );
fclose( datos );
}
}
cvReleaseImage( &hsv_frame );
++i;
}
// Liberamos todos los recursos usados (mallocs, gsl y frames)
cvReleaseCapture( &video );
gsl_rng_free( rng );
free( histo_aux );
free( regions );
for( int i = 0; i < num_objects; ++i ) {
free( ref_histos[i] );
free( particles[i] );
free( nuevas_particulas[i] );
}
free( particles );
free( nuevas_particulas );
t_fin = clock();
ms = ((double)(t_fin - t_ini) / CLOCKS_PER_SEC) * 1000.0;
printf("%d\t%d\t%.10g\n", PARTICLES, num_objects, ms);
}
int main(int argc, char *argv[])
{
IplImage *img = 0, *img2=0 ;
int height,width,step,channels;
int i,j,k;
if(argc<4){
printf("Usage: ./a.out <image-file-name> <watermarker image> <audio file>\n");
exit(0);
}
// load an image
img=cvLoadImage(argv[1]);
if(!img){
printf("Could not load image file: %s\n",argv[1]);
exit(0);
}
/// Load Watermark Image
img2=cvLoadImage(argv[2]);
if(!img2){
printf("Could not load image file: %s\n",argv[2]);
exit(0);
}
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
int nchannels = img->nChannels;
data = (uchar *)img->imageData;
int height2=img2->height;
int width2=img2->width;
int step2=img2->widthStep;
int channels2=img2->nChannels;
data2 = (uchar *)img2->imageData;
///// Inserting Watermark
insert_watermark(img,img2);
//Read an audio file and write into the image
FILE *fp=fopen(argv[3],"r");
if(fp==NULL){
printf("Could not load audio file: %s\n",argv[3]);
exit(0);
}
insert_audio(fp,img,img2);
//printf("%d row=%d col=%d \n",count1,row_count,col_count);
// Extract bit form count of total no. of Bytes which are presence in audio file
int a1,a2,a3,a4;
a1=count1%256;
a2=count1%65536;
a3=count1%16777216;
a4=count1%4294967296;
//printf("%d %d %d %d\n",a1,(a2-a1)>>8,(a3-a2)>>16,(a4-a3)>>24);
int size[4]={0};
size[0]=a1;
size[1]=(a2-a1)>>8;
size[2]=(a3-a2)>>16;
size[3]=(a4-a3)>>24;
printf("bytes=%d\n", size[0] | (size[1]<<8) | (size[2]<<16) | (size[3]<<24));
int val1,val2;
//insert the header of the audio//
for(i=0;i<4;i++)
{
a1=size[i]%4;
a2=size[i]%32;
a3=size[i]%256;
val1=(a2-a1)>>2;
val2=(a3-a2)>>5;
data[0+i*channels+0]= (data[0+i*channels+0] &252);
data[0+i*channels+1]= (data[0+i*channels+1] &248);
data[0+i*channels+2]= (data[0+i*channels+2] &248);
data[0+i*channels+0]= (data[0+i*channels+0] |a1);
data[0+i*channels+1]= (data[0+i*channels+1] |val1);
data[0+i*channels+2]= (data[0+i*channels+2] |val2);
}
cvSaveImage("new_image.png", img );
// create a window
cvNamedWindow("mainWin", CV_WINDOW_AUTOSIZE);
cvMoveWindow("mainWin", 100, 100);
// show the image
cvShowImage("mainWin", img );
// wait for a key
cvWaitKey(0);
// release the image
cvReleaseImage(&img );
return 0;
}
int main(void)
{
koki_camera_params_t params;
params.size.x = WIDTH;
params.size.y = HEIGHT;
params.principal_point.x = params.size.x / 2;
params.principal_point.y = params.size.y / 2;
params.focal_length.x = 571.0;
params.focal_length.y = 571.0;
int fd = koki_v4l_open_cam("/dev/video0");
struct v4l2_format fmt = koki_v4l_create_YUYV_format(WIDTH, HEIGHT);
koki_v4l_set_format(fd, fmt);
int num_buffers = 1;
koki_buffer_t *buffers;
buffers = koki_v4l_prepare_buffers(fd, &num_buffers);
koki_v4l_start_stream(fd);
while (1){
uint8_t *yuyv = koki_v4l_get_frame_array(fd, buffers);
IplImage *frame = koki_v4l_YUYV_frame_to_RGB_image(yuyv, WIDTH, HEIGHT);
IplImage *thresholded;
thresholded = koki_threshold_adaptive(frame, 5, 3,
KOKI_ADAPTIVE_MEAN);
cvShowImage("thresh", thresholded);
koki_labelled_image_t *l = koki_label_image(thresholded, 128);
for (int i=0; i<l->clips->len; i++){
if (!koki_label_useable(l, i))
continue;
GSList *contour = koki_contour_find(l, i);
koki_quad_t *quad = koki_quad_find_vertices(contour);
if (quad == NULL){
koki_contour_free(contour);
continue;
}
koki_contour_draw(frame, contour);
koki_quad_refine_vertices(quad);
koki_quad_draw(frame, quad);
koki_marker_t *marker;
marker = koki_marker_new(quad);
if (koki_marker_recover_code(marker, frame)){
koki_pose_estimate(marker, 0.11, ¶ms);
koki_bearing_estimate(marker);
printf("marker code: %d\n", marker->code);
}
koki_contour_free(contour);
koki_quad_free(quad);
koki_marker_free(marker);
}//for
cvShowImage("frame", frame);
cvWaitKey(1);
koki_labelled_image_free(l);
cvReleaseImage(&thresholded);
cvReleaseImage(&frame);
}
return 0;
cvDestroyWindow("frame");
cvDestroyWindow("thresh");
}
int main()
{
int c;//to store ascii value of key pressed
int i,j,h,s,v;
CvCapture *capture=cvCreateCameraCapture(0);//initiate camera
//because of recursively updating frame , here we dont need to wait for camera as for some ms frame will be black and then as camera starts , frame will update and shaw image
IplImage *frame;
IplImage* outputred;
IplImage* outputone;
IplImage* outputtwo;
// IplImage* outputblue;
IplImage* outputwhite;
// IplImage* outputorange;
uchar *ptemp;
// uchar *poutputorange;
uchar *poutputred;
uchar *poutputwhite;
// uchar *poutputblue;
uchar *poutputone;
uchar *poutputtwo;
if(capture!=NULL)
{
frame=cvQueryFrame(capture);//take current image in camera and give it to frame pointer
cvNamedWindow("img");
while(1)
{
cvShowImage("img",frame);
frame=cvQueryFrame(capture);
temp=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3);
cvCvtColor(frame,temp,CV_BGR2HSV);
//frame rate time period (if not given system will hang as system processing speed is very fast
// cvNamedWindow("output",1);
//cvShowImage("output",temp);
cvSetMouseCallback("img", my_mouse_callback, NULL);
c=cvWaitKey(1);
outputred=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
outputone=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
outputtwo=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
// outputblue=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
outputwhite=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
// outputorange=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1);
cvCvtColor(frame,temp,CV_BGR2HSV);
ptemp = (uchar*)temp->imageData;
poutputone = (uchar*)outputone->imageData;
poutputtwo = (uchar*)outputtwo->imageData;
// poutputblue = (uchar*)outputblue->imageData;
poutputwhite = (uchar*)outputwhite->imageData;
poutputred = (uchar*)outputred->imageData;
// poutputorange = (uchar*)outputorange->imageData;
for(i=0;i<frame->height;i++)
for(j=0;j<frame->width;j++)
{
h=ptemp[i*temp->widthStep + j*temp->nChannels+0];
s=ptemp[i*temp->widthStep + j*temp->nChannels+1];
v=ptemp[i*temp->widthStep + j*temp->nChannels+2];
if((h>=157&&h<=178)&&s>=110 && s<=255 &&v>=90)//red
poutputred[i*outputred->widthStep + j]=255;
else
poutputred[i*outputred->widthStep + j]=0;
if((h==0 && s==0 &&v<150 && v>9)||(h>=25 &&h<=110 && s>=20&&s<=200&& v>=13 && v<=120))//one
poutputone[i*outputone->widthStep + j]=255;
else
poutputone[i*outputone->widthStep + j]=0;
/* if((h>=145 &&h<=160)&&s>=175 && s<=255 && v>=80 && v<=150)//one
poutputone[i*outputone->widthStep + j]=255;
else
poutputone[i*outputone->widthStep + j]=0;
*/
if(h>=110 &&h<=153&&s>=90&&v>=7 && v<=150)//two
poutputtwo[i*outputtwo->widthStep + j]=255;
else
poutputtwo[i*outputtwo->widthStep + j]=0;
if( (h==0 && s==0 && v>=250) || (((h>=0 && h<=30)) && s>=50&&s<=200&&v>=110) )//white
poutputwhite[i*outputwhite->widthStep + j]=255;
else
poutputwhite[i*outputwhite->widthStep + j]=0;
}
//cvNamedWindow("output",1);
cvNamedWindow("outputred",1);
cvNamedWindow("outputone",1);
cvNamedWindow("outputtwo",1);
// cvNamedWindow("outputblue",1);
cvNamedWindow("outputwhite",1);
//cvNamedWindow("outputorange",1);
//cvShowImage("output",temp);
cvShowImage("outputred",outputred);
cvShowImage("outputone",outputone);
cvShowImage("outputtwo",outputtwo);
// cvShowImage("outputblue",outputblue);
cvShowImage("outputwhite",outputwhite);
// cvShowImage("outputorange",outputorange);
cvWaitKey(1);
/* imgOutred=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3);
labelImgred=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1);
CvBlobs blobsred;
cvLabel(outputred, labelImgred, blobsred);
cvRenderBlobs(labelImgred, blobsred, input, imgOutred);
cvFilterByArea(blobsred,PIXEL_MIN,PIXEL_MAX);
imgOutone=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3);
labelImgone=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1);
CvBlobs blobsone;
cvLabel(outputone, labelImgone, blobsone);
cvRenderBlobs(labelImgone, blobsone, input, imgOutone);
cvFilterByArea(blobsone,PIXEL_MIN,PIXEL_MAX);
imgOuttwo=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3);
labelImgtwo=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1);
CvBlobs blobstwo;
cvLabel(outputtwo, labelImgtwo, blobstwo);
cvRenderBlobs(labelImgtwo, blobstwo, input, imgOuttwo);
cvFilterByArea(blobstwo,PIXEL_MIN,PIXEL_MAX);
imgOutblue=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3);
labelImgblue=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1);
CvBlobs blobsblue;
cvLabel(outputblue, labelImgblue, blobsblue);
cvRenderBlobs(labelImgblue, blobsblue, input, imgOutblue);
cvFilterByArea(blobsblue,PIXEL_MIN,PIXEL_MAX);
imgOutwhite=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3);
labelImgwhite=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1);
CvBlobs blobswhite;
cvLabel(outputwhite, labelImgwhite, blobswhite);
cvRenderBlobs(labelImgwhite, blobswhite, input, imgOutwhite);
cvFilterByArea(blobswhite,PIXEL_MINWHITE,PIXEL_MAX);
*/
cvReleaseImage( &outputred );
cvReleaseImage( &outputone );
cvReleaseImage( &outputtwo );
//cvReleaseImage( &outputblue );
cvReleaseImage( &outputwhite );
//cvReleaseImage( &outputorange );
cvReleaseImage(&temp );
//cvDestroyWindow( "output" );
if(c>0&&c<255)
{
cvDestroyWindow( "img" );
cvReleaseImage( &frame );
cvReleaseCapture(&capture);
// cvDestroyWindow( "outputred" );
//cvDestroyWindow( "output" );
// cvDestroyWindow( "outputone" );
// cvDestroyWindow( "outputtwo" );
//cvDestroyWindow( "outputblue" );
// cvDestroyWindow( "outputwhite" );
//cvDestroyWindow( "outputorange" );
cvReleaseImage( &outputred );
cvReleaseImage( &outputone );
cvReleaseImage( &outputtwo );
//cvReleaseImage( &outputblue );
cvReleaseImage( &outputwhite );
//cvReleaseImage( &outputorange );
return 0;
}
}
}
}
bool CvCaptureCAM_DC1394_v2_CPP::grabFrame()
{
dc1394capture_policy_t policy = DC1394_CAPTURE_POLICY_WAIT;
bool code = false, isColor;
dc1394video_frame_t *dcFrame = 0, *fs = 0;
int i, nch;
if (!dcCam || (!started && !startCapture()))
return false;
dc1394_capture_dequeue(dcCam, policy, &dcFrame);
if (!dcFrame)
return false;
if (/*dcFrame->frames_behind > 1 ||*/ dc1394_capture_is_frame_corrupt(dcCam, dcFrame) == DC1394_TRUE)
{
goto _exit_;
}
isColor = dcFrame->color_coding != DC1394_COLOR_CODING_MONO8 &&
dcFrame->color_coding != DC1394_COLOR_CODING_MONO16 &&
dcFrame->color_coding != DC1394_COLOR_CODING_MONO16S;
if (nimages == 2)
{
fs = (dc1394video_frame_t*)calloc(1, sizeof(*fs));
//dc1394_deinterlace_stereo_frames(dcFrame, fs, DC1394_STEREO_METHOD_INTERLACED);
dc1394_deinterlace_stereo_frames_fixed(dcFrame, fs, DC1394_STEREO_METHOD_INTERLACED);
dc1394_capture_enqueue(dcCam, dcFrame); // release the captured frame as soon as possible
dcFrame = 0;
if (!fs->image)
goto _exit_;
isColor = colorStereo;
}
nch = isColor ? 3 : 1;
for (i = 0; i < nimages; i++)
{
IplImage fhdr;
dc1394video_frame_t f = fs ? *fs : *dcFrame, *fc = &f;
f.size[1] /= nimages;
f.image += f.size[0] * f.size[1] * i; // TODO: make it more universal
if (isColor)
{
if (!frameC)
frameC = (dc1394video_frame_t*)calloc(1, sizeof(*frameC));
frameC->color_coding = nch == 3 ? DC1394_COLOR_CODING_RGB8 : DC1394_COLOR_CODING_MONO8;
if (nimages == 1)
{
dc1394_convert_frames(&f, frameC);
dc1394_capture_enqueue(dcCam, dcFrame);
dcFrame = 0;
}
else
{
f.color_filter = bayerFilter;
dc1394_debayer_frames(&f, frameC, bayer);
}
fc = frameC;
}
if (!img[i])
img[i] = cvCreateImage(cvSize(fc->size[0], fc->size[1]), 8, nch);
cvInitImageHeader(&fhdr, cvSize(fc->size[0], fc->size[1]), 8, nch);
cvSetData(&fhdr, fc->image, fc->size[0]*nch);
// Swap R&B channels:
if (nch==3)
cvConvertImage(&fhdr,&fhdr,CV_CVTIMG_SWAP_RB);
if( rectify && cameraId == VIDERE && nimages == 2 )
{
if( !maps[0][0] || maps[0][0]->width != img[i]->width || maps[0][0]->height != img[i]->height )
{
CvSize size = cvGetSize(img[i]);
cvReleaseImage(&maps[0][0]);
cvReleaseImage(&maps[0][1]);
cvReleaseImage(&maps[1][0]);
cvReleaseImage(&maps[1][1]);
maps[0][0] = cvCreateImage(size, IPL_DEPTH_16S, 2);
maps[0][1] = cvCreateImage(size, IPL_DEPTH_16S, 1);
maps[1][0] = cvCreateImage(size, IPL_DEPTH_16S, 2);
maps[1][1] = cvCreateImage(size, IPL_DEPTH_16S, 1);
char buf[4*4096];
if( getVidereCalibrationInfo( buf, (int)sizeof(buf) ) &&
initVidereRectifyMaps( buf, maps[0], maps[1] ))
;
else
rectify = false;
}
cvRemap(&fhdr, img[i], maps[i][0], maps[i][1]);
}
else
cvCopy(&fhdr, img[i]);
}
code = true;
_exit_:
if (dcFrame)
dc1394_capture_enqueue(dcCam, dcFrame);
if (fs)
{
if (fs->image)
free(fs->image);
free(fs);
}
return code;
}
ofxCvOpticalFlowLK::~ofxCvOpticalFlowLK(void)
{
cvReleaseImage(&vel_x);
cvReleaseImage(&vel_y);
}
BOOL CFaceProcess::OnSavePic()
{
// TODO: Add your control notification handler code here
KillTimer(timer);
if (!m_Video){
// {AfxMessageBox("先打开摄像头"); return false; }
// m_GrabFrame=cvQueryFrame(m_Video);
// if (!m_GrabFrame)
// {AfxMessageBox("截取视屏帧失败，请重试！"); return false; }
//static char countsnap='1';
if( !cvGrabFrame( m_Video))
return FALSE;
m_GrabFrame = cvRetrieveFrame(m_Video );
if( !m_GrabFrame)
return FALSE;
if( !m_SaveFrame)
m_SaveFrame = cvCreateImage( cvSize(m_GrabFrame->width,m_GrabFrame->height),
IPL_DEPTH_8U, m_GrabFrame->nChannels );
if( m_GrabFrame->origin == IPL_ORIGIN_TL )
cvCopy( m_GrabFrame, m_SaveFrame, 0 );
else
cvFlip( m_GrabFrame, m_SaveFrame, 0 );
}//if (!m_Video){
static int countsnap=1;
CString m_name1=GetImageName(path,countsnap);
/*********加上后缀名称,加上存放相对路径*********************/
CString headPath="ImageLab/";
m_name1=headPath+m_name1+".pgm";
const char* pszStr1 = m_name1.GetBuffer(m_name1.GetLength());
//AfxMessageBox(m_name);
IplImage * m_snap1=cvCreateImage(cvGetSize(m_SaveFrame),m_SaveFrame->depth,m_SaveFrame->nChannels);
cvCopy(m_SaveFrame,m_snap1,NULL);
//m_snap1->origin=1;//等于0保存倒立图向
IplImage *faceImage1=0;
IplImage *faceGray1=0;
//检测人脸
try{
if(faceDetector.detect_and_draw(m_snap1)){
faceImage1=faceDetector.getFaceImage();
// faceImage1->origin=1;
//化简图片
if(faceSimplifier.Simplify(faceImage1)){
faceGray1=faceSimplifier.getFaceImage();
//faceGray1->origin=1;//等于0保存倒立图向
cvSaveImage(pszStr1,faceGray1); //把图像写入文件
countsnap++;
}
}
SetTimer(timer,1,NULL) ;
}catch(...)
{
SetTimer(timer,1,NULL) ;
AfxMessageBox("保存图片失败--OnSavePic！！");
return false;
}
if(countsnap>3)
GetDlgItem(IDC_OK)->EnableWindow(TRUE);//使控件有效
if(m_snap1)
cvReleaseImage(&m_snap1);
if(faceImage1)
cvReleaseImage(&faceImage1);
if(faceGray1)
cvReleaseImage(&faceGray1);
return true;
}
int main()
{
// Initialize capturing live feed from the camera
CvCapture* capture = 0;
capture = cvCaptureFromCAM(1); //depending on from which camera you are Capturing
// Couldn't get a device? Throw an error and quit
if(!capture)
{
printf("Could not initialize capturing...\n");
return -1;
}
// The two windows we'll be using
cvNamedWindow("video");
cvNamedWindow("thresh");
// This image holds the "scribble" data...
// the tracked positions of the ball
IplImage* imgScribble = NULL;
// An infinite loop
while(true)
{
// Will hold a frame captured from the camera
IplImage* frame = 0;
frame = cvQueryFrame(capture);
// If we couldn't grab a frame... quit
if(!frame)
break;
// If this is the first frame, we need to initialize it
if(imgScribble == NULL)
{
imgScribble = cvCreateImage(cvGetSize(frame), 8, 3);
}
// Holds the yellow thresholded image (yellow = white, rest = black)
IplImage* imgYellowThresh = GetThresholdedImage(frame);
// Calculate the moments to estimate the position of the ball
CvMoments *moments = (CvMoments*)malloc(sizeof(CvMoments));
cvMoments(imgYellowThresh, moments, 1);
// The actual moment values
double moment10 = cvGetSpatialMoment(moments, 1, 0);
double moment01 = cvGetSpatialMoment(moments, 0, 1);
double area = cvGetCentralMoment(moments, 0, 0);
// Holding the last and current ball positions
static int posX = 0;
static int posY = 0;
int lastX = posX;
int lastY = posY;
posX = moment10/area;
posY = moment01/area;
// Print it out for debugging purposes
printf("position (%d,%d)\n", posX, posY);
// We want to draw a line only if its a valid position
if(lastX>0 && lastY>0 && posX>0 && posY>0)
{
// Draw a yellow line from the previous point to the current point
cvLine(imgScribble, cvPoint(posX, posY), cvPoint(lastX, lastY), cvScalar(0,255,255), 5);
}
// Add the scribbling image and the frame... and we get a combination of the two
cvAdd(frame, imgScribble, frame);
cvShowImage("thresh", imgYellowThresh);
cvShowImage("video", frame);
// Wait for a keypress
int c = cvWaitKey(10);
if(c!=-1)
{
// If pressed, break out of the loop
break;
}
// Release the thresholded image... we need no memory leaks.. please
cvReleaseImage(&imgYellowThresh);
delete moments;
}
// We're done using the camera. Other applications can now use it
cvReleaseCapture(&capture);
return 0;
}
