C++ MyImage类代码示例

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();
}

//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);		
}