int
main (int argc, char **argv)
{
CvCapture *capture = 0;
IplImage *frame = 0;
double w = 320, h = 240;
int c;
// (1)コマンド引数によって指定された番号のカメラに対するキャプチャ構造体を作成する
if (argc == 1 || (argc == 2 && strlen (argv[1]) == 1 && isdigit (argv[1][0])))
capture = cvCreateCameraCapture (argc == 2 ? argv[1][0] - '0' : 0);
/* この設定は，利用するカメラに依存する */
// (2)キャプチャサイズを設定する．
//cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, w);
//cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, h);
cvNamedWindow ("Capture", CV_WINDOW_AUTOSIZE);
// (3)カメラから画像をキャプチャする
{
IplImage *src_img_gray, *tmp_img_gray, *dst_img_gray;
// (a) 画像処用の画像データを確保
frame = cvQueryFrame (capture);
frame = cvQueryFrame (capture);
frame = cvQueryFrame (capture);
tmp_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_16S, 1);
src_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 1);
dst_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 1);
while (1) {
frame = cvQueryFrame (capture);
// (b)グレイ画像を作成
cvCvtColor(frame, src_img_gray, CV_BGR2GRAY);
// (c)Edge処理
if ( 0 ) {
cvCanny (src_img_gray, dst_img_gray, 50.0, 200.0, 3);
}else{
cvLaplace (src_img_gray, tmp_img_gray, 5);
cvConvertScaleAbs(tmp_img_gray, dst_img_gray, 1, 0);
}
// (d)結果を表示する
cvShowImage ("Capture", dst_img_gray);
c = cvWaitKey (10);
if (c == '\x1b')
break;
}
}
cvReleaseCapture (&capture);
cvDestroyWindow ("Capture");
return 0;
}
// ÀÆÕÀ˹±ä»»
int main( int argc, char** argv )
{
IplImage* laplace = 0;
IplImage* colorlaplace = 0;
IplImage* planes[3] = { 0, 0, 0 };
CvCapture* capture = 0;
if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])))
capture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 );
else if( argc == 2 )
capture = cvCaptureFromAVI( argv[1] );
if( !capture )
{
fprintf(stderr,"Could not initialize capturing...\n");
return -1;
}
cvNamedWindow( "Laplacian", 0 );
for(;;)
{
IplImage* frame = 0;
int i;
frame = cvQueryFrame( capture );
if( !frame )
break;
if( !laplace )
{
for( i = 0; i < 3; i++ )
planes[i] = cvCreateImage( cvSize(frame->width,frame->height), 8, 1 );
laplace = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_16S, 1 );
colorlaplace = cvCreateImage( cvSize(frame->width,frame->height), 8, 3 );
}
cvCvtPixToPlane( frame, planes[0], planes[1], planes[2], 0 );
for( i = 0; i < 3; i++ )
{
cvLaplace( planes[i], laplace, 3 );
cvConvertScaleAbs( laplace, planes[i], 1, 0 );
}
cvCvtPlaneToPix( planes[0], planes[1], planes[2], 0, colorlaplace );
colorlaplace->origin = frame->origin;
cvShowImage("Laplacian", colorlaplace );
if( cvWaitKey(10) >= 0 )
break;
}
cvReleaseCapture( &capture );
cvDestroyWindow("Laplacian");
return 0;
}
void COpenCVMFCView::OnLaplace()
{
// TODO: Add your command handler code here
IplImage* pImage;
IplImage* pImgLaplace = NULL;
IplImage* pImgPlanes[3] = {0,0,0};
int i;
pImage = workImg;
pImgLaplace = cvCreateImage(cvGetSize(pImage),
IPL_DEPTH_16S,1);
if (workImg->nChannels == 1) {
cvLaplace(pImage,pImgLaplace,3);
cvConvertScaleAbs(pImgLaplace,pImage, 1, 0 );
}
else {
for (i = 0; i < 3; i++) {
pImgPlanes[i] = cvCreateImage(cvGetSize(pImage),
IPL_DEPTH_8U,1);
}
cvCvtPixToPlane(pImage,pImgPlanes[0],
pImgPlanes[1],pImgPlanes[2],0);
for (i = 0; i < 3; i++) {
cvLaplace(pImgPlanes[i],pImgLaplace,3);
cvConvertScaleAbs(pImgLaplace,pImgPlanes[i], 1, 0 );
}
cvCvtPlaneToPix(pImgPlanes[0],pImgPlanes[1],
pImgPlanes[2],0,pImage);
for (i = 0; i < 3; i++) {
cvReleaseImage(&pImgPlanes[i]);
}
}
cvReleaseImage(&pImgLaplace);
Invalidate();
}
typename image<T, D>::create_new laplace(const image<T, D>& a,
int aperture_size)
{
IplImage* src = a.ipl();
IplImage* dst = cvCreateImage(cvGetSize(src),
image_details::ipl_depth<T>(), int(a.channels()));
cvLaplace(src, dst, aperture_size);
typename image<T, D>::create_new r(dst);
cvReleaseImage(&src);
cvReleaseImage(&dst);
return r;
}
static GstFlowReturn
gst_cv_laplace_transform (GstOpencvVideoFilter * base, GstBuffer * buf,
IplImage * img, GstBuffer * outbuf, IplImage * outimg)
{
GstCvLaplace *filter = GST_CV_LAPLACE (base);
g_assert (filter->intermediary_img);
cvLaplace (img, filter->intermediary_img, filter->aperture_size);
cvConvertScale (filter->intermediary_img, outimg, 1, 0);
return GST_FLOW_OK;
}
int main(int argc, char *argv[])
{
IplImage* img = 0;
IplImage* img2 = 0;
int height,width,step,channels;
uchar *data;
int i,j,k;
if(argc<2){
printf("Usage: main <image-file-name>\n\7");
exit(0);}
// load an image
img=cvLoadImage(argv[1]);
if(!img){
printf("Could not load image file: %s\n",argv[1]);
exit(0);
}
// get the image data
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
printf("Processing a %dx%d image with %d channels and widthStep=%d\n",height,width,channels,step);
cvNamedWindow("mainWin", CV_WINDOW_AUTOSIZE); // create a window
cvMoveWindow("mainWin", 100, 100);//offset from the upper-left corner of the screen
// invert the image
for(i=0;i<height;i++) for(j=0;j<width;j++) for(k=0;k<channels;k++)
data[i*step+j*channels+k]=255-data[i*step+j*channels+k];
cvShowImage("mainWin1", img ); // show the image
cvWaitKey(0); // wait for a key
cvCircle(img, cvPoint(100,100), 20, cvScalar(0,255,0), 1);//draw a circle at (100,100) with a r=20. green lines of width 1
cvShowImage("mainWin2", img ); // show the image
cvWaitKey(0); // wait for a key
img2=cvCreateImage(cvSize(img->width,img->height),IPL_DEPTH_32F,3);//allocates memory for image 2
cvLaplace( img, img2, 3); //computes Laplacian of img and puts the result on img2.
cvShowImage("mainWin3", img2 );// show the image
cvWaitKey(0); // wait for a key
// release the images
cvReleaseImage(&img );
cvReleaseImage(&img2 );
return 0;
}
void ImageProcessorCV::Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage)
{
if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height ||
pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale)
return;
IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage);
IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage);
IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1);
cvLaplace(pIplInputImage, pIplTempImage, 5);
cvConvertScaleAbs(pIplTempImage, pIplOutputImage);
cvReleaseImage(&pIplTempImage);
cvReleaseImageHeader(&pIplInputImage);
cvReleaseImageHeader(&pIplOutputImage);
}
static CvMat* extractEdges( IplImage* img, image_type_t source )
{
CvMat* temp_16sc;
CvMat* temp_8uc;
CvMat* edges;
edges = cvCreateMat( img->height, img->width, CV_8UC1 );
temp_16sc = cvCreateMat( img->height, img->width, CV_16SC1 );
temp_8uc = cvCreateMat( img->height, img->width, CV_8UC1 );
cvZero(edges);
void accumulateEdgesFromChannel( int channel )
{
if( channel > 0 )
cvSetImageCOI( img, channel );
cvCopy(img, temp_8uc, NULL); // needed only becaues cvLaplace() doesn't support COI
if( source == PHOTO )
cvSmooth(temp_8uc, temp_8uc, CV_GAUSSIAN, PHOTO_PRESMOOTH, PHOTO_PRESMOOTH, 0.0, 0.0);
cvLaplace(temp_8uc, temp_16sc, 3);
cvAbs( temp_16sc, temp_16sc );
cvAdd( edges, temp_16sc, edges, NULL);
}
if( img->nChannels == 1 )
accumulateEdgesFromChannel( -1 );
else if( source != PHOTO )
accumulateEdgesFromChannel( 1 );
else
for(int i = 0; i < 3; i++)
accumulateEdgesFromChannel( i+1 );
cvReleaseMat(&temp_16sc);
cvReleaseMat(&temp_8uc);
return edges;
}
static void node_composit_exec_cvLaplace(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
{
IplImage *image, *laplace_img, *img_grey;
int aperture;
CV_FUNCNAME( "cvLaplace" );
if(out[0]->hasoutput==0) return;
cvSetErrMode(1); //Parent mode error
__CV_BEGIN__;
if(in[0]->data){
switch(node->custom1){
case 0:
CV_CALL(aperture=3);
break;
case 1:
CV_CALL(aperture=1);
break;
case 2:
CV_CALL(aperture=5);
break;
case 3:
CV_CALL(aperture=7);
break;
case 4:
CV_CALL(aperture=9);
break;
}
CV_CALL(image = in[0]->data);
laplace_img= cvCreateImage(cvSize(image->width,image->height),32,1);
img_grey= cvCreateImage(cvSize(image->width,image->height),IPL_DEPTH_8U,1);
CV_CALL(cvCvtColor(image,img_grey, CV_BGR2GRAY));
CV_CALL(cvLaplace(img_grey,laplace_img,aperture));
CV_CALL(out[0]->data= laplace_img);
}
__CV_END__;
}
CV_IMPL void cvDistReg(const CvArr* srcarr,
CvArr* dstarr)
{
CV_FUNCNAME("cvDistReg");
__BEGIN__;
CvMat sstub, *src;
CvMat dstub, *dst;
CvMat* src_dx=0, *src_dy=0, *s=0, *ps=0;
CvMat* dps_x=0, *dps_y=0, *del=0, *ones=0;
CvSize size;
int i, j, iStep_s, iStep_ps;
float* fPtr_s, *fPtr_ps;
float temp_s=0.0f, temp_ps=0.0f;
float flag_s1=0.0f, flag_s2=0.0f, flag_ps1=0.0f, flag_ps2=0.0f;
CV_CALL( src = cvGetMat(srcarr, &sstub ));
CV_CALL( dst = cvGetMat(dstarr, &dstub ));
if( CV_MAT_TYPE(src->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( CV_MAT_TYPE(dst->type) != CV_32FC1)
CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" );
if( !CV_ARE_SIZES_EQ( src, dst ))
CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" );
size = cvGetMatSize( src );
src_dx = cvCreateMat(size.height, size.width, CV_32FC1 );
src_dy = cvCreateMat(size.height, size.width, CV_32FC1 );
s = cvCreateMat(size.height, size.width, CV_32FC1 );
ps = cvCreateMat(size.height, size.width, CV_32FC1 );
dps_x = cvCreateMat(size.height, size.width, CV_32FC1 );
dps_y = cvCreateMat(size.height, size.width, CV_32FC1 );
del = cvCreateMat(size.height, size.width, CV_32FC1 );
ones = cvCreateMat(size.height, size.width, CV_32FC1 );
cvSetZero(src_dx);
cvSetZero(src_dy);
cvSetZero(s);
cvSetZero(ps);
cvSetZero(dps_x);
cvSetZero(dps_y);
cvSetZero(del);
cvSet(ones, cvScalar(1.0f));
iStep_s = s->step / sizeof(fPtr_s[0]);
fPtr_s = s->data.fl;
iStep_ps= ps->step/ sizeof(fPtr_ps[0]);
fPtr_ps = ps->data.fl;
cvSobel(src, src_dx, 1, 0, 1);
cvSobel(src, src_dy, 0, 1, 1);
cvMul(src_dx, ones, src_dx, 0.25f);
cvMul(src_dy, ones, src_dy, 0.25f);
cvCalS(src,s);
for (j=0; j<size.height; j++){
for (i=0; i<size.width; i++){
temp_s = fPtr_s[i+iStep_s*j];
if (int(temp_s*10000)>=0 && int(temp_s*10000)<=10000) {
flag_s1 = 1.0f;
} else {
flag_s1 = 0.0f;
}
if (int(temp_s*10000) > 10000) {
flag_s2 = 1.0f;
} else {
flag_s2 = 0.0f;
}
temp_ps = flag_s1*sin(2*PI*temp_s)/2/PI+flag_s2*(temp_s-1.0f);
if (int(temp_ps*10000) == 0) {
flag_ps1 = 0.0f;
} else {
flag_ps1 = 1.0f;
}
if (int(temp_s*10000) == 0) {
flag_ps2 = 0.0f;
} else {
flag_ps2 = 1.0f;
}
fPtr_ps[i+iStep_ps*j] = (flag_ps1*temp_ps+1.0f-flag_ps1)/(flag_ps2*temp_s+1.0f-flag_ps2);
if ((flag_ps2*temp_s+1.0f-flag_ps2)==0){
printf("Something wrong in last: temp_s = %f, flag_ps2 = %f\n", temp_s, flag_ps2);
exit(0);
}
}
}
cvMul(ps, src_dx, dps_x);
cvMul(ps, src_dy, dps_y);
cvSub(dps_x, src_dx, dps_x);
cvSub(dps_y, src_dy, dps_y);
cvCurvature(dps_x, dps_y, dst);
cvLaplace(src,del,1);
cvMul(del, ones, del, 0.2f);
cvAdd(dst, del, dst);
cvReleaseMat(&src_dx);
cvReleaseMat(&src_dy);
cvReleaseMat(&s);
cvReleaseMat(&ps);
cvReleaseMat(&dps_x);
cvReleaseMat(&dps_y);
cvReleaseMat(&del);
cvReleaseMat(&ones);
__END__;
}
CvScalar GetSharpness(IplImage* in, IplImage* drawHist=0)
{
const short history_size = 5;
static short history_index = 0;
static short history[5];
static IplImage* data = 0;
static IplImage* out = 0;
static IplImage* out_8bit = 0;
if( ! out ) {
out=cvCreateImage(cvSize(in->roi->width,in->roi->height),IPL_DEPTH_16S,1);
out_8bit=cvCreateImage(cvSize(in->roi->width,in->roi->height),IPL_DEPTH_8U,1);
}
// aperture size of 1 corresponds to the correct matrix
cvLaplace(in, out, 1);
short maxLap = -32767;
short* imgData = (short*)out->imageData;
int i=0;
double avg=0.0;
for(i=0;i<(out->imageSize/2);i++)
{
if(abs(imgData[i]) > maxLap) maxLap = abs(imgData[i]);
avg += abs(imgData[i]);
}
avg /= out->imageSize;
history[history_index++] = maxLap;
history_index = (history_index + 1) % history_size;
float mean = 0.0;
for(i=0;i<history_size;i++) {
mean+=history[i];
}
mean /= history_size;
if(drawHist) {
cvConvertScale(out,out_8bit);
CvHistogram* hist;
int hist_size[] = { 256 };
float ranges_1[] = { 0, 256 };
float* ranges[] = { ranges_1 };
hist = cvCreateHist( 1, hist_size, CV_HIST_ARRAY, ranges, 1 );
cvCalcHist( &out_8bit, hist, 0, 0 ); // Compute histogram
cvNormalizeHist( hist, 20*255 ); // Normalize it
// populate the visualization
float max_value = 0;
cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );
for( int s = 0; s < 256; s++ ){
float bin_val = cvQueryHistValue_1D( hist, s );
if(bin_val>0.0) {
cvRectangle( drawHist, cvPoint( s, 100 ),
cvPoint( s, 100- (bin_val/max_value*100)),
CV_RGB( 0, 255, 0 ),
CV_FILLED );
}
}
cvReleaseHist(&hist);
}
CvScalar r;
r.val[0] = mean;
r.val[1] = avg;
return r;
}
void Evolution(IplImage *u, IplImage *g, double lambda, double mu, double alf, double epsilon, double delt, int numIter)
{
if (!u||!g)
return;
CvSize size = cvGetSize(u);
IplImage* vx = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* vy = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* ux = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* uy = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* Nx = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* Ny = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* diracU = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* K = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* laplace = cvCreateImage(size,IPL_DEPTH_32F,1);
Sobel(g, vx, vy);
int i,j;
CvScalar cur1,cur2,cur11,cur22,cur;
CvScalar Cdirac, Cvx, CNx, Cvy, CNy, Cg, CK, Claplace, Cu;
for (int k=0;k<numIter;k++)
{
cout<<k<<"……"<<endl;
NeumannBoundCond(u);
Sobel(u, ux, uy);
for (i=0; i<size.height; i++)
{
for(j=0; j<size.width; j++)
{
cur1 = cvGet2D(ux,i,j);
cur2 = cvGet2D(uy,i,j);
cur11.val[0] = cur1.val[0]/sqrt(cur1.val[0]*cur1.val[0] + cur2.val[0]*cur2.val[0] + 1e-10);
cur22.val[0] = cur2.val[0]/sqrt(cur1.val[0]*cur1.val[0] + cur2.val[0]*cur2.val[0] + 1e-10);
cvSet2D(Nx,i,j,cur11);
cvSet2D(Ny,i,j,cur22);
}
}
Dirac(u,diracU,epsilon);
CurvatureCentral2(Nx,Ny,K);
cvLaplace(u, laplace, 1);
for (i=0; i<size.height; i++)
{
for(j=0; j<size.width; j++)
{
Cdirac = cvGet2D(diracU,i,j);
Cvx = cvGet2D(vx,i,j);
CNx = cvGet2D(Nx,i,j);
Cvy = cvGet2D(vy,i,j);
CNy = cvGet2D(Ny,i,j);
Cg = cvGet2D(g,i,j);
CK = cvGet2D(K,i,j);
Claplace = cvGet2D(laplace,i,j);
Cu = cvGet2D(u,i,j);
cur.val[0] = lambda*Cdirac.val[0]*(Cvx.val[0]*CNx.val[0] + Cvy.val[0]*CNy.val[0] + Cg.val[0]*CK.val[0])
+ mu*(Claplace.val[0]-CK.val[0]) + alf*Cdirac.val[0]*Cg.val[0];
Cu.val[0] += delt*cur.val[0];
cvSet2D(u,i,j,Cu);
}
}
}
cvReleaseImage(&vx);
cvReleaseImage(&vy);
cvReleaseImage(&ux);
cvReleaseImage(&uy);
cvReleaseImage(&Nx);
cvReleaseImage(&Ny);
cvReleaseImage(&diracU);
cvReleaseImage(&K);
cvReleaseImage(&laplace);
}
void Evolution2(IplImage * u, IplImage *g, double lambda, double mu, double alf, double epsilon, double delt, int numIter)
{
if (!u||!g)
return;
CvSize size = cvGetSize(u);
IplImage* vx = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* vy = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* ux = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* uy = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* Nx = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* Ny = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* diracU = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* K = cvCreateImage(size,IPL_DEPTH_32F,1);
IplImage* Laplace = cvCreateImage(size,IPL_DEPTH_32F,1);
Sobel(g,vx,vy);
CvScalar s1,s2,s11,s22;
CvScalar Cdirac, Cvx, Cvy, CNx, CNy, Cg, CK, CLaplace, Cu;
int i,j;
for(int k=0;k<numIter;k++)
{
cout<<k<<"……"<<endl;
NeumannBoundCond(u);
Sobel(u,ux,uy);
for(i=0;i<size.height;i++)
{
for(j=0;j<size.width;j++)
{
s1=cvGet2D(ux,i,j);
s2=cvGet2D(uy,i,j);
double normDu=sqrt(pow(s1.val[0],2)+pow(s2.val[0],2)+1e-10);
s11.val[0]=s1.val[0]/normDu;
s22.val[0]=s2.val[0]/normDu;
cvSet2D(Nx,i,j,s11);
cvSet2D(Ny,i,j,s22);
}
}
Dirac(u,diracU,epsilon);
CurvatureCentral2(Nx,Ny,K);
cvLaplace(u, Laplace, 1);
for(i=0;i<size.height;i++)
{
for(j=0;j<size.width;j++)
{
Cdirac=cvGet2D(diracU,i,j);
Cvx=cvGet2D(vx,i,j);
Cvy=cvGet2D(vy,i,j);
CNx=cvGet2D(Nx,i,j);
CNy=cvGet2D(Ny,i,j);
Cg=cvGet2D(g,i,j);
CK=cvGet2D(K,i,j);
CLaplace=cvGet2D(Laplace,i,j);
Cu=cvGet2D(u,i,j);
double weightedLengthTerm=lambda*Cdirac.val[0]*(Cvx.val[0]*CNx.val[0]+Cvy.val[0]*CNy.val[0]+Cg.val[0]*CK.val[0]);
double weightedAreaTerm=alf*Cdirac.val[0]*Cg.val[0];
double penalizingTerm=mu*(CLaplace.val[0]-CK.val[0]);
double total=weightedLengthTerm+weightedAreaTerm+penalizingTerm;
Cu.val[0]+=delt*total;
cvSet2D(u,i,j,Cu);
}
}
}
cvReleaseImage(&vx);
cvReleaseImage(&vy);
cvReleaseImage(&ux);
cvReleaseImage(&uy);
cvReleaseImage(&Nx);
cvReleaseImage(&Ny);
cvReleaseImage(&diracU);
cvReleaseImage(&K);
cvReleaseImage(&Laplace);
}
