int main(int argc, char** argv)
{
  // parse command line ----------------------------------------------
  po::options_description general_opt("Allowed options are: ");
  general_opt.add_options()
    ("help,h", "display this message")
    ("input,i", po::value<std::string>(), "input image file name (any 2D image format accepted by DGtal::GenericReader)")
    ("output,o", po::value<std::string>(), "output image file name (any 2D image format accepted by DGtal::GenericWriter)")
    ("angle,a", po::value<double>()->default_value(0.0), "Angle in radian")  ;
  
  bool parseOK=true;
  po::variables_map vm;
  try{
    po::store(po::parse_command_line(argc, argv, general_opt), vm);  
  }catch(const std::exception& ex){
    trace.info()<< "Error checking program options: "<< ex.what()<< std::endl;
    parseOK=false;
  }
  po::notify(vm);    
  if(vm.count("help")||argc<=1|| !parseOK)
    {
      trace.info()<< "Rotate an image by a given angle a binary object with 0 values as background points and values >0 for the foreground ones." <<std::endl << "Basic usage: "<<std::endl
      << "\t imgRotate [options] --input <imageName> --output <outputImage> --angle 0.3"<<std::endl
      << general_opt << "\n";
      return 0;
    }
  
  //Parameters
  if ( ! ( vm.count ( "input" ) ) ) missingParam ( "--input" );
  const std::string input = vm["input"].as<std::string>();
  if ( ! ( vm.count ( "output" ) ) ) missingParam ( "--output" );
  const std::string  output = vm["output"].as<std::string>();
  const double angle = vm["angle"].as<double>();
  
  typedef functors::IntervalForegroundPredicate<MyImage> Binarizer;
  MyImage image = GenericReader<MyImage>::import( input );
  trace.info() <<"Input image: "<< image<<std::endl;
  
  typedef functors::BackwardRigidTransformation2D<Z2i::Space> RotateFunctor;
  Z2i::RealPoint center = image.domain().upperBound();
  center -= image.domain().lowerBound();
  center /= 2.0;
  
  RotateFunctor rotationFunctor(center,
                                angle,
                                Z2i::RealPoint(0.0,0.0));
  
  functors::Identity idD;
  typedef functors::DomainRigidTransformation2D<MyImage::Domain, RotateFunctor> MyDomainTransformer;
  MyDomainTransformer rotDomain(rotationFunctor);
  typedef MyDomainTransformer::Bounds Bounds;
  Bounds newdomain = rotDomain( image.domain());
  MyImage::Domain transformedDomain ( newdomain.first, newdomain.second );
  typedef ConstImageAdapter<MyImage, MyImage::Domain, RotateFunctor, MyImage::Value, functors::Identity > MyImageBackwardAdapter;
  MyImageBackwardAdapter backwardImageAdapter ( image, transformedDomain , rotationFunctor, idD );
  
  backwardImageAdapter >> output;
  
  return 0;
}

MyImage ReverseProcessor::preProcessImage(const MyImage& image) const
{
  QImage *resultImage = ImageAlgorithm::reverse(image.getImage());
  MyImage result(*resultImage, image.getType());
  delete resultImage;
  return result;
}

int main(int, char**){

    MyImage image;
    
    //Set up parameters for the triangl

    vec2 v0(100, 100);
    vec2 v1(200, 300);
    vec2 v2(400, 50);

    float TotalArea = triangleArea(v0, v1, v2);
    //rasterize the triangle   
    for (int row = 0; row < image.rows; ++row) {
        for (int col = 0; col < image.cols; ++col) {
            vec2 pt(col, row);

            /// Calculate the barycentric coordinates using the triangle area

       }
    }

   
    image.show();
    // image.save("output.png"); ///< Does not work on Windows!

    return EXIT_SUCCESS;
}

