V1z em 13h28min de 15 de setembro de 2011

2011-09-15T13:28:34Z

← Edição anterior		Edição das 10h28min de 15 de setembro de 2011
Linha 434:		Linha 434:

	Pode comentar, se precisar de me contatar veja meus contatos [[Nivaldo Bondança\|aqui]]		Pode comentar, se precisar de me contatar veja meus contatos [[Nivaldo Bondança\|aqui]]

			[[Category:Lab Macambira]]

Hick209 em 23h23min de 14 de setembro de 2011

2011-09-14T23:23:50Z

← Edição anterior		Edição das 20h23min de 14 de setembro de 2011
Linha 1:		Linha 1:
	Aí está o código, na íntegra		Aí está o código, na íntegra

			<i> Em Breve: </i> More comments!

	<pre>		<pre>

Hick209: Nova página: Aí está o código, na íntegra

 /*     Programa esqueleto da AirHackTable  */  #include "opencv/highgui.h" #include "opencv/cv.h" #include    using namespace cv;   voi...

2011-09-13T00:13:13Z

Nova página: Aí está o código, na íntegra <pre> Programa esqueleto da AirHackTable: #include "opencv/highgui.h" #include "opencv/cv.h" #include <stdio.h> using namespace cv; voi...

Página nova

Aí está o código, na íntegra

<pre>
/*
Programa esqueleto da AirHackTable
*/

#include "opencv/highgui.h"
#include "opencv/cv.h"
#include <stdio.h>

using namespace cv;

void pausef(void);

class ColorHistogram
{
private:
int histSize[3];
float hranges[2];
const float* ranges[3];
int channels[3];
public:
ColorHistogram()
{
// Prepare arguments for a color histogram
histSize[0]= histSize[1]= histSize[2]= 256;
hranges[0]= 0.0; // BRG range
hranges[1]= 255.0;
ranges[0]= hranges; // all channels have the same range
ranges[1]= hranges;
ranges[2]= hranges;
channels[0]= 0; // the three channels
channels[1]= 1;
channels[2]= 2;
}

cv::MatND getHistogram(const cv::Mat &image)
{
cv::MatND hist;
// Compute histogram
cv::calcHist(&image,
1, // histogram of 1 image only
channels, // the channel used
cv::Mat(), // no mask is used
hist, // the resulting histogram
3, // it is a 3D histogram
histSize, // number of bins
ranges // pixel value range
);
return hist;
}

// Computes the 1D Hue histogram with a mask.
// BGR source image is converted to HSV
// Pixels with low saturation are ignored
cv::MatND getHueHistogram(const cv::Mat &image,
int minSaturation=0)
{
cv::MatND hist;

// Convert to HSV color space
cv::Mat hsv;
cv::cvtColor(image, hsv, CV_BGR2HSV);

// Mask to be used (or not)
cv::Mat mask;
if (minSaturation>0)
{
// Spliting the 3 channels into 3 images
std::vector<cv::Mat> v;
cv::split(hsv,v);

// Mask out the low saturated pixels
cv::threshold(v[1],mask,minSaturation,255,
cv::THRESH_BINARY);
}

// Prepare arguments for a 1D hue histogram
hranges[0]= 0.0;
hranges[1]= 180.0;
channels[0]= 0; // the hue channel

// Compute histogram
cv::calcHist(&hsv,
1, // histogram of 1 image only
channels, // the channel used
mask, // binary mask
hist, // the resulting histogram
1, // it is a 1D histogram
histSize, // number of bins
ranges // pixel value range
);

return hist;
}
};

