Unnamed

// Cristóbal Carnero Liñán <grendel.ccl@gmail.com>

// g++ `pkg-config opencv cvblob --cflags --libs` testblobs2.cpp -o testblobs2

#include <iostream>
#include <iomanip>

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


#include <cvblob.h>
using namespace cvb;

IplImage* update_brightcont(IplImage *src_image);

int main()
{
  CvTracks tracks;
  
  IplImage *imgDx;
  IplImage *imgSx;
  IplImage* imgGreyDx;
  IplImage* imgGreySx;
  IplImage* tempDx;
  IplImage* tempSx;
  
  int blobs = 0;
  
  CvSize imSize;

  cvNamedWindow("camera1", CV_WINDOW_AUTOSIZE);
  cvNamedWindow("camera2", CV_WINDOW_AUTOSIZE);

  CvCapture *captureDx = cvCaptureFromCAM(0);
  CvCapture *captureSx = cvCaptureFromCAM(1);
  
  //cvGrabFrame(capturedx);
  //IplImage *imgdx = cvRetrieveFrame(capturedx);

  //cvGrabFrame(capturesx);
  //IplImage *imgsx = cvRetrieveFrame(capturesx);

  //CvSize imgSizedx = cvGetSize(imgdx);
  //CvSize imgSizesx = cvGetSize(imgsx);

  //IplImage *frame = cvCreateImage(imgSize, img->depth, img->nChannels);
  //IplImage *frame = cvCreateImage(imgSize, 8, 1);

  //IplConvKernel* morphKernel = cvCreateStructuringElementEx(5, 5, 1, 1, CV_SHAPE_RECT, NULL);

  //unsigned int frameNumber = 0;
  unsigned int blobNumber = 0;

  bool quit = false;
  while (!quit)
  {
    cvGrabFrame(captureDx);
    cvGrabFrame(captureSx);
    imgDx = cvRetrieveFrame(captureDx);
    imgSx = cvRetrieveFrame(captureSx);

	imSize = cvGetSize(imgDx);
    IplImage* imgGreyDx = cvCreateImage(imSize, 8, 1);
    IplImage* imgGreySx = cvCreateImage(imSize, 8, 1);
    cvCvtColor(imgDx, imgGreyDx, CV_RGB2GRAY);
    cvCvtColor(imgSx, imgGreySx, CV_RGB2GRAY);

    //cvConvertScale(imgdx, frame, 1, 0);
    //cvConvertScale(imgsx, frame, 1, 0);

    //IplImage *segmentated = cvCreateImage(imgSize, 8, 1);

    CvBlobs blobsDx;
    CvBlobs blobsSx;
    
    tempDx = cvCreateImage(imSize, 8, 1);
    tempDx = cvCloneImage(update_brightcont(imgGreyDx));
    tempSx = cvCreateImage(imSize, 8, 1);
    tempSx = cvCloneImage(update_brightcont(imgGreySx));
    
    cvThreshold(imgGreyDx, imgGreyDx, 100, 255, CV_THRESH_BINARY);
    cvThreshold(imgGreySx, imgGreySx, 100, 255, CV_THRESH_BINARY);
    
    IplImage* labelImgDx = cvCreateImage(imSize, IPL_DEPTH_LABEL, 1);
    IplImage* labelImgSx = cvCreateImage(imSize, IPL_DEPTH_LABEL, 1);
    
    cvLabel(tempDx, labelImgDx, blobsDx);
    cvLabel(tempSx, labelImgSx, blobsSx);
    
    IplImage *imgOutDx = cvCreateImage(imSize, IPL_DEPTH_8U, 3);
    IplImage *imgOutSx = cvCreateImage(imSize, IPL_DEPTH_8U, 3);  
    cvZero(imgOutDx);
    cvZero(imgOutSx);
    
	cvRenderBlobs(labelImgDx, blobsDx, imgDx, imgOutDx);
	cvRenderBlobs(labelImgSx, blobsSx, imgSx, imgOutSx);
    
    //cvCreateBlobs(blobsdx);
    //cvCreateBlobs(blobssx);
    
        
    if (blobs)
    {
		cvShowImage("camera1", imgOutDx);
    	cvShowImage("camera2", imgOutSx);
    }
    else
    {
    	cvShowImage("camera1", imgDx);
    	cvShowImage("camera2", imgSx);

    }
    
   
    //cvReleaseImage(&labelImg);
    //cvReleaseImage(&segmentated);

    char k = cvWaitKey(10)&0xff;
    switch (k)
    {
      case 27:
      case 'q':
      case 'Q':
        quit = true;
        break;
        
      case 'b':
      	blobs = 1-blobs;
      	break;
      	
/*      case 's':
      case 'S':
        for (CvBlobs::const_iterator it=blobs.begin(); it!=blobs.end(); ++it)
        {
          std::stringstream filename;
          filename << "redobject_blob_" << std::setw(5) << std::setfill('0') << blobNumber << ".png";
          cvSaveImageBlob(filename.str().c_str(), img, it->second);
          blobNumber++;

          std::cout << filename.str() << " saved!" << std::endl;
        }
        break; */
    }

    cvReleaseBlobs(blobsDx);
    cvReleaseBlobs(blobsSx);

    //frameNumber++;
  }

  cvReleaseImage(&imgDx);
  cvReleaseImage(&imgSx);
  cvReleaseImage(&imgGreyDx);
  cvReleaseImage(&imgGreySx);
  cvReleaseImage(&tempDx);
  cvReleaseImage(&tempSx);
  
  cvDestroyWindow("camera1");
  cvDestroyWindow("camera2");

  return 0;
}