bool testImageCopyShort()
{
  unsigned int nbok = 0;
  unsigned int nb = 0;

  trace.beginBlock ( "Testing smart copy of Image..." );
  typedef ImageContainerBySTLVector<Z2i::Domain, int> VImage;
  typedef Image<VImage > MyImage;
  BOOST_CONCEPT_ASSERT(( CImage< MyImage > ));

  Z2i::Point a(0,0);
  Z2i::Point b(32,32);
  Z2i::Point c(12, 14);

  Z2i::Domain domain(a,b);

  MyImage image(  new VImage(domain) );
  trace.info() << "Image constructed: "<< image <<std::endl;

  VImage myImageC( domain );
  MyImage imageFromConstRef ( myImageC );
  trace.info() << "Image constructed (from constRef): "<< imageFromConstRef <<std::endl;
  nbok += (imageFromConstRef.getPointer().count()== 2) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "unique" << std::endl;

  MyImage image3;
  trace.info() << "Image constructed (degulat): "<< image3 <<std::endl;


  trace.info() <<  "default: "<< image3 <<std::endl;
  image3 = image;
  nbok += (image3.getPointer().count()== 3) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "true == true" << std::endl;
  trace.info() <<  "assignment: "<< image3 <<std::endl;
  nbok += (image3.getPointer().count()== 3) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
        << "true == true" << std::endl;

  image3.setValue(Z2i::Point(1,1), 4);
  trace.info() <<  "setValue on assigned: "<< image3 <<std::endl;
  nbok += (image3.getPointer().count()== 2) ? 1 : 0;
  nb++;

  MyImage image4(image3);
  trace.info() << "Image constructed (copy): "<< image4 <<std::endl;
  nbok += (image4.getPointer().count()== 3) ? 1 : 0;
  nb++;


  trace.info() << "(" << nbok << "/" << nb << ") "
         << "true == true" << std::endl;

  return nbok == nb;
}

int diff_pic(unsigned char *logo_img_sample, int pyr_i, const MyImage &img_pic, int start_r, int start_c, int end_r, int end_c)
{
	unsigned char *Ybuf_pic = img_pic.getYbuf();
	int block_unit = 8;
	int block_len = pyr_i * BLOCK_SIZE;

	int error = 0;
	for(int i = start_r; i < end_r; i += block_unit) {
		for(int j = start_c; j < end_c; j += block_unit) {
	
			int min_mse = (1 << 31) - 1;
			for(int row = 0; row < block_len; row += block_unit) {
				for(int col = 0; col < block_len; col += block_unit) {

					int block_err = 0;
					for(int blc_i = 0; blc_i < block_unit; blc_i++) {
						for(int blc_j = 0; blc_j < block_unit; blc_j++) {
							int diff = logo_img_sample[(row + blc_i) * block_len + col + blc_j] - Ybuf_pic[(i + blc_i) * img_pic.getWidth() + j + blc_j];
							block_err += diff * diff;
						}
					}
					if(block_err < min_mse) min_mse = block_err;
				}
			}
			error += min_mse;
		}
	}
	return error / (block_len / 8) / (block_len / 8);
}

MyImage HistogramEqualizationProcessor::preProcessImage(const MyImage& image) const
{
  QImage *resultImage = processImage(image.getImage());
  MyImage result(*resultImage, MyImage::Gray);
  delete resultImage;
  return result;
}

MyImage ToGrayProcessor::preProcessImage(const MyImage& image) const
{
  QImage *resultImage = ImageAlgorithm::convertToGrayScale(image.getImage(),
                                                           _type);
  MyImage result(*resultImage, MyImage::Gray);
  delete resultImage;
  return result;
}

