#include <iostream>

#include <fstream>

CV_SLMLTest::CV_SLMLTest( const char* _modelName, const char* _testName ) :

    CV_MLBaseTest( _modelName, _testName, "load-save" )

{

    else

        CV_Error( CV_StsBadArg, "outputs must be in the first or last column; other cases are not supported" );

}

{

    const CvMat* train_sidx = _data->get_train_sample_idx();

    int* train_sidx_ptr = train_sidx->data.i;

    CvMat _new_responses = CvMat( new_responses );

    return ann->train( &predictors, &_new_responses, 0, train_sidx, _params, flags );

}

{

    float err = 0;

    const CvMat* responses = _data->get_responses();

    int cls_count = (int)cls_map.size();

    Mat output( 1, cls_count, CV_32FC1 );

    CvMat _output = CvMat(output);

    for( int i = 0; i < sample_count; i++ )

    {

        CvMat sample;

#include <string>

#include <iostream>

using namespace cv;

#define CV_NBAYES   "nbayes"

    virtual int validate_test_results( int testCaseIdx ) = 0;

    int train( int testCaseIdx );

    void save( const char* filename );

    void load( const char* filename );

    CvMLData data;

    string modelName, validationFN;

    FileStorage validationFS;

    // MLL models

    CvRTrees* rtrees;

    CvERTrees* ertrees;

    int64 initSeed;

};

    virtual int run_test_case( int testCaseIdx );

    virtual int validate_test_results( int testCaseIdx );

    char fname1[50], fname2[50];

};

#include <vector>

#include "opencv2/flann/dist.h"

namespace cvflann

{

		// bubble up

		while (i>=1 && (dists[i]<dists[i-1] || (dists[i]==dists[i-1] && indices[i]<indices[i-1]) ) ) {

//         while (i>=1 && (dists[i]<dists[i-1]) ) {

			i--;

		}

	float worstDist() const

	{

	}

};

		}

	};

	float radius;

	bool sorted;

        float totalCost;

    };

    void evaluate_kmeans(CostData& cost, const KMeansIndexParams& kmeans_params)

        int kmeansParamSpaceSize = ARRAY_LEN(maxIterations)*ARRAY_LEN(branchingFactors);