class ContentFinder
{
private:
float hranges[2];
const float* ranges[3];
int channels[3];
float threshold;
cv::MatND histogram;
public:
ContentFinder() : threshold(-1.0f)
{
ranges[0]= hranges; // all channels have same range
ranges[1]= hranges;
ranges[2]= hranges;
}
// Sets the threshold on histogram values [0,1]
void setThreshold(float t)
{
threshold= t;
}
// Gets the threshold
float getThreshold()
{
return threshold;
}
// Sets the reference histogram
void setHistogram(const MatND& h)
{
histogram= h;
cv::normalize(histogram,histogram,1.0);
}

Mat find(const cv::Mat& image)
{
Mat result;

hranges[0]= 0.0; // range [0,255]
hranges[1]= 255.0;
channels[0]= 0; // the three channels
channels[1]= 1;
channels[2]= 2;

cv::calcBackProject(&image,
1, // one image
channels, // vector specifying what histogram dimensions belong to what image channels
histogram, // the histogram we are using
result, // the resulting back projection image
ranges, // the range of values, for each dimension
255.0 // the scaling factor is chosen such that a histogram value of 1 maps to 255
);

// Threshold back projection to obtain a binary image
if (threshold>0.0)
cv::threshold(result, result, 255*threshold, 255, cv::THRESH_BINARY);

return result;
}

Mat find(const cv::Mat& image, float minValue, float maxValue, int *channels, int dim) {

cv::Mat result;

hranges[0]= minValue;
hranges[1]= maxValue;

for (int i=0; i<dim; i++)
this->channels[i]= channels[i];

// NOT USING THIS PART
// if (isSparse) { // call the right function based on histogram type
//
// cv::calcBackProject(&image,
// 1, // we only use one image at a time
// channels, // vector specifying what histogram dimensions belong to what image channels
// shistogram, // the histogram we are using
// result, // the resulting back projection image
// ranges, // the range of values, for each dimension
// 255.0 // the scaling factor is chosen such that a histogram value of 1 maps to 255
// );
//
// } else {

cv::calcBackProject(&image,
1, // we only use one image at a time
channels, // vector specifying what histogram dimensions belong to what image channels
histogram, // the histogram we are using
result, // the resulting back projection image
ranges, // the range of values, for each dimension
255.0 // the scaling factor is chosen such that a histogram value of 1 maps to 255
);
// }

// Threshold back projection to obtain a binary image
if (threshold>0.0)
cv::threshold(result, result, 255*threshold, 255, cv::THRESH_BINARY);

return result;
}
};

// AirHackTable
class AHT
{
private:
// int pad;
#define TAM 1
#define PAD 15
// amount of circles to be detected
ContentFinder circleFinder;
ColorHistogram hist;
Point circleCenter;
Point circleCenter2;

void sharpen(Mat &image)
{
// Construct kernel (all entries initialized to 0)
Mat kernel(3,3,CV_32F,Scalar(0));

// assigns kernel values
kernel.at<float>(1,1)= 5.0;
kernel.at<float>(0,1)= -1.0;
kernel.at<float>(2,1)= -1.0;
kernel.at<float>(1,0)= -1.0;
kernel.at<float>(1,2)= -1.0;

// filter the image
filter2D( image, image, image.depth(), kernel);
}

void colorReduce(Mat &image, int div=64)
{
int nl = image.rows; // number of lines
// total number of elements per line
int nc = image.cols * image.channels();
for (int j = 0; j < nl; j++)
{
// get the address of row j
uchar* data = image.ptr<uchar>(j);
for (int i = 0; i < nc; i++)
{
data[i] = data[i]/div*div + div/2;
} // end of line
}
}

public:
Mat process(Mat &image)
{
Mat result, thres;

flip( image, image, 1 );

sharpen( image );

colorReduce( image, 32 );

cvtColor( image, result, CV_RGB2GRAY );

equalizeHist( result, result );

// Canny( result, result, 0, 255);

GaussianBlur( result, result, Size(7,7) , 3);

// threshold( result, thres, 110, 255, CV_THRESH_BINARY);

// result += thres/10;

return result;
}

// old version, not using anymore
// it is still here so I can use its code
void findCircles(Mat &image, Mat result, int minSaturation=0)
{
circleFinder.setThreshold(0.05f);

// pad = 15;

double count, sx[TAM] = { 0 }, sy[TAM] = { 0 };

// holds the detected circles
vector<Vec3f> circles;

HoughCircles( result( Rect( PAD, PAD, result.cols-PAD, result.rows-PAD) ), circles, CV_HOUGH_GRADIENT, 1.65, 32);

// TODO
// To be improved
for( size_t i = 0, count = 0; i < circles.size() && count < TAM; i++, count++ )
{
Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));

// if ( (center.x - sx[count] < 5) && ( center.y - sy[count] < 5) )
{
Mat ROI = image( Rect( center.x-PAD, center.y-PAD, 2*PAD, 2*PAD ) );
circleFinder.setHistogram(hist.getHueHistogram(ROI, minSaturation));

// hist = f.find(image);
// hist += f.find(image);

circle( image, Point(center.x+PAD, center.y+PAD) , 19, 255, 2 );
}

sx[count] = center.x;
sy[count] = center.y;
}
}