MyImage* MyImage::LoadImage(string path) {
    GLuint texture;
    unsigned char *data;
    int width, height;

    MyImage *image = new MyImage();

    string ext;
    ext = path.substr( path.find_last_of('.') );
    
    if( ext.compare("tga") == 0 ) {
        if( ! image->InitWithFileTGA(path) ) {
            delete image;
            return NULL;
        }
        
        return image;
    }
    else if( ext.compare("png") == 0 ) {
        // not supported
        delete image;
        return NULL;
    }

    
    // else formats ...
    texture = SOIL_load_OGL_texture(path.c_str(),
                                    SOIL_LOAD_AUTO,
                                    SOIL_CREATE_NEW_ID,
                                    SOIL_FLAG_INVERT_Y,
                                    &data,
                                    &width,
                                    &height);
    if( texture == 0 ) {
        return NULL;
    }
    
    image = new MyImage( texture, data, width, height );
    return image;
}

MyImage MyImage::over(MyImage& image, int posx, int posy){
	MyImage newImage(image.to4ChannelsImage());

	for(int y = 0; y< height && (y+posy)< newImage.height ; y++){
		for(int x = 0; x< width && (x+posx< newImage.width ); x++){
			for(int c = 0; c< 3; c++){
				newImage.data[c + (x+posx) *4 + (y+posy)*newImage.width*4]=
				newImage.data[c + (x+posx) *4 + (y+posy)*newImage.width*4] * (255-data[3+x*4+y*width*4])/255+data[c+ x*4 + y*width*4]*(data[3+x*4+y*width*4])/255;
				 
			}
		
		}
	}
	return newImage;

}

bool compareImage_basic(const MyImage &img_logo, const MyImage &img_pic)
{
	int *his_logo = getHistogram_H(img_logo, 0, 0, img_logo.getHeight(), img_logo.getWidth());
	int *his_pic = getHistogram_H(img_pic, 0, 0, img_pic.getHeight(), img_pic.getWidth());
	print_arr(his_logo, H_N);
    print_arr(his_pic, H_N);
    int total_pixel = img_logo.getWidth() * img_logo.getHeight();
	retainMajority(his_logo, 0.9, H_N);
	TRACE("After retaining majority\n");
	print_arr(his_logo, H_N);
	filter(his_logo, his_pic, H_N);
	TRACE("After filtering\n");
	print_arr(his_pic, H_N);
	double *norm_his_logo = normalize(his_logo, H_N);
	double *norm_his_pic = normalize(his_pic, H_N);
	double diff = differ(norm_his_logo, norm_his_pic, H_N);
    TRACE("ecu diff: %lf\n", diff);
    delete his_logo;
    delete his_pic;
    delete norm_his_logo;
    delete norm_his_pic;

	return diff <= THRESHOLD;
}

ToBlackAndWhiteDialog::ToBlackAndWhiteDialog(const MyImage& image,
                                             const Area& area,
                                             QWidget *parent) :
    QDialog(parent),
    ui(new Ui::ToBlackAndWhiteDialog),
    _area(area)
{
  ui->setupUi(this);

  _image = image.getImage();

  changing = false;
  single = true;
  black = true;
  singleThreshold = 0;

  thresholdItem = new ThresholdItem();
  plot = new BasicStatisticPlot(
      ImageAlgorithm::getStatistic(image.getImage(), ImageAlgorithm::Green));
  ui->widget_2->layout()->addWidget(plot);
  plot->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
  thresholdItem->attach(plot);
  QVector<int> thresholds;
  thresholds.push_back(0);
  thresholdItem->setThresholds(thresholds);
  connect(thresholdItem,
          SIGNAL(thresholdChanged(QVector<int>)),
          this,
          SLOT(multipleChanged(QVector<int>)));
  xPlotPicker = new XPlotPicker(QwtPlot::xBottom,
                                QwtPlot::yLeft,
                                QwtPlotPicker::VLineRubberBand,
                                QwtPicker::AlwaysOn,
                                plot->canvas());
  xPlotPicker->setRubberBandPen(QColor(0, 0, 255, 160));
  xPlotPicker->setTrackerPen(QColor(0, 0, 255, 160));
  xPlotPicker->setEnabled(true);
  connect(xPlotPicker, SIGNAL(pressAt(int)), this, SLOT(singleChanged(int)));
  connect(ui->thresholdSpinBox,
          SIGNAL(valueChanged(int)),
          this,
          SLOT(singleChanged(int)));
  marker = new QwtPlotMarker();
  marker->setValue(0.0, 0.0);
  marker->setLineStyle(QwtPlotMarker::VLine);
  marker->setLabelAlignment(Qt::AlignRight | Qt::AlignBottom);
  marker->setLinePen(QPen(Qt::green, 0, Qt::DashDotLine));
  marker->attach(plot);

  connect(ui->thresholdsEdit,
          SIGNAL(textEdited(QString)),
          this,
          SLOT(multipleTextChanged(QString)));
  connect(ui->blackButton,
          SIGNAL(toggled(bool)),
          this,
          SLOT(startWithBlack(bool)));
  connect(ui->whiteButton,
          SIGNAL(toggled(bool)),
          this,
          SLOT(startWithWhite(bool)));
  resetPreview();
}