//        CostData* kmeansCosts = new CostData[kmeansParamSpaceSize];

                int k = cnt;

                // order by time cost

                while (k>0 && kmeansCosts[k].first.timeCost < kmeansCosts[k-1].first.timeCost) {

                    --k;

                }

                ++cnt;

            int k = i;

            while (k>0 && kmeansCosts[k].first.totalCost < kmeansCosts[k-1].first.totalCost) {

                k--;

            }

        }

        int testTrees[] = { 1, 4, 8, 16, 32 };

        size_t kdtreeParamSpaceSize = ARRAY_LEN(testTrees);

        // evaluate kdtree for all parameter combinations

        int cnt = 0;

            int k = cnt;

            // order by time cost

            while (k>0 && kdtreeCosts[k].first.timeCost < kdtreeCosts[k-1].first.timeCost) {

                --k;

            }

            ++cnt;

            int k = (int)i;

            while (k>0 && kdtreeCosts[k].first.totalCost < kdtreeCosts[k-1].first.totalCost) {

                k--;

            }

        }

    IndexParams* estimateBuildParams()

    {

        int sampleSize = int(index_params.sample_fraction*dataset.rows);

        logger().info("Entering autotuning, dataset size: %d, sampleSize: %d, testSampleSize: %d\n",dataset.rows, sampleSize, testSampleSize);

        float speedup = 0;

        if (samples>0) {

            Matrix<ELEM_TYPE> testDataset = random_sample(dataset,samples);

#include "opencv2/flann/general.h"

#include "opencv2/flann/matrix.h"

namespace cvflann

{

#define _OPENCV_DIST_H_

#include <cmath>

#include "opencv2/flann/general.h"

namespace cvflann

#include "opencv2/flann/timer.h"

namespace cvflann

{

	const float SEARCH_EPS = 0.001;

    // make sure precisions array is sorted

    int pindex = 0;

    float precision = precisions[pindex];

#include "opencv2/flann/allocator.h"

#include "opencv2/flann/random.h"

namespace cvflann

{

                // Compute the new potential

                double newPot = 0;

                for (int i = 0; i < n; i++)

                // Store the best result

                if (bestNewPot < 0 || newPot < bestNewPot) {

            centers[centerCount] = indices[bestNewIndex];

            currentPot = bestNewPot;

            for (int i = 0; i < n; i++)

        }

        centers_length = centerCount;

        branching = params.branching;

        max_iter = params.iterations;

        if (max_iter<0) {

        }

        flann_centers_init_t centersInit = params.centers_init;

		if (indices_length < branching) {

			node->indices = indices;

            node->childs = NULL;

			return;

		}

		if (centers_length<branching) {

            node->indices = indices;

            node->childs = NULL;

			return;

		}

					double d = flann_dist(dataset[indices[i]],dataset[indices[i]]+veclen_,zero());

					variance += d;

					mean_radius += sqrt(d);

					end++;

				}

			}

		float meanVariance = root->variance*root->size;

		while (clusterCount<clusters_length) {

			int splitIndex = -1;

			for (int i=0;i<clusterCount;++i) {

#include "opencv2/flann/random.h"

#include "opencv2/flann/saving.h"

namespace cvflann

{

			/* Randomize the order of vectors to allow for unbiased sampling. */

			for (int j = (int)size_; j > 0; --j) {

				int rnd = rand_int(j);

			}

			trees[i] = divideTree(0, (int)size_ - 1);

		}

		/* Compute mean values.  Only the first SAMPLE_MEAN values need to be

			sampled to get a good estimate.

		*/

		for (int j = first; j <= end; ++j) {

			ELEM_TYPE* v = dataset[vind[j]];

            for (size_t k=0; k<veclen_; ++k) {

				/* Bubble end value down to right location by repeated swapping. */

				int j = num - 1;

				while (j > 0  &&  v[topind[j]] > v[topind[j-1]]) {

					--j;

				}

			}

				++i;

			} else {

				/* Move to end of list by swapping vind i and j. */

				--j;

			}

		}

		int checkCount = 0;

		Heap<BranchSt>* heap = new Heap<BranchSt>((int)size_);

		/* Search once through each tree down to root. */

		for (i = 0; i < numTrees; ++i) {

	 *  at least "mindistsq".

	*/

	void searchLevel(ResultSet<ELEM_TYPE>& result, const ELEM_TYPE* vec, Tree node, float mindistsq, int& checkCount, int maxCheck,

	{

		if (result.worstDist()<mindistsq) {

//			printf("Ignoring branch, too far\n");

            dest = srcMatrix[srcMatrix.rows-i-1];

            src = srcMatrix[r];

            for (size_t j=0;j<srcMatrix.cols;++j) {

                src++;

                dest++;

            }

#include <algorithm>

namespace cvflann

{

 	 * Returns the node of minimum value from the heap (top of the heap).

	 *

	 * Params:

	 * Returns: false if heap empty

	 */

	bool popMin(T& value)

		}

		/* Switch first node with last. */

		count -= 1;

		heapify(1);      /* Move new node 1 to right position. */

			minloc = right;

		}

		if (minloc != parent) {

			heapify(minloc);

		}

	}

#include <stdarg.h>

#include "opencv2/flann/general.h"

namespace cvflann

{

#include <cstdlib>

#include <cassert>

namespace cvflann

{

// 			int rand = cast(int) (drand48() * n);

			int rnd = rand_int(i);

			assert(rnd >=0 && rnd < i);

		}

		counter = 0;

        int j = dcnt-1;

        // bubble up

        while (j>=1 && dists[j]<dists[j-1]) {

            j--;

        }

    }

template<typename T>

{

	FILE* fin = fopen(filename.c_str(), "rb");

	if (fin==NULL) {

template<typename T>

{

	FILE* fout = fopen(filename.c_str(), "wb");

	if (fout==NULL) {

namespace cv

{

using std::queue;

typedef pair<int,int> coordinate_t;

#ifndef _CV_GCGRAPH_H_

#define _CV_GCGRAPH_H_

template <class TWeight> class GCGraph

{

public:

        TWeight weight;

    };

    TWeight flow;

};

    Vtx *vtxPtr = &vtcs[0];

    Edge *edgePtr = &edges[0];

    // initialize the active queue and the graph vertices

    for( int i = 0; i < (int)vtcs.size(); i++ )