void getCircles(Mat image, Mat result, int minSaturation=0)
{
// holds the detected circles
vector<Vec3f> circles;

HoughCircles( result( Rect( PAD, PAD, result.cols-PAD, result.rows-PAD) ), circles, CV_HOUGH_GRADIENT, 1.65, 32);

// TODO
if( circles.size() )
{
Point center(cvRound(circles[0][0]), cvRound(circles[0][1]));

Mat ROI = image( Rect( center.x-PAD, center.y-PAD, 2*PAD, 2*PAD ) );
circleFinder.setHistogram(hist.getHueHistogram(ROI, minSaturation));

circleCenter = center;
}
}

// not using yet
void nextPosition(Mat image, int minSaturation=0)
{
Mat hsv;
// Convert to HSV space
cvtColor( image, hsv, CV_BGR2HSV );

std::vector<Mat> v;
// Split the image
split( hsv, v );

// Identify pixels with low saturation
threshold( v[1], v[1], minSaturation, 255, THRESH_BINARY );

int ch[1]={0};
// Get back-projection of hue histogram
Mat result = circleFinder.find( hsv, 0.0f, 180.0f, ch,1 );

// Eliminate low stauration pixels
bitwise_and( result, v[1], result );

Rect rect(circleCenter.x+PAD,circleCenter.y+PAD,1,1);
// rectangle(image, rect, cv::Scalar(0,0,255));

TermCriteria criteria( cv::TermCriteria::MAX_ITER, 10, 0.01 );

meanShift( result, rect, criteria );

circleCenter2.x = rect.x;
circleCenter2.y = rect.y;
// return result;
}

void drawCircle(Mat &image)
{
if( circleCenter.x != 0 )
circle( image, Point(circleCenter.x+PAD, circleCenter.y+PAD) , 19, 255, 2 );
if( circleCenter2.x != 0 )
circle( image, Point(circleCenter2.x, circleCenter2.y) , 19, 0, 2 );
}
};

int main( int argc, char** argv )
{
char c;
int minSat = 65;

namedWindow( "player", 0 );
// namedWindow( "mod", 0 );
// namedWindow( "Histogram", 0 );

CvCapture *cam;

if( argc != 2 )
cam = cvCreateCameraCapture(0);
// else
// cam.open( string(argv[1]) )
Mat frame, modframe;

AHT image;

while(1)
{
// gets the next frame
frame = cvQueryFrame(cam);

if(!frame.data) break;

modframe = image.process(frame);

// look for the circles
// image.findCircles(frame, modframe);
if( c == 'g' )
image.getCircles(frame, modframe, minSat);
if( c == 'n' )
image.nextPosition(frame, minSat);

image.drawCircle(frame);

// show results
// imshow("Histogram", hist);
imshow( "player", frame );
// imshow( "mod", modframe );

c = cvWaitKey(3);
// c == ESC
if( c == 27 ) break;
else if( c == ' ' || c == 'p' ) pausef();
}

destroyWindow("player");
// destroyWindow("mod");
// destroyWindow("Histogram");

return 0;
}

void pausef()
{
char c = 0;
while( c != 'p' && c != ' ' )
c = cvWaitKey(0);
}
</pre>

Pode comentar, se precisar de me contatar veja meus contatos [[Nivaldo Bondança|aqui]]

AHTcode - Histórico de revisão

V1z em 13h28min de 15 de setembro de 2011

Hick209 em 23h23min de 14 de setembro de 2011

Hick209: Nova página: Aí está o código, na íntegra
/* Programa esqueleto da AirHackTable */ #include "opencv/highgui.h" #include "opencv/cv.h" #include using namespace cv; voi...