/** @function main */
int main( int argc, char** argv )
{
    //300 350
    
    double probability = 0.6;

    std::vector<string> sourceVector = saveFileName(argv[1]);
    std::vector<string> searchVector = saveFileName(argv[2]);

    
    double matched = 0;
    
    for(std::vector<string>::iterator sourceIterator = sourceVector.begin(); sourceIterator != sourceVector.end(); sourceIterator++ ){
        for(std::vector<string>::iterator searchIterator = searchVector.begin(); searchIterator != searchVector.end(); searchIterator++ ){
            if (*sourceIterator == *searchIterator) {
                matched++;
                break;
            }
            
            
        }
    }

    probability *= (matched / sourceVector.size());
    
    
    
    MyImage *image = new MyImage();
    image->setWidth(352);
    image->setHeight(288);
    image->setImagePath(argv[1]);

    if(!image->ReadImage()){
        std::cout << "Error reading MyImage" << std::endl;
    }

    printf("%s", argv[1]);
    
    
   FILE *f = fopen(argv[1], "rb");
    if (!f) {
        printf("error\n");
        exit(1);
    }
    unsigned char pixels[352 * 288 * 3];
    fread(pixels, sizeof(unsigned char), 352*288 * 3, f);
    fclose(f);
    cv::Mat object(Size(352, 288), CV_8UC3, pixels);
    
    namedWindow("image", CV_WINDOW_AUTOSIZE);
    imshow("image", object);
    
    if( !object.data )
    {
        std::cout<< "Error reading object " << std::endl;
        return -1;
    }
    
    cv::Mat tmp, alpha;
    threshold(object, object, 255, 0, THRESH_TOZERO_INV);

    cv::Rect myROI(100, 100, 150, 150);
    
    
    int minHessian = 1000;
    
    cv::SurfFeatureDetector detector( minHessian );
    std::vector<cv::KeyPoint> kp_object;
    detector.upright = false;
    detector.detect( object, kp_object );
    
    cv::SurfDescriptorExtractor extractor;
    cv::Mat des_object;
    
    extractor.compute( object, kp_object, des_object );
    
    cv::FlannBasedMatcher matcher;
    
    
    cv::namedWindow("Good Matches");
    
    std::vector<cv::Point2f> obj_corners(4);
    
    //Get the corners from the object
    obj_corners[0] = cvPoint(0,0);
    obj_corners[1] = cvPoint( object.cols, 0 );
    obj_corners[2] = cvPoint( object.cols, object.rows );
    obj_corners[3] = cvPoint( 0, object.rows );
    
    char key = 'a';
    int framecount = 0;
    while (key != 27)
    {
       
        
        if (framecount < 5)
        {
            framecount++;
            continue;
//.........这里部分代码省略.........

bool compareImage_v2(MyImage &img_logo, MyImage &img_pic)
{
	int row_n = img_pic.getHeight() / BLOCK_SIZE;
	int col_n = img_pic.getWidth() / BLOCK_SIZE;
	
	int *his_logo = getHistogram(img_logo, 0, 0, img_logo.getHeight(), img_logo.getWidth());
	//int *his_logo = getHistogram_H(img_logo, 0, 0, img_logo.getHeight(), img_logo.getWidth());
	//int *his_pic = getHistogram_H(img_pic, 0, 0, img_pic.getHeight(), img_pic.getWidth());
	
	//print_arr(his_logo, histo_size);
	//print_arr(his_logo, histo_size_h);
	//delete his_pic;
	double *norm_logo = normalize(his_logo, histo_size);
	//double *norm_logo = normalize(his_logo, histo_size_h);
	//print_arr_d(norm_logo, histo_size);
	//print_arr_d(norm_logo, histo_size_h);
	int **block_histos = new int*[row_n * col_n];

	int total_blc = 0;
	for(int i = 0; i < img_pic.getHeight(); i += BLOCK_SIZE) {
		for(int j = 0; j < img_pic.getWidth(); j += BLOCK_SIZE) {
			//TRACE("i: %d, j: %d\n", i, j);
			block_histos[total_blc++] = getHistogram(img_pic, i, j, i + BLOCK_SIZE, j + BLOCK_SIZE);
		//	print_arr(block_histos[total_blc - 1], H_N);
		}
	}

	int window_size = min(row_n, col_n);
	//double min_diff = 1000.0;
	//int min_x = -1, min_y = -1, min_size = -1;
	std::priority_queue<Box, std::vector<Box>, CompareBox> best_boxes;
	int max_heap_size = 5;
	while(window_size > 0) {
		for(int row = 0; row <= row_n - window_size; row++) {
			for(int col = 0; col <= col_n - window_size; col++) {
				
				int *local_histo = new int[histo_size];
				//int *local_histo = new int[histo_size_h];
				for(int x = 0; x < histo_size; x++) local_histo[x] = 0;
				//for(int x = 0; x < histo_size_h; x++) local_histo[x] = 0;
				for(int x = row; x < row + window_size; x++) {
					for(int y = col; y < col + window_size; y++) {
						int block_index = x * col_n + y;
						for(int z = 0; z < histo_size; z++)
						//for(int z = 0; z < histo_size_h; z++)
							local_histo[z] += block_histos[block_index][z];
					}
				}
				
				double *norm_local = normalize(local_histo, histo_size);
				//double *norm_local = normalize(local_histo, histo_size_h);
				//print_arr_d(norm_local, H_N);
				//print_arr_d(norm_logo, H_N);
				double diff = differ(norm_local, norm_logo, histo_size);
				//double diff = differ(norm_local, norm_logo, histo_size_h);
				//TRACE("row: %d, col: %d, size: %d, diff: %lf\n", row, col, window_size, diff);
				/*
				if(row == 3 && col == 6 && window_size == 2) {
					print_arr_d(norm_local, histo_size);
					TRACE("diff: %lf\n", diff);
				}
				*/
				if(best_boxes.size() == max_heap_size && best_boxes.top().diff > diff) {
					delete best_boxes.top().histogram;
					best_boxes.pop();
				}
				if(best_boxes.size() < max_heap_size) {
					Box new_box = {row, col, window_size, diff, local_histo};
					//TRACE("r: %d, c: %d, size: %d, diff: %lf\n", new_box.row, new_box.col, new_box.len, new_box.diff);
					best_boxes.push(new_box);
				}
				else
					delete local_histo;
				delete norm_local;
			}
		}
		window_size--;
	}
	//TRACE("row: %d, col: %d, size: %d, diff: %lf\n", min_y, min_x, min_size, min_diff);
	//int length = min_size * BLOCK_SIZE;
	img_pic.RGBtoGray();
	img_logo.RGBtoGray();
	unsigned char **pyramid = create_img_pyr(img_logo, 0);
	

	int min_err = (1 << 31) - 1;
	double min_diff = 10.0;
	//printf("here\n");
	while(!best_boxes.empty()) {
		Box best_box = best_boxes.top();
		TRACE("row: %d, col: %d, size: %d, diff: %lf\n", best_box.row, best_box.col, best_box.len, best_box.diff);
		//printf("row: %d, col: %d, size: %d, diff: %lf\n", best_box.row, best_box.col, best_box.len, best_box.diff);
		//print_arr(best_box.histogram, histo_size);
		//print_arr(best_box.histogram, histo_size_h);
		img_pic.DrawBox(best_box.row * BLOCK_SIZE, best_box.col * BLOCK_SIZE, (best_box.row  + best_box.len)* BLOCK_SIZE, (best_box.col + best_box.len) * BLOCK_SIZE);
		best_boxes.pop();
		if(best_boxes.empty())
		    min_err = diff_pic(pyramid[best_box.len - 1], best_box.len, img_pic, best_box.row * BLOCK_SIZE, best_box.col * BLOCK_SIZE, (best_box.row  + best_box.len)* BLOCK_SIZE, (best_box.col + best_box.len) * BLOCK_SIZE);
		//TRACE("cur_err: %d\n", cur_err);
		//printf("cur_err: %d\n", cur_err);
//.........这里部分代码省略.........

//callback in glut loop
void display(void)
{
	std::cout << imageToBeOutput.getWidth() << " " << imageToBeOutput.getHeight() << " " << imageToBeOutput.getChannels()<<std::endl;

	glClear(GL_COLOR_BUFFER_BIT);
	glDrawPixels(imageToBeOutput.getWidth(), imageToBeOutput.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, display_data);
	glFlush();
}

//keyboard handle function to implement image manipulation
void handleKey(unsigned char key, int x, int y){
  switch(key){


//use key 'w' or 'W' to write image
      case 'w':	
      case 'W':
      if (writename != NULL)
      {
          Image.ImageWrite(writename);

      }

      //if the second parameter is not specified in command line, output the message 'cannot write the image'
      else{
          std::cout << "You cannot write the image because you didn't specify a filename." << std::endl;
      }
      break;

//use key 'q' or 'Q' to quit the program      
    case 'q':		// q - quit
    case 'Q':
    case 27:		// esc - quit
      exit(0);
      
    default:		// not a valid key -- just ignore it
      return;
  }
}

void sendDecodeSequentialMode(void* storage){
	TwoByte* st = (TwoByte*) storage;

	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
										
	Byte* imgd = workingImage.getImageData();
	
	unsigned int q = 1<<quantizationLevel;

	TwoByte* tblock = new TwoByte[192];
	Byte* idctblock = new Byte[192];

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y + yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = st[src]*q;
					tblock[dest + 1] = st[src + 1]*q;  
					tblock[dest + 2] = st[src + 2]*q;  
				}
			}

			doIDCT(tblock, idctblock);
			
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y + yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;
					imgd[dest]  = idctblock[src];					
					imgd[dest + 1] = idctblock[src + 1];					
					imgd[dest + 2] = idctblock[src + 2];  					
				}
			}
			drawImage(&workingImage, nextStart);
			Sleep(latency);
		}
	}
		
	delete[] tblock;
	delete[] idctblock;
	MessageBox(NULL, "DECODING DONE", "Status", NULL);
}

