C++ Array::resize方法代码示例

void SetupWeights (int N, const Parameter &param, const blitz::Array<double, 1> &r, blitz::Array<double, 1> &weight)
{
	Array<double, 1> x(N);
	weight.resize(N);

	// Basic Clenshaw Curtis points and  weigths 
	x = cos(M_PI * (tensor::i +1) / (N+1));

	for (int k=0; k<N; k++)
	{
		weight(k) = 1.0;
		for (int i=1; i<(N+1)/2; i++)
		{ 
			weight(k) -= 2.0/(4*i*i-1) *cos(2.0*M_PI*i*(k+1)/(N+1));
		}
		if (N%2 == 1)
		{	
			weight(k) -= 1/(N*N+2*N) *cos((N+1)*x(N/2));
		}
		weight(k) = 2.0/(N+1) * weight(k);
	}   

	// Scaling the weights according to transformations
	if (param.Range == TransformRangeRadial)
	{
		if (param.Type == TransformTypeAlgebraic) 
		{
			weight *= param.Scaling * 2.0 / ((1+x)*(1+x));
		}
		else if (param.Type == TransformTypeTrigonometric)
		{ 
			double pi_4 = M_PI/4.0;
			weight *= param.Scaling * pi_4 / sqr(cos(pi_4*(1+x)));
		}
		else if (param.Type == TransformTypeLogarithmic) 
		{
			weight *= param.Scaling * 6.0 / (1.0 - x);
		}
		else
		{
			cout << "Invalid parameter type " << param.Type << endl;
			throw std::runtime_error("Invalid parameter type");
		}
	}	
	else if (param.Range == TransformRangeCartesian)
	{
		if (param.Type == TransformTypeAlgebraic) 
		{
			weight *= param.Scaling * 1.0 / pow(1 - x*x, 1.5);
		}
		/* Not implemented for Cartesian range
		else if (param.Type == TransformTypeTrigonometric)
		{ 
			double pi_4 = M_PI/4.0;
			weight *= 
		}
		else if (param.Type == TransformTypeLogarithmic) 
		{
			weight *= 
		}
		else
		{
			cout << "Invalid parameter type " << param.Type << endl;
			throw std::runtime_error("Invalid parameter type");
		}
		*/
	}

}

int main( int argc, char **argv)
{
std::string inpf, trif, outf, backf;
adobe::dictionary_t params;

bool use_lab = false;

	try
	{
	po::options_description desc("Allowed options");
	po::variables_map vm;
	po::positional_options_description p;

		p.add( "input" , 1);
		p.add( "trimap", 1);

		desc.add_options()	("help", "produce help message")
							// files
							("input", po::value<std::string>(), "input file")
							("trimap",po::value<std::string>(), "trimap file")
							("output,o", po::value<std::string>(), "output file")
							("background,bg", po::value<std::string>(), "clean background")
							("save_bg", "save estimated background")

							// colors
							("rgb", "use rgb colorspace")

							// sampling
							("kwin", po::value<int>()->default_value( 8), "known window radius")
							("uwin", po::value<int>()->default_value( 8), "unknown window radius")
							("mins", po::value<int>()->default_value( 16), "min samples")
							
							// clusters
							("clusters", po::value<int>()->default_value( 5), "max number of clusters")
							("ctheresh", po::value<double>()->default_value( 0.001), "cluster thereshold")
	
							// optimize
							("cvar", po::value<double>()->default_value( 0.04), "camera variance")

							// gui
							("window,w", "show results in a window")
							; // end

		po::store( po::command_line_parser( argc, argv).options( desc).positional( p).run(), vm);
		po::notify( vm);

		if( vm.count( "help") || !vm.count("input") || !vm.count("trimap"))
			usage();
		
		if( (!vm.count("output")) && (!vm.count("window")))
			usage();
			
		inpf = vm["input"].as<std::string>();
		trif = vm["trimap"].as<std::string>();
		
		if( vm.count("output"))
			outf = vm["output"].as<std::string>();

		use_lab = !vm.count("rgb");
		
		params[adobe::name_t("use_lab")] = adobe::any_regular_t( use_lab);
		
		// load images
		image.reference( read_image( inpf.c_str()));
		trimap.reference( read_trimap( trif.c_str()));

		if( (trimap.rows() != image.rows()) || (trimap.cols() != image.cols()))
		{
			std::cout << "Image & trimap dimensions don't match\n";
			exit( boost::exit_failure);
		}

		if( use_lab)
			convert2lab( image);
		
		if( vm.count( "background"))
		{
			backf = vm["background"].as<std::string>();
			params[adobe::name_t("use_back")] = adobe::any_regular_t( true);

			bg.reference( read_image( backf.c_str()));
			
			if( use_lab)
				convert2lab( bg);
		}
		else
		{
			bg.resize( image.rows(), image.cols());
			params[adobe::name_t("use_back")] = adobe::any_regular_t( false);
		}

		// sampling
		params[ adobe::name_t( "kwin_size")] = adobe::any_regular_t( vm["kwin"].as<int>());
		params[ adobe::name_t( "uwin_size")] = adobe::any_regular_t( vm["uwin"].as<int>());
		params[ adobe::name_t( "min_samples")] = adobe::any_regular_t( vm["mins"].as<int>());

		// cluster
		params[ adobe::name_t( "maxk")] = adobe::any_regular_t( vm["clusters"].as<int>());
		params[ adobe::name_t( "ctheresh")] = adobe::any_regular_t( vm["ctheresh"].as<double>());

//.........这里部分代码省略.........