C++ (Cpp) kkt Examples

Example #1

File: imageviewer_ex2.cpp Project: brunoferraz/computer_vision

void ImageViewer_ex2::adjustimageAffineSimilarity()
{
    Vector3f l(3,1);
    Vector3f m(3,1);
    Vector3f r1(3,1);
    Vector3f r2(3,1);
    MatrixXf A(2,3);

    l = pinmanager->getLine(0);
    m = pinmanager->getLine(1);

    r2 << l(0) * m(0), l(0) * m(1) + l(1) * m(0), l(1) * m(1);

    l = pinmanager->getLine(2);
    m = pinmanager->getLine(3);

    r1 << l(0) * m(0), l(0) * m(1) + l(1) * m(0), l(1) * m(1);

    A << r1.transpose(), r2.transpose();
    JacobiSVD<MatrixXf> SVD(A, ComputeFullV);
    VectorXf S = SVD.matrixV().col(SVD.matrixV().cols() - 1);

    //S /= S(2);
    S(2) = 1;

    MatrixXf kkt(2,2);
    kkt << S(0), S(1), S(1), S(2);

    LLT<MatrixXf> lltOfA(kkt);
    MatrixXf L = lltOfA.matrixU();

    H << L(0), L(1), 0, L(2), L(3), 0, 0, 0, 1;
    //std::cout << H << std::endl;
    H = H.inverse();

    QSize imgSize(this->width(), this->height());
    QVector<QPoint> areaRender;
    areaRender << QPoint(0,0) << QPoint(0, imgSize.height()) << QPoint(imgSize.width(), imgSize.height()) << QPoint(imgSize.width(), 0);
    showResult(imgSize, areaRender);
}

Example #2

File: Hildreth.cpp Project: crazydreamer/moses-online

vector<float> Hildreth::optimise (const vector<SparseVec>& a, const vector<float>& b) {

	size_t i;
	int max_iter = 10000;
	float eps = 0.00000001;
	float zero = 0.000000000001;

	vector<float> alpha ( b.size() );
	vector<float> F ( b.size() );
	vector<float> kkt ( b.size() );

	float max_kkt = -1e100;

	size_t K = b.size();

	float A[K][K];
	bool is_computed[K];
	for ( i = 0; i < K; i++ )
	{
		A[i][i] = inner_product(a[i], a[i]);
		is_computed[i] = false;
	}

	int max_kkt_i = -1;


	for ( i = 0; i < b.size(); i++ )
	{
		F[i] = b[i];
		kkt[i] = F[i];
		if ( kkt[i] > max_kkt )
		{
			max_kkt = kkt[i];
			max_kkt_i = i;
		}
	}

	int iter = 0;
	float diff_alpha;
	float try_alpha;
	float add_alpha;

	while ( max_kkt >= eps && iter < max_iter )
	{

		diff_alpha = A[max_kkt_i][max_kkt_i] <= zero ? 0.0 : F[max_kkt_i]/A[max_kkt_i][max_kkt_i];
		try_alpha = alpha[max_kkt_i] + diff_alpha;
		add_alpha = 0.0;

		if ( try_alpha < 0.0 )
			add_alpha = -1.0 * alpha[max_kkt_i];
		else
			add_alpha = diff_alpha;

		alpha[max_kkt_i] = alpha[max_kkt_i] + add_alpha;

		if ( !is_computed[max_kkt_i] )
		{
			for ( i = 0; i < K; i++ )
			{
				A[i][max_kkt_i] = inner_product(a[i], a[max_kkt_i]); // for version 1
				//A[i][max_kkt_i] = 0; // for version 1
				is_computed[max_kkt_i] = true;
			}
		}

		for ( i = 0; i < F.size(); i++ )
		{
			F[i] -= add_alpha * A[i][max_kkt_i];
			kkt[i] = F[i];
			if ( alpha[i] > zero )
				kkt[i] = abs ( F[i] );
		}
		max_kkt = -1e100;
		max_kkt_i = -1;
		for ( i = 0; i < F.size(); i++ )
			if ( kkt[i] > max_kkt )
			{
				max_kkt = kkt[i];
				max_kkt_i = i;
			}

		iter++;
	}

	return alpha;
}