IplImage* update_brightcont(IplImage *src_image) {
    int hist_size = 64;
    float range_0[] = {0, 256};
    float* ranges[] = {range_0};
    uchar lut[256];
    CvMat* lut_mat;
    CvHistogram *hist;
    IplImage* dst_image = 0, *imgs = 0; //*hist_image = 0;
    int brightness = -100;
    int contrast = 100;
    int i;
    float max_value = 0;

    //    printf("Per un valore _brightness %d abbiamo un valore brightness %d\n", _brightness, brightness);
    //    printf("Per un valore _contrast %d abbiamo un valore contrast %d\n", _contrast, contrast);

    dst_image = cvCloneImage(src_image);
    //hist_image = cvCreateImage(cvGetSize(src_image), 8, 1);
    hist = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
    lut_mat = cvCreateMatHeader(1, 256, CV_8UC1);
    cvSetData(lut_mat, lut, 0);

    if (contrast > 0) {
        double delta = 127. * contrast / 100;
        double a = 255. / (255. - delta * 2);
        double b = a * (brightness - delta);
        for (i = 0; i < 256; i++) {
            int v = cvRound(a * i + b);
            if (v < 0)
                v = 0;
            if (v > 255)
                v = 255;
            lut[i] = (uchar) v;
        }
    } else {
        double delta = -128. * contrast / 100;
        double a = (256. - delta * 2) / 255.;
        double b = a * brightness + delta;
        for (i = 0; i < 256; i++) {
            int v = cvRound(a * i + b);
            if (v < 0)
                v = 0;
            if (v > 255)
                v = 255;
            lut[i] = (uchar) v;
        }
    }

    cvLUT(src_image, dst_image, lut_mat);
    //cvShowImage( "image", dst_image );
    imgs = cvCreateImage(cvGetSize(dst_image), 8, 1);
    imgs = cvCloneImage(dst_image);
    //cvSmooth(dst_image, imgs, CV_MEDIAN, 9, 0, 0, 0);
    //cvThreshold(imgs, imgs, 250.0, 0.0, CV_THRESH_TOZERO);
    //cvShowImage("1", imgs);
    //cvSaveImage("c:/senzaFiltroSW.jpg",imgs);
    //cvSaveImage("c:/senzaFiltroSW1.jpg",imgs);

    cvCalcHist(&dst_image, hist, 0, NULL);
    cvZero(dst_image);
    cvGetMinMaxHistValue(hist, 0, &max_value, 0, 0);
    //    cvScale(hist->bins, hist->bins, ((double) hist_image->height) / max_value, 0);
    //cvNormalizeHist( hist, 1000 );

    //cvSet(hist_image, cvScalarAll(255), 0);
    //bin_w = cvRound((double) hist_image->width / hist_size);

    //    for (i = 0; i < hist_size; i++)
    //        cvRectangle(hist_image, cvPoint(i * bin_w, hist_image->height),
    //            cvPoint((i + 1) * bin_w, hist_image->height - cvRound(cvGetReal1D(hist->bins, i))),
    //            cvScalarAll(0), -1, 8, 0);

    //cvShowImage( "histogram", hist_image );
    return imgs;
}