void decodeProgressiveModeSpectralSelection(TwoByte* st){
	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
										
	Byte* imgd = workingImage.getImageData();
	
	unsigned int q = 1<<quantizationLevel;

	TwoByte* tblock = new TwoByte[192];
	Byte* idctblock = new Byte[192];

	memset(tblock, 0x00, sizeof(TwoByte)*192);
	memset(idctblock, 0x00, sizeof(Byte)*192);

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y + yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = st[src]*q;
					tblock[dest + 1] = st[src + 1]*q;  
					tblock[dest + 2] = st[src + 2]*q;  
				}
			}

			doIDCT(tblock, idctblock);
			
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y + yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;
					imgd[dest]  = idctblock[src];					
					imgd[dest + 1] = idctblock[src + 1];					
					imgd[dest + 2] = idctblock[src + 2];  					
				}
			}
		}
	}
		
	delete[] tblock;
	delete[] idctblock;
	drawImage(&workingImage, nextStart);		
}

void encode(TwoByte *store){
	int h = originalImage.getHeight();
	int w = originalImage.getWidth();										
	Byte* imgd = originalImage.getImageData();	

	Byte* tblock = new Byte[192];
	double* dctblock = new double[192];
	
	memset(tblock, 0x00, sizeof(Byte)*192);
	memset(dctblock, 0x00, sizeof(double)*192);
	
	unsigned int  q = 1<<quantizationLevel;

	for(int y = 0; y < h; y+=8){
		for(int x = 0; x < w; x+=8){
			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int src = ((y+yy)*w + (x + xx))*3;
					int dest = (yy*8 + xx)*3;
					tblock[dest] = imgd[src];
					tblock[dest + 1] = imgd[src + 1];  
					tblock[dest + 2] = imgd[src + 2];  
				}
			}

			doDCT(tblock, dctblock);			

			for(int yy= 0; yy < 8; yy++){
				for(int xx = 0; xx < 8; xx++){
					int dest = ((y+yy)*w + (x + xx))*3;
					int src = (yy*8 + xx)*3;

					store[dest]  = (TwoByte)(dctblock[src]/q); 
					store[dest + 1] = (TwoByte)(dctblock[src + 1]/q);
					store[dest + 2] = (TwoByte)(dctblock[src + 2]/q);   
				}
			}
		}
	}
	delete[] tblock;
	delete[] dctblock;
}

int main(int argc, char** argv){
	if(argc < 3){
		std::cout << "usage:"<<std::endl;
		std::cout << "composite [foregroundImagename] [backgroundImagename]" << std::endl;
		std::cout << "or" <<std::endl;
		std::cout << "composite [foregroundImagename] [backgroundImagename] [outputIMagename]" << std::endl;
		exit(-1);
	}

	FileIO::getInstance().readFromFileToImage(foreImage, argv[1]);
	FileIO::getInstance().readFromFileToImage(backImage, argv[2]);
	imageToBeOutput = foreImage.over(backImage,0,0);
	display_data = new GLubyte[imageToBeOutput.getWidth()*imageToBeOutput.getHeight()*4];
	imageToBeOutput.displayOutput(display_data);

	if(argc>3){
		FileIO::getInstance().writeImageToFile(imageToBeOutput,argv[3]);
	}

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA);
	glutInitWindowSize(imageToBeOutput.getWidth(), imageToBeOutput.getHeight());
	glutInitWindowPosition(0, 0);
	glutCreateWindow(argv[0]);
	init();
	glutDisplayFunc(display);
	glutMainLoop();
	return 0;
}

void sendSuccessiveBits(void* storage){
	TwoByte* st = (TwoByte*) storage;
	
	int h = workingImage.getHeight();
	int w = workingImage.getWidth();
	int len = h*w*3;
	
	TwoByte *newst = new TwoByte[len];
	memset(newst, 0x00, sizeof(TwoByte)*len);
	TwoByte offset = 1<<12;
	for(int k = 12; k >= 0; --k){
		for(int i = 0; i < len; ++i){
			TwoByte temp = st[i] + offset;						
			temp &= (1<<k);				
			newst[i] |= temp;			
		}
		decodeProgressiveModeBitApproximation(newst, offset);	
		Sleep(latency);
	}
	delete[] newst;
	MessageBox(NULL, "DECODING DONE", "Status", NULL);
}