示例#1
0
文件: igi.cpp 项目: bernstein/pbrt-v2
Spectrum IGIIntegrator::Li(const Scene &scene, const Renderer *renderer,
        const RayDifferential &ray, const Intersection &isect,
        const Sample *sample, RNG &rng, MemoryArena &arena) const {
    Spectrum L(0.);
    Vector wo = -ray.d;
    // Compute emitted light if ray hit an area light source
    L += isect.Le(wo);

    // Evaluate BSDF at hit point
    BSDF *bsdf = isect.GetBSDF(ray, arena);
    const Point &p = bsdf->dgShading.p;
    const Normal &n = bsdf->dgShading.nn;
    L += UniformSampleAllLights(scene, renderer, arena, p, n,
                    wo, isect.rayEpsilon, ray.time, bsdf, sample, rng,
                    lightSampleOffsets, bsdfSampleOffsets);
    // Compute indirect illumination with virtual lights
    uint32_t lSet = min(uint32_t(sample->oneD[vlSetOffset][0] * nLightSets),
                        nLightSets-1);
    for (uint32_t i = 0; i < virtualLights[lSet].size(); ++i) {
        const VirtualLight &vl = virtualLights[lSet][i];
        // Compute virtual light's tentative contribution _Llight_
        float d2 = DistanceSquared(p, vl.p);
        Vector wi = Normalize(vl.p - p);
        float G = AbsDot(wi, n) * AbsDot(wi, vl.n) / d2;
        G = min(G, gLimit);
        Spectrum f = bsdf->f(wo, wi);
        if (G == 0.f || f.IsBlack()) continue;
        Spectrum Llight = f * G * vl.pathContrib / nLightPaths;
        RayDifferential connectRay(p, wi, ray, isect.rayEpsilon,
                                   sqrtf(d2) * (1.f - vl.rayEpsilon));
        Llight *= renderer->Transmittance(scene, connectRay, NULL, rng, arena);

        // Possibly skip virtual light shadow ray with Russian roulette
        if (Llight.y() < rrThreshold) {
            float continueProbability = .1f;
            if (rng.RandomFloat() > continueProbability)
                continue;
            Llight /= continueProbability;
        }

        // Add contribution from _VirtualLight_ _vl_
        if (!scene.IntersectP(connectRay))
            L += Llight;
    }
    if (ray.depth < maxSpecularDepth) {
        // Do bias compensation for bounding geometry term
        int nSamples = (ray.depth == 0) ? nGatherSamples : 1;
        for (int i = 0; i < nSamples; ++i) {
            Vector wi;
            float pdf;
            BSDFSample bsdfSample = (ray.depth == 0) ?
                BSDFSample(sample, gatherSampleOffset, i) : BSDFSample(rng);
            Spectrum f = bsdf->Sample_f(wo, &wi, bsdfSample,
                                        &pdf, BxDFType(BSDF_ALL & ~BSDF_SPECULAR));
            if (!f.IsBlack() && pdf > 0.f) {
                // Trace ray for bias compensation gather sample
                float maxDist = sqrtf(AbsDot(wi, n) / gLimit);
                RayDifferential gatherRay(p, wi, ray, isect.rayEpsilon, maxDist);
                Intersection gatherIsect;
                Spectrum Li = renderer->Li(scene, gatherRay, sample, rng, arena,
                                           &gatherIsect);
                if (Li.IsBlack()) continue;

                // Add bias compensation ray contribution to radiance sum
                float Ggather = AbsDot(wi, n) * AbsDot(-wi, gatherIsect.dg.nn) /
                    DistanceSquared(p, gatherIsect.dg.p);
                if (Ggather - gLimit > 0.f && !isinf(Ggather)) {
                    float gs = (Ggather - gLimit) / Ggather;
                    L += f * Li * (AbsDot(wi, n) * gs / (nSamples * pdf));
                }
            }
        }
    }
    if (ray.depth + 1 < maxSpecularDepth) {
        Vector wi;
        // Trace rays for specular reflection and refraction
        L += SpecularReflect(ray, bsdf, rng, isect, renderer, scene, sample,
                             arena);
        L += SpecularTransmit(ray, bsdf, rng, isect, renderer, scene, sample,
                              arena);
    }
    return L;
}
示例#2
0
int main()
{
	cv::Mat src;
	cv::Mat dst;
	cv::Mat paintable;
	int end=false;

	// read the img
	src = imread("C:/Users/giki/Pictures/quadri_dataset/quadro_tre.jpg", 1);
	if (src.empty())
		return -1;

	cv::Size s = src.size();
	src.copyTo(paintable);

	// Convert to grayscale
	cv::Mat gray;
	cv::cvtColor(src, gray, CV_BGR2GRAY);

	// Convert to binary image using Canny
	cv::Mat bw;
	cv::Canny(gray, bw, 0, 50, 5);
	
	// Find contours
	std::vector<std::vector<cv::Point> > contours;
	cv::findContours(bw.clone(), contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
	vector<Vec4i> hierarchy;

	// The array for storing the approximation curve
	std::vector<cv::Point> approx;

	// Rects extraction
	vector<vector<Point>> contours_poly( contours.size() );
	vector<Rect> bound_rect( contours.size() );
	vector<vector<Rect>> good_rect;
	int good_rect_index=0;
	for (int i = 0; i < contours.size(); i++)
	{
		// poligon approximation
		approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true );
		// extraciont only poligon=rect
		bound_rect[i] = boundingRect( Mat(contours_poly[i]) );	
		//-------------
		if (bound_rect[i].area() > (s.area()*0.30) )
		{
			vector<Rect> vector;
			vector.push_back(bound_rect[i]);
			good_rect.push_back(vector); // estrapolo tutti i rettangoli buoni
			good_rect_index++;
			Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
			rectangle( paintable, bound_rect[i].tl(), bound_rect[i].br(), color, 2, 8, 0 );
		}
	} 

	if (good_rect.size()==0)
		// non si sono trovati rettangoli compatibili, forse 
		// l'immagine è una parte interna di quadro
	{
		dst=src;
		end=true;
	}

	//cv::imshow("src", paintable);
	//waitKey();

	if (end==false)
	{
		// adesso di questi rettangoli buoni devo prendere quelli che effettivamente costituiscono il mio quadro
		for (int j = 0; j < good_rect_index; j++)
		{
			Rect confront = good_rect[j][0];
			int x_center = confront.x+confront.width/2;
			int y_center = confront.y+confront.height/2;

			for (int i = 0; i < good_rect_index; i++)
			{
				if (j==i)
					continue;
				else if (x_center > good_rect[i][0].x + good_rect[i][0].width/2 - good_rect[i][0].width*0.05)
						if (x_center < good_rect[i][0].x + good_rect[i][0].width/2+good_rect[i][0].width*0.05)
							if (y_center > good_rect[i][0].y+good_rect[i][0].height/2-good_rect[i][0].height*0.05)
								if (y_center < good_rect[i][0].y+good_rect[i][0].height/2+good_rect[i][0].height*0.05)
									good_rect[i].push_back(confront);
			}// sto codicione che andrà semplificato praticamente controlla il centro dei rettangoli e definisce
			 // due rettangoli come buoni se hanno lo stesso centro (con un minimo di errore accettabile)
			 // infatti ho deciso che per me un quadro è una successione di rettangoli con lo stesso centro
			 // (cornice interna + cornice esterna + inizio tela = 3 rettangoli con lo stesso centro),
			 // più o meno funziona sempre, a meno di cornici strane.

		}
		// Ho un vettore di vettori contenente tutti gli accoppiamenti, prendo l'accoppiamento che 
		// contiene i rettangoli più grandi
		vector<Rect> quadro;
		for( int i = 0; i< good_rect_index; i++ ) // iterate through each contour.
		{	
			if (i==0)
				quadro=good_rect[i];
			else if (quadro.size() < good_rect[i].size())
				{
					quadro=good_rect[i];
				}
		}

		int size = quadro.size();

		for (int i=0; i < size; i++)
		{	
			Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
			rectangle( paintable, quadro[i].tl(), quadro[i].br(), color, 2, 8, 0 );
		}

		// Max rect extraction from the quadro
		int largest_contour_index=0;
		cv::Rect big_rect; // The variable to store max rect

		for( int i = 0; i < quadro.size(); i++ ) // iterate through each contour.
		{	
			if (i==0)
				big_rect=quadro[i];
			else if (big_rect.area() < quadro[i].area())
				{
					big_rect=quadro[i];
					largest_contour_index=i;
				}
		}

		// cut the image to have only the quadro
		src(big_rect).copyTo(dst); 

	}
	cv::imshow("src", src);
	cv::imshow("src_with rect", paintable);
	cv::imshow("dst", dst);
    waitKey();
	return 0;
}			
示例#3
0
// Reproduce mates & mutates the individuals of the species
// It may access the global species list in the population
// because some babies may turn out to belong in another species
// that have to be created.
// Also calls Birth() for every new baby
void Species::Reproduce(Population &a_Pop, Parameters& a_Parameters, RNG& a_RNG)
{
    Genome t_baby; // temp genome for reproduction

    int t_offspring_count = Rounded(GetOffspringRqd());

    // no offspring?! yikes.. dead species!
    if (t_offspring_count == 0)
    {
        // maybe do something else?
        return;
    }

    //////////////////////////
    // Reproduction

    // Spawn t_offspring_count babies
    bool t_champ_chosen = false;
    bool t_baby_exists_in_pop = false;
    while(t_offspring_count--)
    {
        // if the champ was not chosen, do it now..
        if (!t_champ_chosen)
        {
            t_baby = m_Individuals[0];
            t_champ_chosen = true;
        }
        // or if it was, then proceed with the others
        else
        {
            do // - while the baby already exists somewhere in the new population
            {
                // this tells us if the baby is a result of mating
                bool t_mated = false;

                // There must be individuals there..
                ASSERT(NumIndividuals() > 0);

                // for a species of size 1 we can only mutate
                // NOTE: but does it make sense since we know this is the champ?
                if (NumIndividuals() == 1)
                {
                    t_baby = GetIndividual(a_Parameters, a_RNG);
                    t_mated = false;
                }
                // else we can mate
                else
                {
                    do // keep trying to mate until a good offspring is produced
                    {
                        Genome t_mom = GetIndividual(a_Parameters, a_RNG);

                        // choose whether to mate at all
                        // Do not allow crossover when in simplifying phase
                        if ((a_RNG.RandFloat() < a_Parameters.CrossoverRate) && (a_Pop.GetSearchMode() != SIMPLIFYING))
                        {
                            // get the father
                            Genome t_dad;
                            bool t_interspecies = false;

                            // There is a probability that the father may come from another species
                            if ((a_RNG.RandFloat() < a_Parameters.InterspeciesCrossoverRate) && (a_Pop.m_Species.size()>1))
                            {
                                // Find different species (random one) // !!!!!!!!!!!!!!!!!
                                int t_diffspec = a_RNG.RandInt(0, static_cast<int>(a_Pop.m_Species.size()-1));
                                t_dad = a_Pop.m_Species[t_diffspec].GetIndividual(a_Parameters, a_RNG);
                                t_interspecies = true;
                            }
                            else
                            {
                                // Mate within species
                                t_dad = GetIndividual(a_Parameters, a_RNG);

                                // The other parent should be a different one
                                // number of tries to find different parent
                                int t_tries = 32;
                                if (!a_Parameters.AllowClones)
                                    while(((t_mom.GetID() == t_dad.GetID()) || (t_mom.CompatibilityDistance(t_dad, a_Parameters) < 0.00001) ) && (t_tries--))
                                    {
                                        t_dad = GetIndividual(a_Parameters, a_RNG);
                                    }
                                else
                                    while(((t_mom.GetID() == t_dad.GetID()) ) && (t_tries--))
                                    {
                                        t_dad = GetIndividual(a_Parameters, a_RNG);
                                    }
                                t_interspecies = false;
                            }

                            // OK we have both mom and dad so mate them
                            // Choose randomly one of two types of crossover
                            if (a_RNG.RandFloat() < a_Parameters.MultipointCrossoverRate)
                            {
                                t_baby = t_mom.Mate( t_dad, false, t_interspecies, a_RNG);
                            }
                            else
                            {
                                t_baby = t_mom.Mate( t_dad, true, t_interspecies, a_RNG);
                            }

                            t_mated = true;
                        }
                        // don't mate - reproduce the mother asexually
                        else
                        {
                            t_baby = t_mom;
                            t_mated = false;
                        }

                    } while (t_baby.HasDeadEnds() || (t_baby.NumLinks() == 0));
                    // in case of dead ends after crossover we will repeat crossover
                    // until it works
                }


                // Mutate the baby
                if ((!t_mated) || (a_RNG.RandFloat() < a_Parameters.OverallMutationRate))
                    MutateGenome(t_baby_exists_in_pop, a_Pop, t_baby, a_Parameters, a_RNG);

                // Check if this baby is already present somewhere in the offspring
                // we don't want that
                t_baby_exists_in_pop = false;
                // Unless of course, we want
                if (!a_Parameters.AllowClones)
                {
                    for(unsigned int i=0; i<a_Pop.m_TempSpecies.size(); i++)
                    {
                        for(unsigned int j=0; j<a_Pop.m_TempSpecies[i].m_Individuals.size(); j++)
                        {
                            if (
                                (t_baby.CompatibilityDistance(a_Pop.m_TempSpecies[i].m_Individuals[j], a_Parameters) < 0.00001) // identical genome?
                               )

                            {
                                t_baby_exists_in_pop = true;
                                break;
                            }
                        }
                    }
                }
            }
            while (t_baby_exists_in_pop); // end do
        }

        // Final place to test for problems
        // If there is anything wrong here, we will just
        // pick a random individual and leave him unchanged
        if ((t_baby.NumLinks() == 0) || t_baby.HasDeadEnds())
        {
            t_baby = GetIndividual(a_Parameters, a_RNG);
        }


        // We have a new offspring now
        // give the offspring a new ID
        t_baby.SetID(a_Pop.GetNextGenomeID());
        a_Pop.IncrementNextGenomeID();

        // sort the baby's genes
        t_baby.SortGenes();

        // clear the baby's fitness
        t_baby.SetFitness(0);
        t_baby.SetAdjFitness(0);
        t_baby.SetOffspringAmount(0);

        t_baby.ResetEvaluated();


        //////////////////////////////////
        // put the baby to its species  //
        //////////////////////////////////

        // before Reproduce() is invoked, it is assumed that a
        // clone of the population exists with the name of m_TempSpecies
        // we will store results there.
        // after all reproduction completes, the original species will be replaced back

        bool t_found = false;
        std::vector<Species>::iterator t_cur_species = a_Pop.m_TempSpecies.begin();

        // No species yet?
        if (t_cur_species == a_Pop.m_TempSpecies.end())
        {
            // create the first species and place the baby there
            a_Pop.m_TempSpecies.push_back( Species(t_baby, a_Pop.GetNextSpeciesID()));
            a_Pop.IncrementNextSpeciesID();
        }
        else
        {
            // try to find a compatible species
            Genome t_to_compare = t_cur_species->GetRepresentative();

            t_found = false;
            while((t_cur_species != a_Pop.m_TempSpecies.end()) && (!t_found))
            {
                if (t_baby.IsCompatibleWith( t_to_compare, a_Parameters))
                {
                    // found a compatible species
                    t_cur_species->AddIndividual(t_baby);
                    t_found = true; // the search is over
                }
                else
                {
                    // keep searching for a matching species
                    t_cur_species++;
                    if (t_cur_species != a_Pop.m_TempSpecies.end())
                    {
                        t_to_compare = t_cur_species->GetRepresentative();
                    }
                }
            }

            // if couldn't find a match, make a new species
            if (!t_found)
            {
                a_Pop.m_TempSpecies.push_back( Species(t_baby, a_Pop.GetNextSpeciesID()));
                a_Pop.IncrementNextSpeciesID();
            }
        }
    }
}
示例#4
0
    double operator()(Individual& ind, RNG& rng, EA& ea) {
        
        int max_x = get<X_SIZE>(ea,10);
        int max_y = get<Y_SIZE>(ea,10);
        int grid_size = max_x * max_y;
        vector<int> agent_pos (grid_size, -1);
        vector<int> exec_order (grid_size);
        double f=0.0;
        
        
        // get the "prototype" phenotype (markov network):
        typename EA::phenotype_type &N = ealib::phenotype(ind, ea);
        vector<typename EA::phenotype_type> as; //
        
        
        for (int q=0; q<get<NUM_START_AGENTS>(ea,1); q++) {
            as.push_back(N); //grid_size, N); // my agents or networks
            agent_pos[q] = q;
            as[q].reset(rng.seed());
        }
        
        for (int i=0; i<grid_size; ++i) {
            exec_order[i] = i;
        }
        
        
        std::vector< std::vector<int> > cell_color(grid_size, std::vector<int>(2, 0));
        std::vector<int> apop_count(grid_size,0);
        update_world_stigmergic_communication_apop_N(get<WORLD_UPDATES>(ea,10), agent_pos, exec_order, as, cell_color, apop_count, ind, rng, ea);
        
        
        int fit_func = get<BODYPLAN>(ea,0) ;
        switch(fit_func) {
            case 0:
                f = body_plan0(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 1:
                f = body_plan1(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 2:
                f = body_plan2(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 3:
                f = body_plan3(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 4:
                f = body_plan4(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 5:
                f = body_plan5(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 6:
                f = body_plan6(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 7:
                f = body_plan7(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 8:
                f = body_plan8(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 9:
                f = body_plan9(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 10:
                f = body_plan10(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 11:
                f = body_plan11(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 12:
                f = body_plan12(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 13:
                f = body_plan13(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 14:
                f = body_plan14(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 15:
                f = body_plan15(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 16:
                f = body_plan16(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 17:
                f = body_plan17(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 18:
                f = body_plan18(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
            case 19:
                f = body_plan19(grid_size, max_x, max_y, agent_pos, as, ea);
                break;
        }

        if (f == 0) {
            f = 1; 
        }
        return (f);
        
        
        
        
    }
示例#5
0
文件: pSBL.cpp 项目: RickOne16/ompl
bool ompl::geometric::pSBL::checkSolution(RNG &rng, bool start, TreeData &tree, TreeData &otherTree, Motion *motion, std::vector<Motion*> &solution)
{
    Grid<MotionInfo>::Coord coord;
    projectionEvaluator_->computeCoordinates(motion->state, coord);

    otherTree.lock.lock();
    Grid<MotionInfo>::Cell* cell = otherTree.grid.getCell(coord);

    if (cell && !cell->data.empty())
    {
        Motion *connectOther = cell->data[rng.uniformInt(0, cell->data.size() - 1)];
        otherTree.lock.unlock();

        if (pdef_->getGoal()->isStartGoalPairValid(start ? motion->root : connectOther->root, start ? connectOther->root : motion->root))
        {
            Motion *connect = new Motion(si_);

            si_->copyState(connect->state, connectOther->state);
            connect->parent = motion;
            connect->root = motion->root;

            motion->lock.lock();
            motion->children.push_back(connect);
            motion->lock.unlock();

            addMotion(tree, connect);

            if (isPathValid(tree, connect) && isPathValid(otherTree, connectOther))
            {
                if (start)
                    connectionPoint_ = std::make_pair(motion->state, connectOther->state);
                else
                    connectionPoint_ = std::make_pair(connectOther->state, motion->state);

                /* extract the motions and put them in solution vector */

                std::vector<Motion*> mpath1;
                while (motion != nullptr)
                {
                    mpath1.push_back(motion);
                    motion = motion->parent;
                }

                std::vector<Motion*> mpath2;
                while (connectOther != nullptr)
                {
                    mpath2.push_back(connectOther);
                    connectOther = connectOther->parent;
                }

                if (!start)
                    mpath1.swap(mpath2);

                for (int i = mpath1.size() - 1 ; i >= 0 ; --i)
                    solution.push_back(mpath1[i]);
                solution.insert(solution.end(), mpath2.begin(), mpath2.end());

                return true;
            }
        }
    }
    else
        otherTree.lock.unlock();

    return false;
}
示例#6
0
void RSATests::testSigningVerifying()
{
	AsymmetricKeyPair* kp;
	RSAParameters p;

	// Public exponents to test
	std::vector<ByteString> exponents;
	exponents.push_back("010001");
	exponents.push_back("03");
	exponents.push_back("0B");
	exponents.push_back("11");

	// Key sizes to test
	std::vector<size_t> keySizes;
	keySizes.push_back(1024);
	keySizes.push_back(1280);
	keySizes.push_back(2048);
	//keySizes.push_back(4096);

	// Mechanisms to test
	std::vector<AsymMech::Type> mechanisms;
#ifndef WITH_FIPS
	mechanisms.push_back(AsymMech::RSA_MD5_PKCS);
#endif
	mechanisms.push_back(AsymMech::RSA_SHA1_PKCS);
	mechanisms.push_back(AsymMech::RSA_SHA224_PKCS);
	mechanisms.push_back(AsymMech::RSA_SHA256_PKCS);
	mechanisms.push_back(AsymMech::RSA_SHA384_PKCS);
	mechanisms.push_back(AsymMech::RSA_SHA512_PKCS);
	mechanisms.push_back(AsymMech::RSA_SHA1_PKCS_PSS);
	mechanisms.push_back(AsymMech::RSA_SHA224_PKCS_PSS);
	mechanisms.push_back(AsymMech::RSA_SHA256_PKCS_PSS);
	mechanisms.push_back(AsymMech::RSA_SHA384_PKCS_PSS);
	mechanisms.push_back(AsymMech::RSA_SHA512_PKCS_PSS);
#ifndef WITH_FIPS
	mechanisms.push_back(AsymMech::RSA_SSL);
#endif

	/* Max salt length for SHA512 and 1024-bit RSA is 62 bytes */
	RSA_PKCS_PSS_PARAMS pssParams[] = {
		{ HashAlgo::SHA1,   AsymRSAMGF::MGF1_SHA1,   20 },
		{ HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 0  },
		{ HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 0  },
		{ HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48 },
		{ HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 62 }
	};

	for (std::vector<ByteString>::iterator e = exponents.begin(); e != exponents.end(); e++)
	{
		for (std::vector<size_t>::iterator k = keySizes.begin(); k != keySizes.end(); k++)
		{
			p.setE(*e);
			p.setBitLength(*k);

			// Generate key-pair
			CPPUNIT_ASSERT(rsa->generateKeyPair(&kp, &p));

			// Generate some data to sign
			ByteString dataToSign;

			RNG* rng = CryptoFactory::i()->getRNG();

			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567));

			// Test mechanisms that perform internal hashing
			for (std::vector<AsymMech::Type>::iterator m = mechanisms.begin(); m != mechanisms.end(); m++)
			{
				ByteString blockSignature, singlePartSignature;
				void* param = NULL;
				size_t paramLen = 0;
				bool isPSS = false;

				switch (*m)
				{
					case AsymMech::RSA_SHA1_PKCS_PSS:
						param = &pssParams[0];
						paramLen = sizeof(pssParams[0]);
						isPSS = true;
						break;
					case AsymMech::RSA_SHA224_PKCS_PSS:
						param = &pssParams[1];
						paramLen = sizeof(pssParams[1]);
						isPSS = true;
						break;
					case AsymMech::RSA_SHA256_PKCS_PSS:
						param = &pssParams[2];
						paramLen = sizeof(pssParams[2]);
						isPSS = true;
						break;
					case AsymMech::RSA_SHA384_PKCS_PSS:
						param = &pssParams[3];
						paramLen = sizeof(pssParams[3]);
						isPSS = true;
						break;
					case AsymMech::RSA_SHA512_PKCS_PSS:
						param = &pssParams[4];
						paramLen = sizeof(pssParams[4]);
						isPSS = true;
						break;
					default:
						break;
				}

				// Sign the data in blocks
				CPPUNIT_ASSERT(rsa->signInit(kp->getPrivateKey(), *m, param, paramLen));
				CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(0, 134)));
				CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(134, 289)));
				CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(134 + 289)));
				CPPUNIT_ASSERT(rsa->signFinal(blockSignature));

				// Sign the data in one pass
				CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, singlePartSignature, *m, param, paramLen));

				// If it is not a PSS signature, check if the two signatures match
				if (!isPSS)
				{
					// Check if the two signatures match
					CPPUNIT_ASSERT(blockSignature == singlePartSignature);
				}

				// Now perform multi-pass verification
				CPPUNIT_ASSERT(rsa->verifyInit(kp->getPublicKey(), *m, param, paramLen));
				CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(0, 125)));
				CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(125, 247)));
				CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(125 + 247)));
				CPPUNIT_ASSERT(rsa->verifyFinal(blockSignature));

				// And single-pass verification
				CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, singlePartSignature, *m, param, paramLen));
			}

			// Test mechanisms that do not perform internal hashing

			// Test PKCS #1 signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 35));

			// Sign the data
			ByteString signature;
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS));

			// Verify the signature
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS));

			// Test raw RSA signing
			size_t byteSize = *k >> 3;

			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, byteSize));

			// Strip the topmost bit
			dataToSign[0] &= 0x7F;

			// Sign the data
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA));

			// Verify the signature
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA));

#ifdef WITH_RAW_PSS
			// Test raw (SHA1) PKCS PSS signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 20));
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0], sizeof(pssParams[0])));
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0], sizeof(pssParams[0])));

			// Test raw (SHA224) PKCS PSS signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 28));
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1], sizeof(pssParams[1])));
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1], sizeof(pssParams[1])));

			// Test raw (SHA256) PKCS PSS signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 32));
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2], sizeof(pssParams[2])));
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2], sizeof(pssParams[2])));

			// Test raw (SHA384) PKCS PSS signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 48));
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3], sizeof(pssParams[3])));
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3], sizeof(pssParams[3])));

			// Test raw (SHA512) PKCS PSS signing
			CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 64));
			CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4], sizeof(pssParams[4])));
			CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4], sizeof(pssParams[4])));
#endif

			rsa->recycleKeyPair(kp);
		}
	}
}
示例#7
0
Spectrum VolumePatIntegrator::Li_Single(const Scene *scene, const Renderer *renderer,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        Spectrum *T, MemoryArena &arena) const {
    VolumeRegion *vr = scene->volumeRegion;
    float t0, t1;
    if (!vr || !vr->IntersectP(ray, &t0, &t1) || (t1-t0) == 0.f) {
        *T = 1.f;
        return 0.f;
    }
    // Do single scattering volume integration in _vr_
    Spectrum Lv(0.);

    // Prepare for volume integration stepping
    int nSamples = Ceil2Int((t1-t0) / stepSize);
    float step = (t1 - t0) / nSamples;
    Spectrum Tr(1.f);
    Point p = ray(t0), pPrev;
    Vector w = -ray.d;
    t0 += sample->oneD[scatterSampleOffset][0] * step;

    // Compute sample patterns for single scattering samples
    float *lightNum = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightNum, rng);
    float *lightComp = arena.Alloc<float>(nSamples);
    LDShuffleScrambled1D(1, nSamples, lightComp, rng);
    float *lightPos = arena.Alloc<float>(2*nSamples);
    LDShuffleScrambled2D(1, nSamples, lightPos, rng);
    uint32_t sampOffset = 0;
    for (int i = 0; i < nSamples; ++i, t0 += step) {
        // Advance to sample at _t0_ and update _T_
        pPrev = p;
        p = ray(t0);
        Ray tauRay(pPrev, p - pPrev, 0.f, 1.f, ray.time, ray.depth);
        Spectrum stepTau = vr->tau(tauRay,
                                   .5f * stepSize, rng.RandomFloat());
        Tr *= Exp(-stepTau);

        // Possibly terminate ray marching if transmittance is small
        if (Tr.y() < 1e-3) {
            const float continueProb = .5f;
            if (rng.RandomFloat() > continueProb) {
                Tr = 0.f;
                break;
            }
            Tr /= continueProb;
        }

        // Compute single-scattering source term at _p_
        Lv += Tr * vr->Lve(p, w, ray.time);
        Spectrum ss = vr->Sigma_s(p, w, ray.time);
        if (!ss.IsBlack() && scene->lights.size() > 0) {
            int nLights = scene->lights.size();
            int ln = min(Floor2Int(lightNum[sampOffset] * nLights),
                         nLights-1);
            Light *light = scene->lights[ln];
            // Add contribution of _light_ due to scattering at _p_
            float pdf;
            VisibilityTester vis;
            Vector wo;
            LightSample ls(lightComp[sampOffset], lightPos[2*sampOffset],
                           lightPos[2*sampOffset+1]);
            Spectrum L = light->Sample_L(p, 0.f, ls, ray.time, &wo, &pdf, &vis);
            if (!L.IsBlack() && pdf > 0.f && vis.Unoccluded(scene)) {
                Spectrum Ld = L * vis.Transmittance(scene, renderer, NULL, rng, arena);
                Lv += Tr * ss * vr->p(p, w, -wo, ray.time) * Ld * float(nLights) /
                        pdf;
            }
        }
        ++sampOffset;
    }
    *T = Tr;
    return Lv * step;
}
示例#8
0
//This function is called everytime a new image is published
void imageCallback(const sensor_msgs::ImageConstPtr& original_image)
{

	bpMsgs::brick brick;
	brick.header.stamp.sec = original_image->header.stamp.sec;
	brick.header.stamp.nsec = original_image->header.stamp.nsec;
	ROS_INFO("stamp sec: %ld nano: %ld", (long int)original_image->header.stamp.sec, (long int)original_image->header.stamp.nsec);
	cv::namedWindow("trackBar", CV_WINDOW_NORMAL);
	cv::resizeWindow("trackBar", 400, 300);


	createTrackbar( "highThresh", "trackBar", &low_thresh, max_thresh, callback );
	createTrackbar( "lowThresh", "trackBar", &high_thresh, max_thresh, callback);


	//Convert from the ROS image message to a CvImage suitable for working with OpenCV for processing
	cv_bridge::CvImagePtr cv_ptr;
	try
	{
		//Always copy, returning a mutable CvImage
		//OpenCV expects color images to use BGR channel order.
		cv_ptr = cv_bridge::toCvCopy(original_image, enc::BGR8);
	}
	catch (cv_bridge::Exception& e)
	{
		//if there is an error during conversion, display it
		ROS_ERROR("camera::main.cpp::cv_bridge exception: %s", e.what());
		return;
	}
	Mat imgdest;

	HSVToBW(cv_ptr->image,imgdest,2);

	//filter(imgdest);

	//erode(imgdest,imgdest,Size(3,3),Point(0,0),3);
	//erode(imgdest,imgdest,Mat(),Point(-1,-1),3);
	GaussianBlur(imgdest, imgdest, Size(3,3), 1.5, 1.5);
	cv::imshow("grey", imgdest);
	  Mat canny_output;
	  vector<vector<Point> > contours;
	  vector<Vec4i> hierarchy;
	  double area;
	  int k;
	  /// Detect edges using canny
	  //Canny( src_gray, canny_output, 400, 1000, 3 );

	  //imshow( "After Canny", canny_output );

	  /// Find contours
	  findContours( /*canny_output*/ imgdest, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_NONE, Point(0, 0) );

	  vector<Moments> _mu(contours.size());
	  vector<Point2f> _mc(contours.size());
	  vector<double> _ma(contours.size());
	  vector<RotatedRect> minRect( contours.size() );
	 // vector<RotatedRect> minEllipse( contours.size() );

	  for( int i = 0; i < contours.size(); i++)
	  {
		  minRect[i] = minAreaRect( Mat(contours[i]) );
		  area = contourArea(contours[i],false);
		   if (area < 1){
			  // cout << "sletter: " << area << endl;
			   contours.erase(contours.begin()+i);
			   minRect.erase(minRect.begin()+i);
			   //area = contourArea(contours[i+1],false);
			   //contours.pop_back();
			   //cout << i << endl;
			   i--;
		   }
		   else {
		//	   minEllipse[i] = fitEllipse( contours[i] );

		   _mu[i] = moments( Mat(contours[i]), false );
		 //  _mu[i] = moments( Mat(minRect[i]), false );
		   _mc[i] = Point2f( _mu[i].m10/_mu[i].m00 , _mu[i].m01/_mu[i].m00);
		   _ma[i] = (0.5*atan2(2*_mu[i].mu11,_mu[i].mu20-_mu[i].mu02))*180/M_PI;
		   ROS_INFO("Contour no: %ld Area: %ld Center x: %ld  y: %ld  Orientation: %ld ", (long int)i,(long int)area,(long int)_mc[i].x, (long int)_mc[i].y, (long int)_ma[i]);
		   ROS_INFO("Contour no: %ld Area: %ld Center x: %ld  y: %ld  Orientation: %ld ", (long int)i,(long int)area,(long int)minRect[i].center.x, (long int)minRect[i].center.y, (long int)minRect[i].angle);
		   brick.angle = _ma[i];
		   brick.x = minRect[i].center.x;
		   brick.y = minRect[i].center.y;
		   if (area > 3000 && area < 5000) {
			   brick.type = 2;
		   }
		   else if (area > 7000 && area < 9000){
			   brick.type = 1;
		   }
		   else if(area > 11000 && area < 13000){
			   brick.type = 3;
		   }
		   else{
			   brick.type = 0;
		   }
		   brick_pub.publish(brick);
		   }
		  // cout << "Contour no: " << i << " Area: " << area << " Center x: " << _mc[i].x << " y: " << _mc[i].y << " Orientation: " << _ma[i] << endl;
		 //  cout << "Ellipse Orientation: " << minEllipse[i].angle << endl;

		   //   cout << oldarea << endl;
	  }

		   Mat drawing = Mat::zeros( imgdest.size(), CV_8UC3 );
		     for( int i = 0; i< contours.size(); i++ )
		        {
		          Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
		       //   drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
		        //  drawContours( drawing, contours, i, color, CV_FILLED );
		        //  ellipse( drawing, minEllipse[i], color, 2, 8 );
		        //  Point2f rect_points[4]; minRect[i].points( rect_points );
		          drawCross(_mc[i],Scalar(0,0,255), 5, drawing);
		          Point2f rect_points[4];
		          minRect[i].points( rect_points );
		          for( int j = 0; j < 4; j++ ) {
		                    line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 );
		          }
		          char buff[255];
		          //sprintf(buff, "%d", i+1);
		          string text = std::string(buff);
		          cv::putText(drawing,text,_mc[i],0,0.5,Scalar(0,0,255),1,8,false);
		         // for( int j = 0; j < 4; j++ )
		        //            line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 );
		        }
		     ROS_INFO("size: %d", contours.size());
		     /// Show in a window
		   //  namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
		   //  imshow( "Contours", drawing );


	cv::imshow("image processed", cv_ptr->image);
	cv::imshow("contours", drawing);
	//cv::imshow("trackBar1", imgdest);
	cv::waitKey(3);

	//Convert the CvImage to a ROS image message and publish it on the "camera/image_processed" topic.
        pub.publish(cv_ptr->toImageMsg());
}
示例#9
0
int main(int, char**)
{
    VideoCapture cap(0); // open the default camera
    if(!cap.isOpened()){  // check if we succeeded
    	std::cout<<"Terminated since camera init failed";
    	return -1;
    }
    Mat edges;
    for(;;)
    {
        Mat frame;
        Mat momentMarkedFrame;

        cap >> frame; // get a new frame from camera
        Mat filteredFrame = filter_R_pass(frame);
        momentMarkedFrame = frame;
        imshow("Filtered", filteredFrame);


        /*
        Mat hsv;
        Mat hue;
        cvtColor( frame, hsv, CV_BGR2HSV );
        /// Use only the Hue value
         hue.create( hsv.size(), hsv.depth() );
         int ch[] = { 0, 0 };
         mixChannels( &hsv, 1, &hue, 1, ch, 1 );
         hist_backProject(20,hue);
*/

        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours( filteredFrame, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );


        Mat drawing = Mat::zeros( filteredFrame.size(), CV_8UC1 );
         for( int i = 0; i< contours.size(); i++ )
            {
        	 vector<Point> contour = contours.at(i);

        	 double cArea = contourArea(contour,false);
        	 if (cArea>1200){
        		 cout<<"Area "<<i<<" :"<<cArea<<endl;
        		 Scalar color = Scalar( rng.uniform(0, 255));

        		 //Find contours's moments
        		 Moments m = moments(contour);
        		 Point2f center = Point2f(m.m10/m.m00,m.m01/m.m00);
        		 circle(momentMarkedFrame,center,5,Scalar(200,200,0),1);
        		 imshow("momentMarkedFrame", momentMarkedFrame);
        		 drawContours( drawing, contours, i, color, 2, 8, hierarchy, 2, Point() );
        	 }


            }





         /// Show in a window
         namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
         imshow( "Contours", drawing );


        //cv::inRange(frame,Scalar(50,50,0),Scalar(60,60,255),redOnlyFrame);
        //cvtColor(frame, edges, COLOR_BGR2GRAY);
        //GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5);
        //Canny(edges, edges, 0, 30, 3);

        imshow("origin", frame);
        if(waitKey(30) >= 0) break;
    }


    // the camera will be deinitialized automatically in VideoCapture destructor
    return 0;
}
示例#10
0
bool handReader::bounding(Mat img, Mat skin){
	int max_radius = 0;
	Point2f max_circle;
	max_radius_index = 0;
	skinCenter.clear();
	threshold(img, img, 0, 255, THRESH_BINARY );
	findContours(img, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
	
	vector<vector<Point> > contours_poly( contours.size() );
	vector<Rect> boundRect( contours.size() );
	vector<Point2f>center( contours.size() );
	vector<float>radius( contours.size() );

	for( int i = 0; i < contours.size(); i++ )
	{ approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true );
	boundRect[i] = boundingRect( Mat(contours_poly[i]) );
	minEnclosingCircle( (Mat)contours_poly[i], center[i], radius[i] );
	}

	if(contours.size()==0)
		return false;
	/// Draw polygonal contour + bonding rects + circles
	//Mat drawing = Mat::zeros( img.size(), CV_8UC3 );
	for( int i = 0; i< contours.size(); i++ ){
		Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
		//drawContours( img, contours_poly, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
		//rectangle( img, boundRect[i].tl(), boundRect[i].br(), color, 2, 8, 0 );
		if((int)radius[i] > 5){
			//circle( img, center[i], (int)radius[i], color, 2, 8, 0 );
			for(int x = boundRect[i].tl().x; x < boundRect[i].br().x; x++){
				for(int y = boundRect[i].tl().y; y < boundRect[i].br().y; y++){
					if(x>=0 && x < img.rows && y >=0 && y < img.cols && skin.data[skin.step[0]*y + skin.step[1]*x + 0] == 255){
						img.data[img.step[0]*y + img.step[1]*x + 0] = 255;						
					}
				}
			}
			if(skin.data[skin.step[0]*(int(boundRect[i].tl().y+boundRect[i].br().y)/2) + skin.step[1]*(int(boundRect[i].tl().x+boundRect[i].br().x)/2) + 0] == 255){	
				skinCenter.push_back(center[i]);
				if((int)radius[i] > max_radius){
					max_radius = (int)radius[i];
					max_circle = center[i];
					//big_radius_v.push_back(center[i]);
				}
			}
		}
	}
	
	//cout<<skinCenter.size()<<endl;
	sort (skinCenter.begin(), skinCenter.end(), sortX);
	//sort (skinCenter.begin(), skinCenter.end(), sortY);
	if(skinCenter.size()!=0){
		//cout <<skinCenter.front().x<<":"<<skinCenter.back().x<<endl;
		
		//pathX.push_back(skinCenter);
		big_radius_v.push_back(max_circle);
		
		//max_radius_index.push_back(mri);
	}
	//cout<<img.rows<<endl;
	//cout<<img.cols<<endl;
	return true;
}
示例#11
0
namespace CvContour {

CvContour::CvContour(const std::string & name) :
    Base::Component(name)  {

}

CvContour::~CvContour() {
}

void CvContour::prepareInterface() {
    // Register handlers with their dependencies.
    registerHandler("onNewImage", boost::bind(&CvContour::onNewImage, this));
    addDependency("onNewImage", &in_img);

    // Input and output data streams.
    registerStream("in_img", &in_img);
    registerStream("out_contours", &out_contours);
    registerStream("out_img", &out_img);
}

bool CvContour::onInit() {

    return true;
}

bool CvContour::onFinish() {
    return true;
}

bool CvContour::onStop() {
    return true;
}

bool CvContour::onStart() {
    return true;
}

RNG rng(12345);

void CvContour::onNewImage()
{
    CLOG(LTRACE) << "CvContour::onNewImage\n";
    try {
        // Input: a binary or edge image.
        cv::Mat input = in_img.read();

        // Find contours.
        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours( input, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );

        /*		  /// Get the moments
        		  vector<Moments> mu(contours.size() );
        		  for( int i = 0; i < contours.size(); i++ )
        		     { mu[i] = moments( contours[i], false ); }

        		  ///  Get the mass centers:
        		  vector<Point2f> mc( contours.size() );
        		  for( int i = 0; i < contours.size(); i++ )
        		     { mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }*/

        CLOG(LINFO) << "Found "<< contours.size() << " contours";
        // Select only the external contour
        /*		if (contours.size() > 1)
        			contours.erase (contours.begin()+1,contours.end());*/


        /// Draw contours
        Mat drawing = Mat::zeros( input.size(), CV_8UC3 );
        for( int i = 0; i< contours.size(); i++ )
        {
            Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
            drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
//		       circle( drawing, mc[i], 4, color, -1, 8, 0 );
        }

        // Write contours to the output.
        out_contours.write(contours);
        out_img.write(drawing);
    } catch (...) {
        CLOG(LERROR) << "CvContour::onNewImage failed\n";
    }
}



} //: namespace CvContour
Mat mClustererCustomKMeans::_cluster(const Mat& descriptors)
{
	cout << "* Creating initial center points *" << endl;
	// start with random centers, choose from the set of points
	RNG rng;
	Mat center_points(Size(descriptors.cols,_getNumClusters()), descriptors.type());
	for(int i = 0; i < _getNumClusters(); i++)
	{
		int ridx = rng.uniform(0, descriptors.rows);
		//TODO alternative to use Mat::copyTo
		center_points.row(i) = descriptors.row(ridx) + Mat::zeros(Size(descriptors.row(ridx).cols, descriptors.row(ridx).rows), descriptors.type());
#ifdef DEBUG
		cout << " Center Point [" << i << "] " << center_points.row(i) << "; p " << ridx << endl;
#endif
	}

	Mat lastClusterCenters = center_points;

	do
	{
		lastClusterCenters = center_points;

		// get nearest points, store points
		cout << "* Grouping points in clusters *" << endl;
		vector<vector<Mat> > clusterd_points(_getNumClusters());
		for(int i = 0; i < descriptors.rows; i++)
		{
			// which cluster the point belongs to
			// get nearest cluster center to the point
			double minDist = 1000000;
			int nearestCluster = 0;
			for(int ic = 0; ic < _getNumClusters(); ic++)
			{
				double dist = Util::getSqDistance(descriptors.row(i), center_points.row(ic));
				if (dist < minDist)
				{
					minDist = dist;
					nearestCluster = ic;
				}
			}
			// store point in its corresponding cluster
			clusterd_points[nearestCluster].push_back(descriptors.row(i));
#ifdef DEBUG
			cout << " Added point " << descriptors.row(i) << " to cluster [" << nearestCluster << "]; Distance " << minDist << endl;
#endif
		}

		// recalculate cluster centers
		cout << "* Recalculate cluster centers *" << endl;
		for(unsigned int i = 0; i < clusterd_points.size(); i++)
		{
			Mat meanM = Util::getMean(clusterd_points[i]);
			center_points.row(i) = meanM + Mat::zeros(Size(meanM.cols, meanM.rows), meanM.type());
#ifdef DEBUG
			cout << " Update centre point [" << i << "] " << center_points.row(i) << endl;
#endif
		}

		cout << "* Checking end condition *" << endl;
#ifdef DEBUG
		cout << "Current center points " << center_points << endl << "Last center points " << lastClusterCenters << endl;
#endif
		// end if the centers stop changing
	} while(!Util::approximateEq(center_points, lastClusterCenters, 0.1));

	return center_points;
}
void AmericanOption::Pfadgenerieren(double** X, double** wdiff, int start,
		double * S) {
	for (int j = 0; j < D; ++j)
		X[start][j] = S[j];

//	if (PfadModell == GENERISCHE) {
//		for (int n = start + 1; n < N; ++n)
//			for (int d = 0; d < D; ++d)
//				X[n][d] = xi(wdiff[n][d]);
//	}

	if (PfadModell == ITO) {
		for (int n = start + 1; n < N; ++n)
			for (int d = 0; d < D; ++d)
				X[n][d] = X[n - 1][d]
						* exp(
								(((r - delta) - 0.5 * sigma[d] * sigma[d]) * dt
										+ sigma[d] * wdiff[n][d]));
		return;
	}

	if (PfadModell == LIBOREXP) {
		double wdiff[D];
		for (int n = start + 1; n < N; ++n) {

			double** zwischen = DoubleFeld(6, D);
			for (int d = 0; d < D; ++d)
				zwischen[0][d] = (X[n - 1][d]);
			double DDT = sqrt(dt / 5.);
			double RZWISCHEN[D];
			double GG[D];
			double G[D];
			static RNG generator;
			for (int schritt = 1; schritt < 6; schritt++) {
				for (int d = 0; d < DrivingFactors; ++d)
					wdiff[d] = DDT * generator.nextGaussian();
				double t = (double) (n - 1) * dt
						+ 0.05 * ((double) schritt - 0.5);
				zwischen[schritt][0] = log(S[0]);
				for (int d = 0; d < D; ++d) {
					RZWISCHEN[d] = (zwischen[schritt - 1][d]);
					G[d] = 0.2 * g((double) d * dt - t);
					GG[d] = pow(
							0.2
									* g(
											(double) (d + 1) * dt
													+ 0.05
															* ((double) schritt
																	- 0.5)), 2);
				}

				for (int i = n; i < D; ++i) {
					double driftsum = 0;
					for (int j = n; j <= i; ++j)
						driftsum += dt * RZWISCHEN[j] * G[i] * G[j]
								* corr[i - 1][j - 1] / (1. + dt * RZWISCHEN[j]);
					zwischen[schritt][i] = zwischen[schritt - 1][i]
							* exp(
									(driftsum - 0.5 * GG[i - n]) * 0.05
											+ G[i]
													* prod(chol[i - 1], wdiff,
															DrivingFactors));
				}
			}
			for (int d = 0; d < D; ++d) {
				X[n][d] = zwischen[5][d];
				if (d < n)
					X[n][d] = X[n - 1][d];
			}
			deleteDoubleFeld(zwischen, 6, D);
		}
	}

//	deleteDoubleFeld(wdiff, D);
	if (X[N - 1][0] < 0)
		printf("Error0\n");
//if(generator_noch_loeschen)delete generator;

}
示例#14
0
文件: igi.cpp 项目: bernstein/pbrt-v2
void IGIIntegrator::Preprocess(const Scene &scene, const Camera *camera,
                               const Renderer *renderer) {
    if (scene.lights.size() == 0) return;
    MemoryArena arena;
    RNG rng;
    // Compute samples for emitted rays from lights
    vector<float> lightNum(nLightPaths * nLightSets);
    vector<float> lightSampPos(2 * nLightPaths * nLightSets, 0.f);
    vector<float> lightSampComp(nLightPaths * nLightSets, 0.f);
    vector<float> lightSampDir(2 * nLightPaths * nLightSets, 0.f);
    LDShuffleScrambled1D(nLightPaths, nLightSets, &lightNum[0], rng);
    LDShuffleScrambled2D(nLightPaths, nLightSets, &lightSampPos[0], rng);
    LDShuffleScrambled1D(nLightPaths, nLightSets, &lightSampComp[0], rng);
    LDShuffleScrambled2D(nLightPaths, nLightSets, &lightSampDir[0], rng);

    // Precompute information for light sampling densities
    Distribution1D *lightDistribution = ComputeLightSamplingCDF(scene);
    for (uint32_t s = 0; s < nLightSets; ++s) {
        for (uint32_t i = 0; i < nLightPaths; ++i) {
            // Follow path _i_ from light to create virtual lights
            int sampOffset = s*nLightPaths + i;

            // Choose light source to trace virtual light path from
            float lightPdf;
            int ln = lightDistribution->SampleDiscrete(lightNum[sampOffset],
                                                       &lightPdf);
            Light *light = scene.lights[ln];

            // Sample ray leaving light source for virtual light path
            LightSample ls(lightSampPos[2*sampOffset], lightSampPos[2*sampOffset+1],
                           lightSampComp[sampOffset]);
            LightInfo2 li = light->Sample_L(scene, ls, lightSampDir[2*sampOffset],
                                             lightSampDir[2*sampOffset+1],
                                             camera->shutterOpen);
            RayDifferential ray(li.ray);
            Spectrum alpha(li.L);

            if (li.pdf == 0.f || alpha.IsBlack()) continue;
            alpha /= li.pdf * lightPdf;
            Intersection isect;
            auto optIsect = scene.Intersect(ray);
            while (optIsect && !alpha.IsBlack()) {
                // Create virtual light and sample new ray for path
                alpha *= renderer->Transmittance(scene, RayDifferential(ray), NULL,
                                                 rng, arena);
                Vector wo = -ray.d;
                BSDF *bsdf = optIsect->GetBSDF(ray, arena);

                // Create virtual light at ray intersection point
                Spectrum contrib = alpha * bsdf->rho(wo, rng) / M_PI;
                virtualLights[s].push_back(VirtualLight(optIsect->dg.p, optIsect->dg.nn, contrib,
                                                        optIsect->rayEpsilon));

                // Sample new ray direction and update weight for virtual light path
                Vector wi;
                float pdf;
                BSDFSample bsdfSample(rng);
                Spectrum fr = bsdf->Sample_f(wo, &wi, bsdfSample, &pdf);
                if (fr.IsBlack() || pdf == 0.f)
                    break;
                Spectrum contribScale = fr * AbsDot(wi, bsdf->dgShading.nn) / pdf;

                // Possibly terminate virtual light path with Russian roulette
                float rrProb = min(1.f, contribScale.y());
                if (rng.RandomFloat() > rrProb)
                    break;
                alpha *= contribScale / rrProb;
                ray = RayDifferential(optIsect->dg.p, wi, ray, optIsect->rayEpsilon);
                optIsect = scene.Intersect(ray);
            }
            arena.FreeAll();
        }
    }
    delete lightDistribution;
}
/** @function thresh_callback */
void thresh_callback(int, void* )
{
  Mat canny_output;
  vector<vector<Point> > contours;
  vector<Vec4i> hierarchy;
  
  /// Detect edges using canny
  Canny( src_gray, canny_output, thresh, thresh*2, 3 );
  /// Find contours
  findContours( canny_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
  
  // find rotated rectangles and ellipses for each contour
  vector<RotatedRect> minRect( contours.size() );
  vector<RotatedRect> minEllipse( contours.size() );
  vector<double> ratio( contours.size() );
  vector<double> size( contours.size() );
  
  for( int i = 0; i < contours.size(); i++ )
  { 
	minRect[i] = minAreaRect( Mat(contours[i]) );
  
  	if( contours[i].size() > contoursizelowbound )
	{ 
		minEllipse[i] = fitEllipse( Mat(contours[i]) );
  		cout<< "contour" << endl;
  		Point2f ellipse_points[4]; minEllipse[i].points( ellipse_points );
		double majorAxis = sqrt(pow(ellipse_points[0].x - ellipse_points[1].x,2) + pow(ellipse_points[0].y - ellipse_points[1].y,2));
		double minorAxis = sqrt(pow(ellipse_points[0].x - ellipse_points[3].x,2) + pow(ellipse_points[0].y - ellipse_points[3].y,2));
		ratio[i] = majorAxis/minorAxis;
		size[i] = majorAxis*minorAxis;
  
	  	//cout<< "ratio = " << ratio[i] << endl; 
	  	//cout<< "size = " << size[i] << endl; 
	}
  
  }
  
  /// Draw contours + rotated rects + ellipses
  Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
  Mat drawingContours = Mat::zeros( canny_output.size(), CV_8UC3 );
  Mat drawingCells;
  cvtColor( src, drawingCells, CV_GRAY2BGR );

  for( int i = 0; i< contours.size(); i++ )
  {
    Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
    drawContours( drawingContours, contours, i, color, 1, 8, hierarchy, 0, Point() );
    //if( ratio[i] > 2 )
    if( size[i] < 1000 && size[i] > 100 && ratio[i] < 6)
      
    {
      cout<< "ratio = " << ratio[i] << endl; 
      cout<< "size = " << size[i] << endl; 
      // Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
      drawContours( drawing, contours, i, color, 1, 8, hierarchy, 0, Point() );
      // ellipse
      ellipse( drawing, minEllipse[i], color, 1, 8 );
      // rotated rectangle
      //Point2f rect_points[4]; minRect[i].points( rect_points );
      //for( int j = 0; j < 4; j++ )
      //   line( drawing, rect_points[j], rect_points[(j+1)%4], color, 1, 8 );
      
      // Draw a line in center of ellipse (major axis over original)
      // Determine location of points of cell and store in  
      Point2f ellipse_points[4]; minEllipse[i].points( ellipse_points );
      Point2f midpt[2]; 
      midpt[0].x = (ellipse_points[0].x + ellipse_points[3].x)/2;
      midpt[0].y = (ellipse_points[0].y + ellipse_points[3].y)/2;
      midpt[1].x = (ellipse_points[1].x + ellipse_points[2].x)/2;
      midpt[1].y = (ellipse_points[1].y + ellipse_points[2].y)/2;
            
      // Point2f cellpts; cellpoints[
      line( drawingCells, midpt[0], midpt[1], color, 2,8);
      
      // Write position of cell in file
      // write coordinates for each cell's major axis as [x1 y1 x2 y2] 
      cellposn << midpt[0].x <<" "<< midpt[0].y << " " << midpt[1].x <<" " << midpt[1].y <<endl;

    }
  }
  
  /// Close textfile
  cellposn.close();
   
  
  
  /// Show in a window
  //namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
  //imshow( "Contours", drawing );
  
  // display Canny param and number of contours detected
  cout <<"Canny = " << thresh << endl;
  int numContours = contours.size();
  cout <<"numContours = " << numContours << endl;
  
  /// Show in a window
  namedWindow( "Filtered Contours", CV_WINDOW_AUTOSIZE );
  imshow( "Filtered Contours", drawing );
  namedWindow( "All Contours", CV_WINDOW_AUTOSIZE );
  imshow( "All Contours", drawingContours );
  namedWindow( "Cells", CV_WINDOW_AUTOSIZE );
  imshow( "Cells", drawingCells );
  
  imshow( "Source" , canny_output);
  


  /// save image;
  imwrite(IMAGE_PATH+filenamewrite, drawingCells);
  cout << "image write complete" << endl;  
}
示例#16
0
    // Tries to automatically detect the corner points of the go board
    // This function simply returns without modifying p0, .., p3 if the board couldn't be found
    void automatic_warp(const Mat& input, Point2f& p0, Point2f& p1, Point2f& p2, Point2f& p3)
    {
        // CONVERT TO HSV
        Mat imgHSV;
        cvtColor( input, imgHSV, CV_BGR2HSV );

        // SPLITTING CHANNELS
        vector<Mat> v_channel;
        split(imgHSV, v_channel);          //split into three channels

        // SELECT CHANNEL FOR FURTHER PROCEEDING: SATURATION
        auto& source_channel = v_channel[1];

        // SMOOTHING IMAGE
        medianBlur(source_channel, source_channel, 3);

        // BINARY THRESH THE IMAGE
        const auto threshold = cv::threshold(source_channel, source_channel, 0, 255, THRESH_BINARY | THRESH_OTSU);

        // FINDING CONTOURS
        Mat clone = source_channel.clone();
        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours(clone, contours, hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE, Point(0, 0));

        // STOP IF THERE AREN'T ANY CONTOURS
        if (contours.size() == 0)
            return;

        // APPROX. CONTOURS TO RECTANGLES
        const auto factor = .065f; // found through testing!
        for (auto& contour : contours) {
            // approximating each contour to get a rectangle with 4 points!
            approxPolyDP(Mat(contour), contour, arcLength(Mat(contour), true)*factor, true);
        }

        // CALCULATING BBOXES
        vector<Rect> bboxes;
        for (const auto& contour : contours)
            bboxes.push_back(boundingRect(contour));

        // CALCULATING MEAN BBOX AREA
        int bbox_area_sum = accumulate(begin(bboxes), end(bboxes), 0, [](int base, const Rect& r) { return base + r.area(); });
        int mean_area = bbox_area_sum/contours.size();

        // DELETING IMPROPER CONTOURS/BBOXES
        // that are smaller than the mean area
        // or almost as big as the whole image
        // or don't have exactly 4 corner points after approximation ( == rectangle)
        assert(bboxes.size() == contours.size());

        // for discarding contours that contain the complete image
        const float edge_factor = .99f;
        const float max_width   = input.cols * edge_factor;
        const float max_height  = input.rows * edge_factor;

        // DEBUG: DRAWING ALL LEFTOVER CONTOURS
        Mat drawing = input.clone();
        for (size_t i = 0; i < contours.size(); ++i) {
            Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255));
            drawContours(drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point());
        }

        // DEBUG: DRAWING BBOXES FOR ALL CONTOURS
        for(auto& rect : bboxes) {
            rectangle(drawing, rect.tl(), rect.br(), Scalar(255, 255, 255), 2, 8);
        }

        auto cont_it = begin(contours);
        auto bbox_it = begin(bboxes);
        while (cont_it != end(contours) && bbox_it != end(bboxes)) {
            auto& contour = *cont_it;
            auto& bbox = *bbox_it;
            const auto ar = bbox.area();

            // delete bboxes and its corresponding contour if the bbox is almost as large as the window
            if (bbox.width >= max_width && bbox.height >= max_height) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            // or if the bbox area is smaller than the mean area
            else if (bbox.area() <= mean_area) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            else if (contour.size() != 4) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            else {
                ++cont_it;
                ++bbox_it;
            }
        }

        // STOP IF WE DON'T HAVE ANY CONTOURS LEFT -> NO BOARD FOUND
        if (contours.size() == 0)
            return;

        // SELECTING SUITABLE CONTOUR
        // sort contours and bboxes by area
        // that means we're selecting biggest contour for further processing
        if (contours.size() > 1) {
            sort(begin(contours), end(contours),
                [](const vector<Point>& cont1, const vector<Point>& cont2) { return contourArea(cont1) > contourArea(cont2); }
            );
            sort(begin(bboxes), end(bboxes),
                [](const Rect& r1, const Rect& r2) { return r1.area() > r2.area(); }
            );
        }

        auto board_contour = contours.front();
        auto board_bbox    = bboxes.front();

        // GETTING CORNER POINTS OF CONTOUR

        // stop if the contour has left only 4 points after approximating
        if (board_contour.size() != 4)
            return;

        // Rectangle Order for warping: 
        // 0--------1
        // |        |
        // |        |
        // 2--------3

        auto center = Point(board_bbox.x + board_bbox.width/2, board_bbox.y + board_bbox.height/2);

        // splitting points in upper and lower half
        vector<Point> uppers, lowers;
        for (auto& point : board_contour) {
            if (point.y < center.y)
                uppers.emplace_back(point);
            else
                lowers.emplace_back(point);
        }

        // stop if we couldn't classify two uppers and lowers
        if (uppers.size() != 2 || lowers.size() != 2)
            return;

        // deciding which point is left/right
        // upper side
        p0 = uppers[0];
        p1 = uppers[1];
        if (p0.x > p1.x)
            swap(p0, p1);

        // lower side
        p2 = lowers[0];
        p3 = lowers[1];
        if (p2.x < p3.x)
            swap(p2, p3);
    }
示例#17
0
int main() {
	cout << "input block : ";
	char name;
	cin >> name;
	VideoCapture cap(0);
	if (!cap.isOpened())return 0;

	vector<Mat> RoiSet;
	Mat sub, draw_sub;
	vector<vector<Point> > contours;
	vector<Vec4i> hierarchy;
	Rect rect;
	Mat diff;
	uchar *myData;
	dis_feature dis_calcul;
	CircleFeature cir_calcul;
	cir_calcul.makeCircle();
	vector<int> vcir;
	Mat whiteBalance;
	int avr = 100;

	////////////////////////////////
	/*int hlow = 0, hhigh = 255;
	int slow = 0, shigh = 255;
	int vlow = 0, vhigh = 255;
	int canlow = 0, canhigh = 255;*/
	////////////////////////////////


	while (1) {
		while (1)//차영상 이용해서 break
		{
			Mat avrimg;

			cap >> avrimg;

			for (int i = 0; i < avr; i++) {
				cap >> img;
				//if (img.empty())goto out;
				resize(avrimg, avrimg, Size(), ratio, ratio);//이미지 리사이징
				getaccAvr(img, avrimg);//중첩영상 만들기
			}
			if (!flag) {
				whiteBalance = avrimg;
				flag = !flag;
				avr = 10;
			}//처음 한번만 밸런스 매트릭스를 만든다



			int height = 0, width = 0;
			int _stride = 0;
			float cnt1 = 0, wide = 0;
			Mat imgry, avrgry;


			imshow("balance_mat", whiteBalance);
			cvtColor(img, imgry, CV_BGR2GRAY);
			cvtColor(avrimg, avrgry, CV_BGR2GRAY);
			absdiff(imgry, avrgry, diff);

			threshold(diff, diff, 20, 255, THRESH_BINARY);

			//imshow("diff", diff);
			height = diff.rows;
			width = diff.cols;
			wide = height*width;
			_stride = diff.step;
			myData = diff.data;
			for (int i = 0; i < height; i++)
			{
				for (int j = 0; j < width; j++)
				{
					uchar val = myData[i * _stride + j];
					if (val)cnt1++;
				}
			}
			//cout << cnt1 << " " << wide << " " << cnt1 / wide << endl;
			if (cnt1 / wide < 0.01) {
				avrimg.copyTo(img);
				break;
			}
			if (waitKey(1) == 27)goto out;
		}
		Mat temp;
		cv::scaleAdd(whiteBalance, -0.1, img, img);
		absdiff(whiteBalance, img, img);
		imshow("balance img", img);

		////////////////////////trackbar//////////////////////
		/*namedWindow("track", 1);
		createTrackbar("Hlow_value", "track", &canlow, 255);
		createTrackbar("Hhigh_value", "track", &canhigh, 255);
		createTrackbar("Slow_value", "track", &slow, 255);
		createTrackbar("Shigh_value", "track", &shigh, 255);
		createTrackbar("Vlow_value", "track", &vlow, 255);
		createTrackbar("Vhigh_value", "track", &vhigh, 255);*/
		//////////////////////////////////////////////////////

		img.copyTo(sub);

		GaussianBlur(img, img, Size(3, 3), 0.8);
		//cvtColor(img, img, COLOR_BGR2HSV);
		//inRange(img, Scalar(hlow, slow, vlow), Scalar(hhigh, shigh, vhigh), img);
		//cvtColor(img, img, COLOR_BGR2GRAY);
		Canny(img, temp, 30, 200);

		//threshold(~img, img, 100, 255, THRESH_BINARY);

		findContours(temp, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));

		draw_sub = Mat::zeros(temp.size(), CV_8UC3);
		vector<Point> approxShape;
		for (size_t i = 0; i < contours.size(); i++) {
			approxPolyDP(contours[i], approxShape, arcLength(Mat(contours[i]), true)*0.04, true);
			drawContours(draw_sub, contours, i, Scalar(255, 255, 255), CV_FILLED);
		}
		imshow("draw_sub", draw_sub);
		Canny(draw_sub, temp, 0, 255);
		imshow("temp2", temp);
		findContours(temp, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
		/*Mat temp_;
		Mat element = getStructuringElement(cv::MORPH_GRADIENT,
		cv::Size(3, 3),
		cv::Point(3, 3));
		draw_sub.copyTo(temp_);
		erode(temp_, temp_, element);
		absdiff(draw_sub, temp_, draw_sub);
		findContours(draw_sub, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
		*/

		vector<RotatedRect> minRect(contours.size());
		vector<RotatedRect> minEllipse(contours.size());

		setMouseCallback("src", CallBackFunc, NULL);

		RoiSet.clear();
		for (int i = 0; i < contours.size(); i++) {
			minRect[i] = minAreaRect(Mat(contours[i]));
			if (contours[i].size()>5) {
				minEllipse[i] = fitEllipse(Mat(contours[i]));
			}
		}
		int j = 0;
		vector<float> width_length;
		vector<location> loc;
		vector<Point2f> cen_for_loc;
		system("cls");
		for (int i = 0; i < contours.size(); i++) {

			Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
			width_length.clear();
			float div = 0;
			Point2f rect_point[4];
			Point2f center;
			minRect[i].points(rect_point);
			Mat M, rotated;
			location tmp;
			float angle = minRect[i].angle;
			Size Rrect_size = minRect[i].size;

			if (minRect[i].angle < -45.) {
				angle += 90.0;
				swap(Rrect_size.width, Rrect_size.height);
			}

			M = getRotationMatrix2D(minRect[i].center, angle, 1.0);
			warpAffine(draw_sub, rotated, M, draw_sub.size(), INTER_CUBIC);
			getRectSubPix(rotated, Rrect_size, minRect[i].center, rotated);
			char num[10];
			sprintf(num, "#%d img", j);

			for (int j = 0; j < 4; j++) {
				width_length.push_back(dis_calcul.point_dist(rect_point[j], rect_point[(j + 1) % 4]));
			}
			div = width_length[0] < width_length[1] ? width_length[0] / width_length[1] : width_length[1] / width_length[0];

			if ((rotated.cols * rotated.rows>2000))//&& (div>0.5))// && (div < 0.9))
			{
				for (int j = 0; j < 4; j++) {
					line(sub, rect_point[j], rect_point[(j + 1) % 4], Scalar(255, 0, 0));
					center.x += rect_point[j].x;
					center.y += rect_point[j].y;
				}
				center.x /= 4;
				cvtColor(rotated, rotated, COLOR_BGR2HSV);
				inRange(rotated, Scalar(0, 0, 0), Scalar(255, 255, 125), rotated);
				//imshow("rotated", rotated);
				//rotated = ~rotated;

				//cout << num << " : " << dis_calcul.dev_from_mat(rotated) << endl;
				cir_calcul.CircleByMat(rotated);
				cir_calcul.rtFullCirnum(rotated, vcir);
				vcir.clear();

				tmp.set_pt(center);
				cen_for_loc.push_back(center);
				///////
				//class에 값 집어넣는 과정
				char decided = decision_making(name,rotated);
				
				tmp.set_data(decided);
				///////
				loc.push_back(tmp);

				imshow(num, rotated);

				cout << num << "::" << decided << endl;
				j++;
			}

		}

		for (int k = 0; k < loc.size(); k++) {
			loc[k].set_rnk(get_rnk_pt(cen_for_loc));

		}
		print_loc(sub, get_rnk_pt(cen_for_loc));
		//imshow("img", img);
		imshow("src", sub);

		if (waitKey(5) == 27)break;
	}
out:
	destroyAllWindows();
	return 0;
}
示例#18
0
namespace Go_Scanner {

    const char* thresh_window = "Thresh";
    const char* morph_window = "Morph";
    bool asked_for_board_contour = false;

    using namespace cv;
    using namespace std;


    //point coordinates
    int boardCornerX[]={80, 443, 460, 157};    
    int boardCornerY[]={80, 87, 430, 325};
    Mat img0, selectedImg, temp;
    string windowName = "Manual Selection Window";

    int board_selection_cancel_key = 27;

    // split a string at each char that is contained in delimiters and return the tokens
    vector<string> split(const string& str, const string& delimiters)
    {
        // Skip delimiters at beginning.
        string::size_type lastPos = str.find_first_not_of(delimiters, 0);
        // Find first "non-delimiter".
        string::size_type pos     = str.find_first_of(delimiters, lastPos);

        vector<string> tokens;
        while (string::npos != pos || string::npos != lastPos)
        {
            // Found a token, add it to the vector.
            tokens.push_back(str.substr(lastPos, pos - lastPos));
            // Skip delimiters.  Note the "not_of"
            lastPos = str.find_first_not_of(delimiters, pos);
            // Find next "non-delimiter"
            pos = str.find_first_of(delimiters, lastPos);
        }

        return tokens;
    }

    // renders a text in img with text at position
    // automatically handels newlines
    void putText(Mat img, string text, Point position) {
        // text appearence
        int fontFace     = 1;
        double fontScale = 1.2;
        int thickness    = 1;
        int baseline     = 0;
        int offset_x = 1, offset_y = 3;

        // text size of one line
        Size textSize = getTextSize(text, fontFace, fontScale, thickness, &baseline);
        baseline += thickness;

        auto total_height = textSize.height + baseline + 1;

        auto lines = split(text, "\n");

        // recurse if we got more than one line
        // and put each line directly under the preceding
        if (lines.size() > 1) {
            int i = 0;
            for (const auto& line : lines) {
                putText(img, line, position + Point(0, i*total_height));
                ++i;
            }
            return;
        }

        // buffer for the transparent box under the text (achieved through blending the images)
        Mat box_buf = img.clone();

        // draw the solid box
        rectangle(box_buf, position + Point(0, baseline),
            position + Point(textSize.width, -textSize.height),
            Scalar(0, 0, 0),
            CV_FILLED);

        // blend the box to make it transparent
        auto alpha = .3f;
        addWeighted(box_buf, alpha, img, 1.0 - alpha, 0.0, img);

        // draw the baseline
        line(img, position + Point(0, thickness + offset_y),
            position + Point(textSize.width, thickness + offset_y),
            Scalar(0, 0, 255));

        // draw the actual text
        putText(img, text, 
                    position + Point(offset_x, offset_y),            // position
                    fontFace,            // font face
                    fontScale,           // font scale
                    Scalar(64, 64, 255), // color
                    thickness,           // thickness
                    CV_AA);              // line type
    }

     /**
     * @brief   Calls the manual board detection and shows the result in a new window.
     */
    void ask_for_board_contour() {
        namedWindow(windowName, CV_WINDOW_AUTOSIZE);
        setMouseCallback(windowName, mouseHandler, NULL);
        putText(img0,
            "Mark the Go board with the blue rectangle\n"
            "Press ESC to cancel or any other key to accept.",
            cvPoint(10, 20));

        showImage();
        auto key = waitKey(0);
        destroyWindow(windowName);

        // only accept board selection if the ESCAPE key was NOT pressed!
        if (key != board_selection_cancel_key)
            asked_for_board_contour = true;
    }

    /**
     * @brief   Calls the automatic board detection and shows the result in a new window.
     *          Prints an error to the console if the automatic detection couldn't find anything.
     */
    void do_auto_board_detection() {
        Point2f p0, p1, p2, p3;
        automatic_warp(img0, p0, p1, p2, p3);

        // automatic_warp failed and board wasn't found
        // if one of the points wasn't set
        if (p0 == Point2f()) {
            cout << "!!ERROR >> Failed to automatically detect the go board!" << endl;
            ask_for_board_contour();
            return;
        }

        // HACK: adjust the coordinates a bit to snap them closer to the board grid
        const auto gap = .5f;
        p0 += Point2f(gap, gap);
        p1 += Point2f(-gap, gap);
        p2 += Point2f(-gap, -gap);
        p3 += Point2f(gap, -gap);

        // create data suitable for showImage()
        int board_corners_X[] = { (int)p0.x, (int)p1.x, (int)p2.x, (int)p3.x };
        int board_corners_Y[] = { (int)p0.y, (int)p1.y, (int)p2.y, (int)p3.y };

        namedWindow(windowName, CV_WINDOW_AUTOSIZE);
        putText(img0,
            "Result of automatically detecting the Go board.\n"
            "Press ESC to cancel or any other key to accept.",
            cvPoint(10, 20));

        showImage(board_corners_X, board_corners_Y);
        auto key = waitKey(0);
        destroyWindow(windowName);

        // only accept board selection if the ESCAPE key was NOT pressed!
        if (key != board_selection_cancel_key) {
            asked_for_board_contour = true;

            // actually commmit the selection to the internal used variables
            boardCornerX[0] = cvRound(p0.x);
            boardCornerX[1] = cvRound(p1.x);
            boardCornerX[2] = cvRound(p2.x);
            boardCornerX[3] = cvRound(p3.x);

            boardCornerY[0] = cvRound(p0.y);
            boardCornerY[1] = cvRound(p1.y);
            boardCornerY[2] = cvRound(p2.y);
            boardCornerY[3] = cvRound(p3.y);
        }
    }

    Mat warpImage(Mat img, Point2f p0, Point2f p1, Point2f p2, Point2f p3)
    {
        /*
        Rectangle Order: 
        0-------1
        |        |
        |        |
        2-------3
        */
        Point2f selCorners[4];        
        selCorners[0] = p0;
        selCorners[1] = p1;
        selCorners[2] = p2;
        selCorners[3] = p3;

        Point2f dstCorners[4]; 
        dstCorners[0] = Point2f(0.0, 0.0);
        dstCorners[1] = Point2f((float)img.cols, 0.0);
        dstCorners[2] = Point2f(0.0, (float)img.rows);
        dstCorners[3] = Point2f((float)img.cols, (float)img.rows);

        Mat transformationMatrix;
        transformationMatrix = getPerspectiveTransform(selCorners, dstCorners);

        Mat warpedImg;
        warpPerspective(img, warpedImg, transformationMatrix, warpedImg.size(), 1, 0 ,0);

        return warpedImg;
    }


    RNG rng(12345);

    // Tries to automatically detect the corner points of the go board
    // This function simply returns without modifying p0, .., p3 if the board couldn't be found
    void automatic_warp(const Mat& input, Point2f& p0, Point2f& p1, Point2f& p2, Point2f& p3)
    {
        // CONVERT TO HSV
        Mat imgHSV;
        cvtColor( input, imgHSV, CV_BGR2HSV );

        // SPLITTING CHANNELS
        vector<Mat> v_channel;
        split(imgHSV, v_channel);          //split into three channels

        // SELECT CHANNEL FOR FURTHER PROCEEDING: SATURATION
        auto& source_channel = v_channel[1];

        // SMOOTHING IMAGE
        medianBlur(source_channel, source_channel, 3);

        // BINARY THRESH THE IMAGE
        const auto threshold = cv::threshold(source_channel, source_channel, 0, 255, THRESH_BINARY | THRESH_OTSU);

        // FINDING CONTOURS
        Mat clone = source_channel.clone();
        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours(clone, contours, hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE, Point(0, 0));

        // STOP IF THERE AREN'T ANY CONTOURS
        if (contours.size() == 0)
            return;

        // APPROX. CONTOURS TO RECTANGLES
        const auto factor = .065f; // found through testing!
        for (auto& contour : contours) {
            // approximating each contour to get a rectangle with 4 points!
            approxPolyDP(Mat(contour), contour, arcLength(Mat(contour), true)*factor, true);
        }

        // CALCULATING BBOXES
        vector<Rect> bboxes;
        for (const auto& contour : contours)
            bboxes.push_back(boundingRect(contour));

        // CALCULATING MEAN BBOX AREA
        int bbox_area_sum = accumulate(begin(bboxes), end(bboxes), 0, [](int base, const Rect& r) { return base + r.area(); });
        int mean_area = bbox_area_sum/contours.size();

        // DELETING IMPROPER CONTOURS/BBOXES
        // that are smaller than the mean area
        // or almost as big as the whole image
        // or don't have exactly 4 corner points after approximation ( == rectangle)
        assert(bboxes.size() == contours.size());

        // for discarding contours that contain the complete image
        const float edge_factor = .99f;
        const float max_width   = input.cols * edge_factor;
        const float max_height  = input.rows * edge_factor;

        // DEBUG: DRAWING ALL LEFTOVER CONTOURS
        Mat drawing = input.clone();
        for (size_t i = 0; i < contours.size(); ++i) {
            Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255));
            drawContours(drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point());
        }

        // DEBUG: DRAWING BBOXES FOR ALL CONTOURS
        for(auto& rect : bboxes) {
            rectangle(drawing, rect.tl(), rect.br(), Scalar(255, 255, 255), 2, 8);
        }

        auto cont_it = begin(contours);
        auto bbox_it = begin(bboxes);
        while (cont_it != end(contours) && bbox_it != end(bboxes)) {
            auto& contour = *cont_it;
            auto& bbox = *bbox_it;
            const auto ar = bbox.area();

            // delete bboxes and its corresponding contour if the bbox is almost as large as the window
            if (bbox.width >= max_width && bbox.height >= max_height) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            // or if the bbox area is smaller than the mean area
            else if (bbox.area() <= mean_area) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            else if (contour.size() != 4) {
                cont_it = contours.erase(cont_it);
                bbox_it = bboxes.erase(bbox_it);
            }
            else {
                ++cont_it;
                ++bbox_it;
            }
        }

        // STOP IF WE DON'T HAVE ANY CONTOURS LEFT -> NO BOARD FOUND
        if (contours.size() == 0)
            return;

        // SELECTING SUITABLE CONTOUR
        // sort contours and bboxes by area
        // that means we're selecting biggest contour for further processing
        if (contours.size() > 1) {
            sort(begin(contours), end(contours),
                [](const vector<Point>& cont1, const vector<Point>& cont2) { return contourArea(cont1) > contourArea(cont2); }
            );
            sort(begin(bboxes), end(bboxes),
                [](const Rect& r1, const Rect& r2) { return r1.area() > r2.area(); }
            );
        }

        auto board_contour = contours.front();
        auto board_bbox    = bboxes.front();

        // GETTING CORNER POINTS OF CONTOUR

        // stop if the contour has left only 4 points after approximating
        if (board_contour.size() != 4)
            return;

        // Rectangle Order for warping: 
        // 0--------1
        // |        |
        // |        |
        // 2--------3

        auto center = Point(board_bbox.x + board_bbox.width/2, board_bbox.y + board_bbox.height/2);

        // splitting points in upper and lower half
        vector<Point> uppers, lowers;
        for (auto& point : board_contour) {
            if (point.y < center.y)
                uppers.emplace_back(point);
            else
                lowers.emplace_back(point);
        }

        // stop if we couldn't classify two uppers and lowers
        if (uppers.size() != 2 || lowers.size() != 2)
            return;

        // deciding which point is left/right
        // upper side
        p0 = uppers[0];
        p1 = uppers[1];
        if (p0.x > p1.x)
            swap(p0, p1);

        // lower side
        p2 = lowers[0];
        p3 = lowers[1];
        if (p2.x < p3.x)
            swap(p2, p3);
    }


//Manual detection

    /*

    Rectangle Order: 
    0-------1
    |        |
    |        |
    3-------2

    */

    int point=-1;            //currently selected point
    int nop=4;               //number of points


    void mouseHandler(int event, int x, int y, int flags, void *param)
    {

        switch(event) 
        {
        case CV_EVENT_LBUTTONDOWN:        
            selectedImg = holdImg(x, y);
            break;

        case CV_EVENT_LBUTTONUP:    
            if((selectedImg.empty()!= true)&& point!=-1)
            {
                releaseImg(selectedImg,x,y);
                selectedImg=Mat();
            }
            break;

        //Draws the lines while navigating with the mouse
        case CV_EVENT_MOUSEMOVE:
            /* draw a rectangle*/
            if(point!=-1)
            {
                if(selectedImg.empty()!= true)
                {
                    temp = selectedImg.clone();
                    rectangle(temp, 
                        Point(x - 10, y - 10), 
                        Point(x + 10, y + 10), 
                        //BGR not RGB!!
                        Scalar(0, 255, 0, 0), 2, 8, 0);

                    //adjust the lines
                    for(int i=0;i<nop;i++)
                    {
                        if(i!=point)
                        {
                            line(temp,
                                Point(x, y), 
                                Point(boardCornerX[i] , boardCornerY[i] ), 
                                Scalar(0, 255, 0 ,0), 1,8,0);
                        }
                    }
                    imshow(windowName, temp); 
                }
                break;
            }
            temp = Mat();
        }
    }

    //draws the lines and points while holding left mouse button down
    Mat holdImg(int x, int y)
    {
        Mat img = img0;

        int radius = 4;
        //find what point is selected
        for(int i=0;i<nop;i++){
            if((x>=(boardCornerX[i]-radius)) && (x<=(boardCornerX[i]+radius ))&& (y<=(boardCornerY[i]+radius ))&& (y<=(boardCornerY[i]+radius ))){
                point=i;
                break;
            }

        }
        //draw points
        for(int j=0;j<nop;j++)
        {
            //if this is not the selected point
            if(j!=point)
            {
                img = img.clone();
                rectangle(img, 
                    Point(boardCornerX[j] - 1, boardCornerY[j] - 1), 
                    Point(boardCornerX[j] + 1, boardCornerY[j] + 1), 
                    Scalar(255, 0,  0, 0), 2, 8, 0);
            }
        }

        //draw lines
        for(int i=0;i<nop;i++)
        {
            if(i!=point)
            {
                for(int k=i+1;k<nop;k++)
                {
                    if(k!=point)
                    {
                        img = img.clone();
                        line(img,
                            Point(boardCornerX[i] , boardCornerY[i] ), 
                            Point(boardCornerX[k] , boardCornerY[k] ), 
                            Scalar(255, 0, 0, 0), 1,8,0);

                    }
                }
            }
        }
        return img;
    }

    //set new coordinates and redraw the scene if the left mouse button is released
    void releaseImg(Mat a, int x, int y)
    {
        boardCornerX[point]=x;
        boardCornerY[point]=y;
        showImage();
    }

    /**
     * @brief   Shows the points given through the two passed parameters on a clone of the img0 in a new window.
     *          Both pointers have to point to memory containing 4 variables
     */
    void showImage(int* board_corner_X, int* board_corner_Y)
    {
        Mat img1 = img0.clone();

        //draw the points
        for(int j=0;j<nop;j++)
        {        
            rectangle(img1, 
                Point(board_corner_X[j] - 1, board_corner_Y[j] - 1), 
                Point(board_corner_X[j] + 1, board_corner_Y[j] + 1), 
                Scalar(255, 0,  0, 0), 2, 8, 0);


            //draw the lines
            for(int k=j+1;k<nop;k++)
            {
                line(img1,
                    Point(board_corner_X[j] , board_corner_Y[j] ), 
                    Point(board_corner_X[k] , board_corner_Y[k] ), 
                    Scalar(255, 0,  0, 0), 1,8,0);
            }
        }
        imshow(windowName, img1);
    }

    /**
     * @brief   Shows the selected points (through manual or automatic board detection) on a clone of the img0 in a new window.
     */
    void showImage()
    {
        showImage(boardCornerX, boardCornerY);
    }

    bool getWarpedImg(Mat& warpedImg)
    {
        img0 = warpedImg.clone();

        // only process the image if the user  selected the board with "ask_for_board_contour" or "do_auto_board_detection" once.
        // this is triggered through the GUI (and the Scanners selectBoardManually() and selectBoardAutomatically() methods)
        if (!asked_for_board_contour) {
            return false;
        }
    
            warpedImg = warpImage(img0,
            Point2i(boardCornerX[0], boardCornerY[0]),
            Point2i(boardCornerX[1], boardCornerY[1]),
            Point2i(boardCornerX[3], boardCornerY[3]),
            Point2i(boardCornerX[2], boardCornerY[2]));       

        return true;

    }
}
示例#19
0
int _tmain(int argc, _TCHAR* argv[])
{
	VideoCapture cap(0); // open the video camera no. 0

	if (!cap.isOpened())  // if not success, exit program
	{
		cout << "Cannot open the video cam" << endl;
		return -1;
	}

	double dWidth = cap.get(CV_CAP_PROP_FRAME_WIDTH); //get the width of frames of the video
	double dHeight = cap.get(CV_CAP_PROP_FRAME_HEIGHT); //get the height of frames of the video

	cout << "Frame size : " << dWidth << " x " << dHeight << endl;

	// namedWindow("BlackWhite", CV_WINDOW_AUTOSIZE);
	namedWindow("Gray", CV_WINDOW_AUTOSIZE);
	namedWindow("Blur", CV_WINDOW_AUTOSIZE);
	namedWindow("BlackWhite", CV_WINDOW_AUTOSIZE);
	namedWindow("Canny", CV_WINDOW_AUTOSIZE);
	namedWindow("FindContours", CV_WINDOW_AUTOSIZE);
	namedWindow("Result", CV_WINDOW_AUTOSIZE);

	while (1)
	{
		Mat frame;

		bool bSuccess = cap.read(frame); // read a new frame from video

		if (!bSuccess) //if not success, break loop
		{
			cout << "Cannot read a frame from video stream" << endl;
			break;
		}

		// process
		Mat frameGray;
		Mat frameBlur;
		Mat frameBlackWhite;
		Mat frameCanny;

		Mat frameGrayResize;
		Mat frameBlurResize;
		Mat frameBlackWhiteResize;
		Mat frameCannyResize;

		cvtColor(frame, frameGray, CV_BGR2GRAY);
		blur(frameGray, frameBlur, Size(9, 9));
		threshold(frameBlur, frameBlackWhite, 80, 255, THRESH_BINARY);

		// calcul de l'air (calculer le nombre de pixels blancs)

		// imshow("BlackWhite", frameGray);

		vector<vector<Point> > contours;
		vector<Vec4i> hierarchy;

		Canny(frameBlackWhite, frameCanny, thresh, thresh * 2, 3);

		findContours(frameCanny, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));

		int index = 0;
		vector<Point> bestContour;
		int perimeter = getPerimeter(contours, index, bestContour);
		int xmin = INT_MAX, xmax = -INT_MAX, ymin = INT_MAX, ymax = -INT_MAX;
		getHandArea(bestContour, xmin, xmax, ymin, ymax);
		int area = getArea(xmin, xmax, ymin, ymax, frameBlackWhite);

		// rapport aire / périmètre
		double rap1 = (double)area / (double)((xmax - xmin) * (ymax - ymin) - area);
		double rap2 = (double)area / (double)perimeter;

		// std::cout << perimeter << std::endl;

		// cout << "contours size: " << contours.size() << endl;
		Mat frameFindContours = Mat::zeros(frameCanny.size(), CV_8UC3);
		Mat drawing = Mat::zeros(frameCanny.size(), CV_8UC3);
		
		Mat frameFindContoursResize;
		Mat drawingResize;

		for( int i = 0; i< contours.size(); i++ )
	    {
			Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255));
			drawContours(frameFindContours, contours, i, color, 2, 8, hierarchy, 0, Point());
        }
		
		// Scalar color = Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255));
		Scalar color = Scalar(200, 200, 250);
		drawContours(drawing, contours, index, color, 2, 8, hierarchy, 0, Point());

		double rapF = rap1 * rap2;

		displayText("Perimeter = " + std::to_string(perimeter), 10, 20, drawing);
		displayText("Area = " + std::to_string(area), 10, 50, drawing);
		displayText("Rapport pixel blanc noir = " + std::to_string(rap1), 10, 80, drawing);
		displayText("Rapport perimeter area = " + std::to_string(rap2), 10, 110, drawing);
		displayText("Rapport final = " + std::to_string(rapF), 10, 140, drawing);
		displayText("Result = " + getResult(rapF, rap1), 10, 170, drawing);

		rectangle(drawing, cvPoint(xmin, ymin), cvPoint(xmax, ymax), cvScalar(255, 0, 0));

		// resize
		// old 640x480
		// new 320x240 or 160x120
		Size newSize = Size(500, 340);

		resize(frameGray, frameGrayResize, newSize);
		resize(frameBlur, frameBlurResize, newSize);
		resize(frameBlackWhite, frameBlackWhiteResize, newSize);
		resize(frameCanny, frameCannyResize, newSize);
		resize(frameFindContours, frameFindContoursResize, newSize);
		resize(drawing, drawingResize, newSize);

		imshow("Gray", frameGrayResize);
		imshow("Blur", frameBlurResize);
		imshow("BlackWhite", frameBlackWhiteResize);
		imshow("Canny", frameCannyResize);
		imshow("FindContours", frameFindContoursResize);
		imshow("Result", drawingResize);

		int offsetX = newSize.width + 30;
		int offsetY = newSize.height + 50;

		moveWindow("Gray", 0, 0);
		moveWindow("Blur", offsetX, 0);
		moveWindow("BlackWhite", 2 * offsetX, 0);
		moveWindow("Canny", 0, offsetY);
		moveWindow("FindContours", offsetX, offsetY);
		moveWindow("Result", 2 * offsetX, offsetY);

		if (waitKey(30) == 27)
		{
			cout << "esc key is pressed by user" << endl;
			break;
		}
	}
	return 0;
}
示例#20
0
void StateSet::init_to_gaussian_noise(RNG& rng) {
	for (size_t n=0; n<N; n++)
		for (size_t y=0; y<datalayout.sizey; y++)
			for (size_t x=0; x<datalayout.sizex; x++)
				data(n,x,y) = comp(rng.gaussian_rand(), rng.gaussian_rand());
}
示例#21
0
void VolumePatIntegrator::EyeRandomWalk(const Scene *scene, const Ray &eyeRay,
        VolumeVertexList& vertexList, RNG &rng) const {
    // Do a random walk for the eye ray in the volume
    Spectrum cummulative(1.f);

    // Find the intersection between the eye ray and the volume
    VolumeRegion *vr = scene->volumeRegion;
    float t0, t1;
    if (!vr || !vr->IntersectP(eyeRay, &t0, &t1) || (t1-t0) == 0.f || t0 < 0.f) {
        return;
    }

    // Find the intersection point between the sampled light ray and the volume
    RayDifferential ray(eyeRay);
    Point p = ray(t0), pPrev;
    uint64_t bounces = 0;
    while(vr->WorldBound().Inside(p)) {
        Vector wi = -ray.d;
        const Spectrum sigma_a = vr->Sigma_a(p, wi, eyeRay.time);
        const Spectrum sigma_s = vr->Sigma_s(p, wi, eyeRay.time);
        const Spectrum STER = vr->STER(p, wi, eyeRay.time);
        // Construct and add the _eyeVertex_ to the _vertexList_
        VolumeVertex eyeVertex(p, wi, sigma_a, sigma_s, cummulative, 1.0);
        vertexList.push_back(eyeVertex);

        // Sample the direction of the next event
        float directionPdf = 1.f;
        Vector wo;
        if(STER.y() > rng.RandomFloat()) {
            // Change the ray direction due to a scattering event at _p_
            if(!vr->SampleDirection(p, wi, wo, &directionPdf, rng)) {
                break; // Direction error
            }

            // Account for the losses due to the scattering event at _p_
            cummulative *= sigma_s * vr->p(p, wi, wo, ray.time);
        } else {
            // Account only for the trnsmittance between the previous and the
            // next events becuse there is no direction change.
            wo = ray.d;
        }

        // Sample the distance of the next event
        ray = RayDifferential(p, wo, 0, INFINITY);

        float tDist;
        float distancePdf = 1.f;
        Point Psample;
        if(!vr->SampleDistance(ray, &tDist, Psample, &distancePdf, rng)) {
            break; // The sampled point is outside the volume
        }

        // Account for the sampling Pdfs from sampling a direction and/or distance
        const float pdf = distancePdf * directionPdf;
        cummulative *= 1 / pdf;

        // Update the events and account for the transmittance between the events
        pPrev = p;
        p = Psample;
        const Ray tauRay(pPrev, p - pPrev, 0.f, 1.f, ray.time, ray.depth);
        const Spectrum stepTau = vr->tau(tauRay, .5f * stepSize, rng.RandomFloat());
        const Spectrum TrPP = Exp(-stepTau);
        cummulative *= TrPP;

        // Possibly terminate ray marching if _cummulative_ is small
        if (cummulative.y() < 1e-3) {
            const float continueProb = .5f;
            if (rng.RandomFloat() > continueProb) {
                cummulative = 0.f;
                break;
            }
            cummulative /= continueProb;
        }

        // Terminate if bounces are more than requested
        bounces++;
        if (bounces > maxDepth) {
            break;
        }
    }
}
示例#22
0
TEST_P(Eltwise, Accuracy)
{
    Vec3i inSize = get<0>(GetParam());
    std::string op = get<1>(GetParam());
    int numConv = get<2>(GetParam());
    bool weighted = get<3>(GetParam());

    Net net;

    std::vector<int> convLayerIds(numConv);
    for (int i = 0; i < numConv; ++i)
    {
        Mat weights({inSize[0], inSize[0], 1, 1}, CV_32F);
        randu(weights, -1.0f, 1.0f);

        LayerParams convParam;
        convParam.set("kernel_w", 1);
        convParam.set("kernel_h", 1);
        convParam.set("num_output", inSize[0]);
        convParam.set("bias_term", false);
        convParam.type = "Convolution";
        std::ostringstream ss;
        ss << "convLayer" << i;
        convParam.name = ss.str();
        convParam.blobs.push_back(weights);

        convLayerIds[i] = net.addLayer(convParam.name, convParam.type, convParam);
        net.connect(0, 0, convLayerIds[i], 0);
    }

    LayerParams eltwiseParam;
    eltwiseParam.set("operation", op);
    if (op == "sum" && weighted)
    {
        RNG rng = cv::theRNG();
        std::vector<float> coeff(1 + numConv);
        for (int i = 0; i < coeff.size(); ++i)
        {
            coeff[i] = rng.uniform(-2.0f, 2.0f);
        }
        eltwiseParam.set("coeff", DictValue::arrayReal<float*>(&coeff[0], coeff.size()));
    }
    eltwiseParam.type = "Eltwise";
    eltwiseParam.name = "testLayer";
    int eltwiseId = net.addLayer(eltwiseParam.name, eltwiseParam.type, eltwiseParam);
    net.connect(0, 0, eltwiseId, 0);
    for (int i = 0; i < numConv; ++i)
    {
        net.connect(convLayerIds[i], 0, eltwiseId, i + 1);
    }

    Mat input({1, inSize[0], inSize[1], inSize[2]}, CV_32F);
    randu(input, -1.0f, 1.0f);

    net.setInput(input);
    Mat outputDefault = net.forward(eltwiseParam.name).clone();

    net.setPreferableBackend(DNN_BACKEND_HALIDE);
    Mat outputHalide = net.forward(eltwiseParam.name).clone();
    normAssert(outputDefault, outputHalide);
}
示例#23
0
文件: pSBL.cpp 项目: RickOne16/ompl
void ompl::geometric::pSBL::threadSolve(unsigned int tid, const base::PlannerTerminationCondition &ptc, SolutionInfo *sol)
{
    RNG rng;

    std::vector<Motion*> solution;
    base::State *xstate = si_->allocState();
    bool      startTree = rng.uniformBool();

    while (!sol->found && ptc == false)
    {
        bool retry = true;
        while (retry && !sol->found && ptc == false)
        {
            removeList_.lock.lock();
            if (!removeList_.motions.empty())
            {
                if (loopLock_.try_lock())
                {
                    retry = false;
                    std::map<Motion*, bool> seen;
                    for (unsigned int i = 0 ; i < removeList_.motions.size() ; ++i)
                        if (seen.find(removeList_.motions[i].motion) == seen.end())
                            removeMotion(*removeList_.motions[i].tree, removeList_.motions[i].motion, seen);
                    removeList_.motions.clear();
                    loopLock_.unlock();
                }
            }
            else
                retry = false;
            removeList_.lock.unlock();
        }

        if (sol->found || ptc)
            break;

        loopLockCounter_.lock();
        if (loopCounter_ == 0)
            loopLock_.lock();
        loopCounter_++;
        loopLockCounter_.unlock();


        TreeData &tree      = startTree ? tStart_ : tGoal_;
        startTree = !startTree;
        TreeData &otherTree = startTree ? tStart_ : tGoal_;

        Motion *existing = selectMotion(rng, tree);
        if (!samplerArray_[tid]->sampleNear(xstate, existing->state, maxDistance_))
            continue;

        /* create a motion */
        Motion *motion = new Motion(si_);
        si_->copyState(motion->state, xstate);
        motion->parent = existing;
        motion->root = existing->root;

        existing->lock.lock();
        existing->children.push_back(motion);
        existing->lock.unlock();

        addMotion(tree, motion);

        if (checkSolution(rng, !startTree, tree, otherTree, motion, solution))
        {
            sol->lock.lock();
            if (!sol->found)
            {
                sol->found = true;
                PathGeometric *path = new PathGeometric(si_);
                for (unsigned int i = 0 ; i < solution.size() ; ++i)
                    path->append(solution[i]->state);
                pdef_->addSolutionPath(base::PathPtr(path), false, 0.0, getName());
            }
            sol->lock.unlock();
        }


        loopLockCounter_.lock();
        loopCounter_--;
        if (loopCounter_ == 0)
            loopLock_.unlock();
        loopLockCounter_.unlock();
    }

    si_->freeState(xstate);
}
void DrawRectangle(Mat& img, Rect box)
{
	//Draw a rectangle with random color
	rectangle(img, box.tl(), box.br(), Scalar(g_rng.uniform(0, 255),
					g_rng.uniform(0,255),g_rng.uniform(0,255)));
}
示例#25
0
static Mat DrawMyImage(int thickness,int nbShape)
{
    Mat img=Mat::zeros(500,256*thickness+100,CV_8UC1);
    int offsetx = 50, offsety = 25;
    int lineLenght = 50;

    for (int i=0;i<256;i++)
        line(img,Point(thickness*i+ offsetx, offsety),Point(thickness*i+ offsetx, offsety+ lineLenght),Scalar(i), thickness);
    RNG r;
    Point center;
    int radius;
    int width,height;
    int angle;
    Rect rc;

    for (int i=1;i<=nbShape;i++)
    {
        int typeShape = r.uniform(MyCIRCLE, MyELLIPSE+1);
        switch (typeShape) {
        case MyCIRCLE:
            center = Point(r.uniform(offsetx,img.cols- offsetx), r.uniform(offsety + lineLenght, img.rows - offsety));
            radius = r.uniform(1, min(offsetx, offsety));
            circle(img,center,radius,Scalar(i),-1);
            break;
        case MyRECTANGLE:
            center = Point(r.uniform(offsetx, img.cols - offsetx), r.uniform(offsety + lineLenght, img.rows - offsety));
            width = r.uniform(1, min(offsetx, offsety));
            height = r.uniform(1, min(offsetx, offsety));
            rc = Rect(center-Point(width ,height )/2, center + Point(width , height )/2);
            rectangle(img,rc, Scalar(i), -1);
            break;
        case MyELLIPSE:
            center = Point(r.uniform(offsetx, img.cols - offsetx), r.uniform(offsety + lineLenght, img.rows - offsety));
            width = r.uniform(1, min(offsetx, offsety));
            height = r.uniform(1, min(offsetx, offsety));
            angle = r.uniform(0, 180);
            ellipse(img, center,Size(width/2,height/2),angle,0,360, Scalar(i), -1);
            break;
        }
    }
    return img;
}
示例#26
0
void Core_ArrayOpTest::run( int /* start_from */)
{
    int errcount = 0;

    // dense matrix operations
    {
        int sz3[] = {5, 10, 15};
        MatND A(3, sz3, CV_32F), B(3, sz3, CV_16SC4);
        CvMatND matA = A, matB = B;
        RNG rng;
        rng.fill(A, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10));
        rng.fill(B, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10));

        int idx0[] = {3,4,5}, idx1[] = {0, 9, 7};
        float val0 = 130;
        Scalar val1(-1000, 30, 3, 8);
        cvSetRealND(&matA, idx0, val0);
        cvSetReal3D(&matA, idx1[0], idx1[1], idx1[2], -val0);
        cvSetND(&matB, idx0, val1);
        cvSet3D(&matB, idx1[0], idx1[1], idx1[2], -val1);
        Ptr<CvMatND> matC = cvCloneMatND(&matB);

        if( A.at<float>(idx0[0], idx0[1], idx0[2]) != val0 ||
           A.at<float>(idx1[0], idx1[1], idx1[2]) != -val0 ||
           cvGetReal3D(&matA, idx0[0], idx0[1], idx0[2]) != val0 ||
           cvGetRealND(&matA, idx1) != -val0 ||

           Scalar(B.at<Vec4s>(idx0[0], idx0[1], idx0[2])) != val1 ||
           Scalar(B.at<Vec4s>(idx1[0], idx1[1], idx1[2])) != -val1 ||
           Scalar(cvGet3D(matC, idx0[0], idx0[1], idx0[2])) != val1 ||
           Scalar(cvGetND(matC, idx1)) != -val1 )
        {
            ts->printf(cvtest::TS::LOG, "one of cvSetReal3D, cvSetRealND, cvSet3D, cvSetND "
                       "or the corresponding *Get* functions is not correct\n");
            errcount++;
        }
    }

    RNG rng;
    const int MAX_DIM = 5, MAX_DIM_SZ = 10;
    // sparse matrix operations
    for( int si = 0; si < 10; si++ )
    {
        int depth = (unsigned)rng % 2 == 0 ? CV_32F : CV_64F;
        int dims = ((unsigned)rng % MAX_DIM) + 1;
        int i, k, size[MAX_DIM]={0}, idx[MAX_DIM]={0};
        vector<string> all_idxs;
        vector<double> all_vals;
        vector<double> all_vals2;
        string sidx, min_sidx, max_sidx;
        double min_val=0, max_val=0;

        int p = 1;
        for( k = 0; k < dims; k++ )
        {
            size[k] = ((unsigned)rng % MAX_DIM_SZ) + 1;
            p *= size[k];
        }
        SparseMat M( dims, size, depth );
        map<string, double> M0;

        int nz0 = (unsigned)rng % max(p/5,10);
        nz0 = min(max(nz0, 1), p);
        all_vals.resize(nz0);
        all_vals2.resize(nz0);
        Mat_<double> _all_vals(all_vals), _all_vals2(all_vals2);
        rng.fill(_all_vals, CV_RAND_UNI, Scalar(-1000), Scalar(1000));
        if( depth == CV_32F )
        {
            Mat _all_vals_f;
            _all_vals.convertTo(_all_vals_f, CV_32F);
            _all_vals_f.convertTo(_all_vals, CV_64F);
        }
        _all_vals.convertTo(_all_vals2, _all_vals2.type(), 2);
        if( depth == CV_32F )
        {
            Mat _all_vals2_f;
            _all_vals2.convertTo(_all_vals2_f, CV_32F);
            _all_vals2_f.convertTo(_all_vals2, CV_64F);
        }

        minMaxLoc(_all_vals, &min_val, &max_val);
        double _norm0 = norm(_all_vals, CV_C);
        double _norm1 = norm(_all_vals, CV_L1);
        double _norm2 = norm(_all_vals, CV_L2);

        for( i = 0; i < nz0; i++ )
        {
            for(;;)
            {
                for( k = 0; k < dims; k++ )
                    idx[k] = (unsigned)rng % size[k];
                sidx = idx2string(idx, dims);
                if( M0.count(sidx) == 0 )
                    break;
            }
            all_idxs.push_back(sidx);
            M0[sidx] = all_vals[i];
            if( all_vals[i] == min_val )
                min_sidx = sidx;
            if( all_vals[i] == max_val )
                max_sidx = sidx;
            setValue(M, idx, all_vals[i], rng);
            double v = getValue(M, idx, rng);
            if( v != all_vals[i] )
            {
                ts->printf(cvtest::TS::LOG, "%d. immediately after SparseMat[%s]=%.20g the current value is %.20g\n",
                           i, sidx.c_str(), all_vals[i], v);
                errcount++;
                break;
            }
        }

        Ptr<CvSparseMat> M2 = (CvSparseMat*)M;
        MatND Md;
        M.copyTo(Md);
        SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2);

        int nz1 = (int)M.nzcount(), nz2 = (int)M3.nzcount();
        double norm0 = norm(M, CV_C);
        double norm1 = norm(M, CV_L1);
        double norm2 = norm(M, CV_L2);
        double eps = depth == CV_32F ? FLT_EPSILON*100 : DBL_EPSILON*1000;

        if( nz1 != nz0 || nz2 != nz0)
        {
            errcount++;
            ts->printf(cvtest::TS::LOG, "%d: The number of non-zero elements before/after converting to/from dense matrix is not correct: %d/%d (while it should be %d)\n",
                       si, nz1, nz2, nz0 );
            break;
        }

        if( fabs(norm0 - _norm0) > fabs(_norm0)*eps ||
           fabs(norm1 - _norm1) > fabs(_norm1)*eps ||
           fabs(norm2 - _norm2) > fabs(_norm2)*eps )
        {
            errcount++;
            ts->printf(cvtest::TS::LOG, "%d: The norms are different: %.20g/%.20g/%.20g vs %.20g/%.20g/%.20g\n",
                       si, norm0, norm1, norm2, _norm0, _norm1, _norm2 );
            break;
        }

        int n = (unsigned)rng % max(p/5,10);
        n = min(max(n, 1), p) + nz0;

        for( i = 0; i < n; i++ )
        {
            double val1, val2, val3, val0;
            if(i < nz0)
            {
                sidx = all_idxs[i];
                string2idx(sidx, idx, dims);
                val0 = all_vals[i];
            }
            else
            {
                for( k = 0; k < dims; k++ )
                    idx[k] = (unsigned)rng % size[k];
                sidx = idx2string(idx, dims);
                val0 = M0[sidx];
            }
            val1 = getValue(M, idx, rng);
            val2 = getValue(M2, idx);
            val3 = getValue(M3, idx, rng);

            if( val1 != val0 || val2 != val0 || fabs(val3 - val0*2) > fabs(val0*2)*FLT_EPSILON )
            {
                errcount++;
                ts->printf(cvtest::TS::LOG, "SparseMat M[%s] = %g/%g/%g (while it should be %g)\n", sidx.c_str(), val1, val2, val3, val0 );
                break;
            }
        }

        for( i = 0; i < n; i++ )
        {
            double val1, val2;
            if(i < nz0)
            {
                sidx = all_idxs[i];
                string2idx(sidx, idx, dims);
            }
            else
            {
                for( k = 0; k < dims; k++ )
                    idx[k] = (unsigned)rng % size[k];
                sidx = idx2string(idx, dims);
            }
            eraseValue(M, idx, rng);
            eraseValue(M2, idx);
            val1 = getValue(M, idx, rng);
            val2 = getValue(M2, idx);
            if( val1 != 0 || val2 != 0 )
            {
                errcount++;
                ts->printf(cvtest::TS::LOG, "SparseMat: after deleting M[%s], it is =%g/%g (while it should be 0)\n", sidx.c_str(), val1, val2 );
                break;
            }
        }

        int nz = (int)M.nzcount();
        if( nz != 0 )
        {
            errcount++;
            ts->printf(cvtest::TS::LOG, "The number of non-zero elements after removing all the elements = %d (while it should be 0)\n", nz );
            break;
        }

        int idx1[MAX_DIM], idx2[MAX_DIM];
        double val1 = 0, val2 = 0;
        M3 = SparseMat(Md);
        minMaxLoc(M3, &val1, &val2, idx1, idx2);
        string s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims);
        if( val1 != min_val || val2 != max_val || s1 != min_sidx || s2 != max_sidx )
        {
            errcount++;
            ts->printf(cvtest::TS::LOG, "%d. Sparse: The value and positions of minimum/maximum elements are different from the reference values and positions:\n\t"
                       "(%g, %g, %s, %s) vs (%g, %g, %s, %s)\n", si, val1, val2, s1.c_str(), s2.c_str(),
                       min_val, max_val, min_sidx.c_str(), max_sidx.c_str());
            break;
        }

        minMaxIdx(Md, &val1, &val2, idx1, idx2);
        s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims);
        if( (min_val < 0 && (val1 != min_val || s1 != min_sidx)) ||
           (max_val > 0 && (val2 != max_val || s2 != max_sidx)) )
        {
            errcount++;
            ts->printf(cvtest::TS::LOG, "%d. Dense: The value and positions of minimum/maximum elements are different from the reference values and positions:\n\t"
                       "(%g, %g, %s, %s) vs (%g, %g, %s, %s)\n", si, val1, val2, s1.c_str(), s2.c_str(),
                       min_val, max_val, min_sidx.c_str(), max_sidx.c_str());
            break;
        }
    }

    ts->set_failed_test_info(errcount == 0 ? cvtest::TS::OK : cvtest::TS::FAIL_INVALID_OUTPUT);
}
示例#27
0
namespace Graphics
{

using namespace Shaders;

int scw, sch;

bool haveFBO = false;
bool noWarpFX = false;

/*
 Other files can use:
 
 namespace Matrices
 {
 
 void SetProjectionMatrix ( const matrix2x3& m );
 void SetViewMatrix ( const matrix2x3& m );
 void SetModelMatrix ( const matrix2x3& m );
 
 const matrix2x3& CurrentMatrix ();
 const matrix2x3& ProjectionMatrix ();
 const matrix2x3& ViewMatrix ();
 const matrix2x3& ModelMatrix ();

 }
 */



namespace Matrices
{

static matrix2x3 projectionMatrix;
static matrix2x3 viewMatrix;
static matrix2x3 modelMatrix;
static matrix2x3 mvpMatrix;

static void LoadMatrix ( const matrix2x3& m )
{
	GLfloat array[16];
	m.FillOpenGLMatrix(array);
	glLoadMatrixf(array);
}

void SetProjectionMatrix ( const matrix2x3& m )
{
	projectionMatrix = m;
}

void SetViewMatrix ( const matrix2x3& m )
{
	viewMatrix = m;
}

// the state is only guaranteed after a SetModelMatrix call
void SetModelMatrix ( const matrix2x3& m )
{
	modelMatrix = m;
	mvpMatrix = modelMatrix * viewMatrix * projectionMatrix;
	LoadMatrix(mvpMatrix);
}

const matrix2x3& CurrentMatrix ()
{
	return mvpMatrix;
}

const matrix2x3& ProjectionMatrix ()
{
	return projectionMatrix;
}

const matrix2x3& ViewMatrix ()
{
	return viewMatrix;
}

const matrix2x3& ModelMatrix ()
{
	return modelMatrix;
}

}

void Init ( int w, int h, bool fullscreen )
{
	SDL_InitSubSystem ( SDL_INIT_VIDEO );
	SDL_GL_SetAttribute ( SDL_GL_RED_SIZE, 8 );
	SDL_GL_SetAttribute ( SDL_GL_BLUE_SIZE, 8 );
	SDL_GL_SetAttribute ( SDL_GL_GREEN_SIZE, 8 );
	SDL_GL_SetAttribute ( SDL_GL_ALPHA_SIZE, 0 );
	SDL_GL_SetAttribute ( SDL_GL_DOUBLEBUFFER, 1 );
	SDL_GL_SetAttribute ( SDL_GL_DEPTH_SIZE, 24 );
	SDL_GL_SetAttribute ( SDL_GL_MULTISAMPLESAMPLES, 4 );
	SDL_GL_SetAttribute ( SDL_GL_MULTISAMPLEBUFFERS, 1 );
	SDL_GL_SetAttribute ( SDL_GL_SWAP_CONTROL, 1 );
	Uint32 flags = SDL_OPENGL;
	if (fullscreen)
		flags |= SDL_FULLSCREEN;
	if (!SDL_SetVideoMode(w, h, 0, flags))
	{
		SDL_GL_SetAttribute ( SDL_GL_MULTISAMPLESAMPLES, 0 );
		SDL_GL_SetAttribute ( SDL_GL_MULTISAMPLEBUFFERS, 0 );
		LOG("Graphics", LOG_WARNING, "Card does not support FSAA!");
		if (!SDL_SetVideoMode(w, h, 0, flags))
		{
		    LOG("Graphics", LOG_WARNING, "Card does not support normal video options!");
			SDL_GL_SetAttribute ( SDL_GL_RED_SIZE, 5 );
			SDL_GL_SetAttribute ( SDL_GL_GREEN_SIZE, 5 );
			SDL_GL_SetAttribute ( SDL_GL_BLUE_SIZE, 5 );
			if (!SDL_SetVideoMode(w, h, 0, flags))
			{
                LOG("Graphics", LOG_ERROR, "Bad graphics driver.");
				abort();
			}
		}
	}
	
	scw = w;
	sch = h;
	
	glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

	glDepthMask(GL_FALSE);

	glEnable ( GL_BLEND );
	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

	glClearDepth(1.0);
	glDepthFunc(GL_LESS);
	glCullFace(GL_CCW);
	
//	glEnable ( GL_LINE_SMOOTH );
	glEnable ( GL_POINT_SMOOTH );
	
	glHint ( GL_LINE_SMOOTH_HINT, GL_NICEST );
	glHint ( GL_POINT_SMOOTH_HINT, GL_NICEST );
#ifdef __MACH__
    glHint ( GL_TRANSFORM_HINT_APPLE, GL_FASTEST );
#endif

	const GLfloat projectionMatrix[] = { 1.0f, 0.0f, 0.0f, 0.0f,
	                                     0.0f, 1.0f, 0.0f, 0.0f,
										 0.0f, 0.0f, 0.001f, 0.0f,
										 0.0f, 0.0f, -0.5f, 1.0f };

	glMatrixMode(GL_PROJECTION);
	glLoadMatrixf(projectionMatrix);
	glMatrixMode(GL_MODELVIEW);
	
	glEnableClientState ( GL_VERTEX_ARRAY );
	
	const char* extensions = (const char*)glGetString(GL_EXTENSIONS);
	const char* renderer = (const char*)glGetString(GL_RENDERER);
	haveFBO = strstr(extensions, "GL_EXT_framebuffer_object");
	noWarpFX = strstr(renderer, "Intel");
}

unsigned ToInt ( const std::string& value )
{
	return atoi(value.c_str());
}

bool ToBool ( const std::string& value )
{
	return value == "true";
}

// [WIP] [ADAM]
void Reset ()
{
//	SDL_SetVideoMode(ToInt(Preferences::Get("Screen/Width")), ToInt(Preferences::Get("Screen/Height")), 0, SDL_ResizeEvent);

//	these two lines work:
//	glDeleteFramebuffersEXT(1, &warpFBO);
//	warpFBO = 0;
	
//	SetProjectionMatrix( matrix2x3::Ortho(left, right, bottom, top) ); // what are left, right, bottom, top?
}

static bool texturingEnabled = false;

static void EnableTexturing ()
{
	if (!texturingEnabled)
	{
		glEnableClientState ( GL_TEXTURE_COORD_ARRAY );
		texturingEnabled = true;
	}
}

static void DisableTexturing ()
{
	if (texturingEnabled)
	{
		glDisableClientState ( GL_TEXTURE_COORD_ARRAY );
		texturingEnabled = false;
	}
}

static bool blendingEnabled = true;

static void EnableBlending ()
{
	if (!blendingEnabled)
	{
		glEnable(GL_BLEND);
		blendingEnabled = true;
	}
}

static void DisableBlending ()
{
	if (blendingEnabled)
	{
		glDisable(GL_BLEND);
		blendingEnabled = false;
	}
}

static void SetColour ( const colour& col )
{
	if (sizeof(col) == sizeof(float) * 4)
	{
		glColor4fv((const GLfloat*)&col);
	}
	else
	{
		glColor4f(col.red(), col.green(), col.blue(), col.alpha());
	}
}

static void ClearColour ()
{
	const uint32_t white = 0xFFFFFFFF;
	glColor4ubv((const GLubyte*)&white);
}

vec2 SpriteDimensions ( const std::string& sheetname )
{
	SpriteSheet* sheet;
	SheetMap::iterator iter = spriteSheets.find(sheetname);
	if (iter == spriteSheets.end())
	{
		// load it
		sheet = new SpriteSheet(sheetname);
		spriteSheets[sheetname] = sheet;
	}
	else
	{
		sheet = iter->second;
	}
	assert(sheet);
	return vec2(sheet->TileSizeX(), sheet->TileSizeY());
}

void DrawSprite ( const std::string& sheetname, int sheet_x, int sheet_y, vec2 position, vec2 size, float rotation, colour col )
{
	SetShader("Sprite");
	EnableTexturing();
	EnableBlending();
	ClearColour();
	SetColour(col);
	SpriteSheet* sheet;
	SheetMap::iterator iter = spriteSheets.find(sheetname);
	if (iter == spriteSheets.end())
	{
		// load it
		sheet = new SpriteSheet(sheetname);
		spriteSheets[sheetname] = sheet;
	}
	else
	{
		sheet = iter->second;
	}
	Matrices::SetViewMatrix(matrix2x3::Translate(position));
	Matrices::SetModelMatrix(matrix2x3::Identity());
	if (sheet->IsRotational())
	{
		assert(sheet_x == 0);
		assert(sheet_y == 0);
		sheet->DrawRotation(size, rotation);
	}
	else
	{
		glRotatef(RAD2DEG(rotation), 0.0f, 0.0f, 1.0f);
		sheet->Draw(sheet_x, sheet_y, size);
	}
}

void DrawSpriteFrame ( const std::string& sheetname, vec2 position, vec2 size, int index, float rotation, colour col )
{
	SetShader("Sprite");
	EnableTexturing();
	EnableBlending();
	ClearColour();
	SetColour(col);
	SpriteSheet* sheet;
	SheetMap::iterator iter = spriteSheets.find(sheetname);
	if (iter == spriteSheets.end())
	{
		sheet = new SpriteSheet(sheetname);
		spriteSheets[sheetname] = sheet;
	}
	else
	{
		sheet = iter->second;
	}
	Matrices::SetViewMatrix(matrix2x3::Translate(position));
	Matrices::SetModelMatrix(matrix2x3::Identity());
	glRotatef(RAD2DEG(rotation), 0.0f, 0.0f, 1.0f);
	
	int x = index % sheet->SheetTilesX();
	int y = (index - x) / sheet->SheetTilesX();
	sheet->Draw(x, y, size);
}

/* [ADAMLATER] - this is a function that allows sprites to be tiled if necessary
void DrawSpriteTile ( const std::string& sheetname, int sheet_x, int sheet_y, vec2 position, vec2 size, float rotation, colour col )
{
	SetShader("Sprite");
	EnableTexturing();
	EnableBlending();
	ClearColour();
	SetColour(col);
	SpriteSheet* sheet;
	SheetMap::iterator iter = spriteSheets.find(sheetname);
	if (iter == spriteSheets.end())
	{
		// load it
		sheet = new SpriteSheet(sheetname);
		spriteSheets[sheetname] = sheet;
	}
	else
	{
		sheet = iter->second;
	}
	Matrices::SetViewMatrix(matrix2x3::Translate(position));
	Matrices::SetModelMatrix(matrix2x3::Identity());
	if (sheet->IsRotational())
	{
		assert(sheet_x == 0);
		assert(sheet_y == 0);
		sheet->DrawRotation(size, rotation);
	}
	else
	{
		glRotatef(RAD2DEG(rotation), 0.0f, 0.0f, 1.0f);
		sheet->Draw(sheet_x, sheet_y, size);
	}
}*/

const int MAX_TEXTURE_SIZE = 4096;

// splits regardless of words
int imperfectSplit ( vec2 dims, std::string* bob, int maxSize )
{
	// bob needs to be a std::vector of std::strings, so that I can add however many strings to it
	// yet to be figured out
	return 1;
}

// splits along spaces, dropping the spaces
int idealSplit ( vec2 dims, std::string* bob, int maxSize )
{
	// has yet to be figured out either
	return 1;
}

void DrawTextSDL ( const std::string& text, const std::string& font, const char* justify, vec2 position, int height, colour col, float rotation )
{
	SetShader("Text");
	EnableTexturing();
	EnableBlending();
	SetColour(col);
	GLuint texID = TextRenderer::TextObject(font, text, height);
	Matrices::SetViewMatrix(matrix2x3::Translate(position));
	Matrices::SetModelMatrix(matrix2x3::Rotation(rotation));
	glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texID);
	vec2 dims = TextRenderer::TextDimensions(font, text, height);
	
	// TEMP
	int xcoord = 0;
	int ycoord = 0;
	TTF_Font* fontObject = TextRenderer::GetFont(font, height);
	if (TTF_SizeUTF8(fontObject, text.c_str(), &xcoord, &ycoord) == 0 && text == "This is as long as a message can be at font 20: not long..")
	{
		printf("The text '%s' has dimensions of %d by %d, and a height of %d\n", text.c_str(), xcoord, ycoord, height);
	}
	// END TEMP
	
	GLfloat textureArray[] = { 0.0f, 0.0f, dims.X(), 0.0f, dims.X(), dims.Y(), 0.0f, dims.Y() };
	vec2 halfSize;
	if (strcmp(justify, "left") == 0)
	{
		halfSize = (dims * (height / dims.Y()));
		GLfloat vertexArray[8] = { 0, halfSize.Y() / 2, halfSize.X(), halfSize.Y() / 2, halfSize.X(), -halfSize.Y() / 2, 0, -halfSize.Y() / 2 };
		glVertexPointer(2, GL_FLOAT, 0, vertexArray);
	}
	else
	{
		halfSize = (dims * (height / dims.Y())) * 0.5f;
		if (strcmp(justify, "right") == 0)
		{
			GLfloat vertexArray[8] = { -halfSize.X(), halfSize.Y() / 2, 0, halfSize.Y() / 2, 0, -halfSize.Y() / 2, -halfSize.X(), -halfSize.Y() / 2 };
			glVertexPointer(2, GL_FLOAT, 0, vertexArray);
		} else
		{
			GLfloat vertexArray[8] = { -halfSize.X(), halfSize.Y(), halfSize.X(), halfSize.Y(), halfSize.X(), -halfSize.Y(), -halfSize.X(), -halfSize.Y() };
			glVertexPointer(2, GL_FLOAT, 0, vertexArray);
		}
	}
	glTexCoordPointer(2, GL_FLOAT, 0, textureArray);
	glDrawArrays(GL_QUADS, 0, 4);
}

void DrawLine ( vec2 coordinate1, vec2 coordinate2, float width, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	glLineWidth(width);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	SetColour(col);
	float vertices[4] = { coordinate1.X(), coordinate1.Y(),
						coordinate2.X(), coordinate2.Y() };
	glVertexPointer ( 2, GL_FLOAT, 0, vertices );
	glDrawArrays ( GL_LINES, 0, 2 );
}

static float RandomFloat ( float min, float max )
{
	float range = max - min;
	float uniform = rand() / (float)RAND_MAX;
	float absolute = uniform * range;
	return absolute + min;
}

static void RealDrawLightning ( vec2 coordinate1, vec2 coordinate2, float width, float chaos, colour col, bool tailed, RNG& rng )
{
	if (col.alpha() < 0.2f)
		return;
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	glLineWidth(width);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	SetColour(col);
	unsigned long segments = 12;
	float offsetting = chaos;
	float* vertices = (float*)alloca(sizeof(float) * 2 * segments);
	vec2 tangent = (coordinate2 - coordinate1).UnitVector();
	vec2 normal = vec2(-tangent.Y(), tangent.X());
	normal.X() = -normal.Y();
	for (unsigned long i = 0; i < segments; i++)
	{
		float delta = ((float)i / (float)(segments - 1));
		//This may be only a partial fix.	
		vec2 basePosition = ((coordinate1*(1.0f-delta)) + (coordinate2*delta));// / 2.0f;
		if (tailed)
		{
			delta *= 2.0f;
			if (delta > 1.0f) delta = 2.0f - delta;
		}
		float maxOffset = offsetting * delta;
		float actualOffset = RandomFloat(-maxOffset, maxOffset);
		basePosition += normal * actualOffset;
		vertices[(i*2)+0] = basePosition.X();
		vertices[(i*2)+1] = basePosition.Y();
	}
	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glDrawArrays(GL_LINE_STRIP, 0, segments);
}

static RNG lightningRNG;
static uint32_t lastSeed = 4;

void DrawLightning ( vec2 coordinate1, vec2 coordinate2, float width, float chaos, colour col, bool tailed )
{
	uint32_t newLastSeed = lightningRNG.GetState();
	RealDrawLightning(coordinate1, coordinate2, width, chaos, col, tailed, lightningRNG);
	RNG localRNG(lastSeed);
	lastSeed = newLastSeed;
	col.alpha() *= 0.5f;
	RealDrawLightning(coordinate1, coordinate2, width * 3.0f, chaos, col, tailed, localRNG);
}

void DrawBox ( float top, float left, float bottom, float right, float width, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	SetColour(col);
	float quad[8] = { left, top,
					left, bottom,
					right, bottom,
					right, top };
	glVertexPointer ( 2, GL_FLOAT, 0, quad );
	glDrawArrays ( GL_QUADS, 0, 4 );
	if (width != 0)
	{
		SetColour(col + colour(0.45, 0.45, 0.45, 0.0));
		glLineWidth(width);
		float vertices[16] = { left, top,
							right, top,
							left, top,
							left, bottom,
							right, top,
							right, bottom,
							left, bottom,
							right, bottom };
		glVertexPointer ( 2, GL_FLOAT, 0, vertices );
		glDrawArrays ( GL_LINES, 0, 8 );
	}
}

void DrawCircle ( vec2 centre, float radius, float width, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	glLineWidth(width);
	Matrices::SetViewMatrix(matrix2x3::Translate(centre));
	Matrices::SetModelMatrix(matrix2x3::Scale(radius));
	SetColour ( col );
	glVertexPointer(2, GL_FLOAT, 0, circlePoints);
	glDrawArrays(GL_LINE_LOOP, 0, sizeof(circlePoints) / (2 * sizeof(float)));
}

void DrawTriangle ( const vec2 point1, const vec2 point2, const vec2 point3, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	SetColour(col);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	float real_triangle[6] = { point1.X(), point1.Y(),
								point2.X(), point2.Y(),
								point3.X(), point3.Y() };
	glVertexPointer(2, GL_FLOAT, 0, real_triangle);
	glDrawArrays(GL_POLYGON, 0, 3);
} 

void DrawDiamond ( float top, float left, float bottom, float right, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	SetColour(col);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	float diamond[8] = { (right + left) / 2, top,
						left, (top + bottom) / 2,
						(right + left) / 2, bottom,
						right, (top + bottom) / 2 };
	glVertexPointer(2, GL_FLOAT, 0, diamond);
	glDrawArrays(GL_QUADS, 0, 4);
} 

#pragma mark Particle System Functions
std::list<ParticleSystem*> particleSystems;

void AddParticles ( const std::string& name, unsigned long particleCount, vec2 centre, vec2 velocity, vec2 velocityVariance, vec2 acceleration, float sizeFactor, float lifetime )
{
	ParticleSystem* ps = new ParticleSystem(name, particleCount, sizeFactor, centre, velocity, velocityVariance, acceleration, lifetime);
	particleSystems.push_back(ps);
}

void DrawParticles ()
{
	Shaders::SetShader("Particles");
	EnableTexturing();
	EnableBlending();
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	for (std::list<ParticleSystem*>::iterator iter = particleSystems.begin();
	                                          iter != particleSystems.end();
	                                          ++iter)
	{
		ParticleSystem* ps = *iter;
		bool isDead = ps->Update();
		if (isDead)
		{
			std::list<ParticleSystem*>::iterator iterCopy = iter;
			++iter;
			particleSystems.erase(iterCopy);
			delete ps;
			if (iter == particleSystems.end())
				break;
		}
		ps->Draw();
	}
}

void ClearParticles ()
{
	for (std::list<ParticleSystem*>::iterator iter = particleSystems.begin();
	                                          iter != particleSystems.end();
	                                          ++iter)
	{
		delete *iter;
	}
	particleSystems.clear();
}

static vec2 cameraCorner1;
static vec2 cameraCorner2;
static float cameraRotation;

std::vector<Starfield*> starfields;
unsigned starfieldNumber;

void DrawStarfield ( float depth )
{
	while (starfields.size() <= starfieldNumber)
	{
		starfields.push_back(new Starfield);
	}
	SetShader("Starfield");
	EnableTexturing();
	DisableBlending();
	ClearColour();
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	starfields[starfieldNumber++]->Draw(depth, (cameraCorner1 + cameraCorner2) / 2.0f);
}

std::map<std::string, Object3D*> objects3d;

static Object3D* GetObject3D ( std::string name )
{
	std::map<std::string, Object3D*>::iterator iter;
	iter = objects3d.find(name);
	if (iter == objects3d.end())
	{
		// load the object
		Object3D* object = new Object3D(name);
		objects3d.insert(std::make_pair(name, object));
		return object;
	}
	else
	{
		return iter->second;
	}
}

void DrawObject3DAmbient ( std::string name, vec2 centre, float scale, float angle, float bank )
{
	Object3D* obj = GetObject3D(name);
	EnableTexturing();
	DisableBlending();
	obj->BindTextures();
	//glUniform3f(UniformLocation("Ambient"), ambient.red(), ambient.green(), ambient.blue());
	SetShader("3DBase");
	glUniform1f(UniformLocation("specularScale"), obj->SpecularScale());
	glUniform1f(UniformLocation("shininess"), obj->Shininess());
	Matrices::SetViewMatrix(matrix2x3::Translate(centre));
	obj->Draw(scale, angle, bank);
}

float AspectRatio ()
{
	return float(scw) / float(sch);
}

vec2 MapPoint ( vec2 windowCoords )
{
	matrix2x3 viewProjection ( Matrices::viewMatrix * Matrices::projectionMatrix );
	matrix2x3 vpi = viewProjection.Inverse();
	vec2 normalisedCoords = vpi * windowCoords;
	normalisedCoords += vec2(1.0f, 1.0f);
	normalisedCoords *= 0.5f;
	return vec2(normalisedCoords.X() * scw, normalisedCoords.Y() * sch);
}

void DrawPoint ( vec2 coord, float width, colour col )
{
	SetShader("Primitive");
	DisableTexturing();
	if (col.alpha() < 1.0f)
	{
		EnableBlending();
	}
	else
	{
		DisableBlending();
	}
	SetColour(col);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	float quad[8] = { coord.X(), coord.Y(),
		coord.X(), coord.Y() - 2,
		coord.X() + 2, coord.Y() - 2,
		coord.X() + 2, coord.Y() };
	glVertexPointer ( 2, GL_FLOAT, 0, quad );
	glDrawArrays ( GL_QUADS, 0, 4 );
	/* ¡WARNING! IMMEDIATE MODE! ENTER AT YOUR OWN RISK */
//	glBegin(GL_POINTS);
//		glVertex2f(coord.X(), coord.Y());
//	glEnd();
}

bool IsCulled ( vec2 position, float radius )
{
	if ((position.X() + radius) < cameraCorner1.X())
		return true;
	if ((position.X() - radius) > cameraCorner2.X())
		return true;
	if ((position.Y() + radius) < cameraCorner1.Y())
		return true;
	if ((position.Y() - radius) > cameraCorner2.Y())
		return true;
	return false;
}

void SetCamera ( vec2 corner1, vec2 corner2, float rotation )
{
	matrix2x3 projection ( matrix2x3::Ortho(corner1.X(), corner2.X(), corner1.Y(), corner2.Y()) );
	if (fabs(rotation) > 0.00004f)
		projection *= matrix2x3::Rotation(rotation);
	Matrices::SetProjectionMatrix(projection);
	cameraCorner1 = corner1;
	cameraCorner2 = corner2;
}

void BeginFrame ()
{
	glDepthMask(GL_TRUE);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glDepthMask(GL_FALSE);
	Matrices::SetViewMatrix(matrix2x3::Identity());
	Matrices::SetModelMatrix(matrix2x3::Identity());
	starfieldNumber = 1;
}

void EndFrame ()
{
#ifdef __MACH__
    glSwapAPPLE();
#else
	SDL_GL_SwapBuffers();
#endif
	TextRenderer::Prune();
}

void BeginWarp ( float magnitude, float angle, float scale )
{
#ifndef DISABLE_WARP_EFFECTS
	if (!haveFBO || noWarpFX)
		return;
	warpMag = magnitude;
	warpAngle = angle;
	warpScale = scale;
	if (magnitude < WARP_MAG_THRESHOLD)
		return;
	if (warpFBO == 0)
	{
		glGenFramebuffersEXT(1, &warpFBO);
		glGenTextures(1, &warpTex);
		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, warpFBO);
		glBindTexture(GL_TEXTURE_RECTANGLE_ARB, warpTex);
		glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA8, scw, sch, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
		glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_RECTANGLE_ARB, warpTex, 0);
		GLuint status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
		assert(status == GL_FRAMEBUFFER_COMPLETE_EXT);
	}
	else
	{
		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, warpFBO);
	}
	glClear(GL_COLOR_BUFFER_BIT);
#endif
}

void EndWarp ()
{
#ifndef DISABLE_WARP_EFFECTS
	if (!haveFBO || noWarpFX || warpMag < WARP_MAG_THRESHOLD)
		return;
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	glBindTexture(GL_TEXTURE_RECTANGLE_ARB, warpTex);
	Shaders::SetShader("DistortWarp");
	glUniform1f(Shaders::UniformLocation("Angle"), warpAngle);
	glUniform1f(Shaders::UniformLocation("Magnitude"), warpMag);
	glUniform1f(Shaders::UniformLocation("Scale"), 1.0f / warpScale);
	glUniform2f(Shaders::UniformLocation("Target"), 0.088f, 0.0f);
	const GLfloat vertices[] = { -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f };
	const GLfloat texCoords[] = { 0.0f, 0.0f, scw, 0.0f, scw, sch, 0.0f, sch };
	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
	EnableTexturing();
	DisableBlending();
	glDrawArrays(GL_QUADS, 0, 4);
#endif
}

void PreloadSpriteSheet(const std::string& sheetname)
{
	SpriteSheet* sheet;
	SheetMap::iterator iter = spriteSheets.find(sheetname);
	if (iter == spriteSheets.end())
	{
		sheet = new SpriteSheet(sheetname);
		spriteSheets[sheetname] = sheet;
	}
}

void PreloadFont(const std::string& fontname)
{
	TextRenderer::TextDimensions(fontname, "", 2);
}

}
示例#28
0
int main(int argc, char ** argv)
{
  if(argc < 2)
    {
      cout << "Usage: " << endl;
      cout << "         TV norm: ./depthInpainting TV depthImage" << endl;
      cout << "       PSNR calc: ./depthInpainting P depthImage mask inpainted" << endl;
      cout << "      Inpainting: ./depthInpainting LRTV depthImage mask outputPath" << endl;
      cout << "      Generating: ./depthInpainting G depthImage missingRate outputMask outputMissing" << endl;
      cout << "         LowRank: ./depthInpainting L depthImahe mask outputpath" << endl;
      cout << "         LRTVPHI: ./depthInpainting LRTVPHI depthImage mask outputPath" << endl;
      cout << "      TVPHI norm: ./depthInpainting TVPHI depthImage" << endl;
      cout << "            LRL0: ./depthInpainting LRL0 depthImage mask outputPath initImage K lambda_L0 MaxIterCnt" << endl;
      cout << "         LRL0PHI: ./depthInpainting LRL0PHI depthImage mask outputPath initImage K lambda_L0 MaxIterCnt" << endl;
      cout << "              L0: /depthInpainting L0 depthImage" << endl;
      return 0;
    }
  string instruction = argv[1];
  if( instruction == "TV" )
    {
      Mat img = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
      cout << NORM_TV(img) << endl;
    }
  if( instruction == "TVPHI")
    {
      Mat img = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
      LRTVPHI lrttv;
      lrttv.setShrinkageParam(1.0, 1.0);
      cout << lrttv.NORM_TVPHI(img) << endl;
    }
  else if( instruction == "P" )
    {
      Mat original = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
      Mat inpainted = imread(argv[4], CV_LOAD_IMAGE_GRAYSCALE);
      Mat mask = imread(argv[3], CV_LOAD_IMAGE_GRAYSCALE);
      cout << PSNR(original, inpainted, mask) << endl;
    }
  else if( instruction == "G" )
    {
      string disparityPath = argv[2];
      int missingRate = atof(argv[3]);
      string outputMask = argv[4];
      string outputMissing = argv[5];
      Mat disparityOriginal = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
 
      int W = disparityOriginal.cols;
      int H = disparityOriginal.rows;

      RNG rng;
      // mask: 0 indicates missing pixels
      Mat mask = Mat::zeros(H, W, CV_8U);
      rng.fill(mask, RNG::UNIFORM, 0, 255);
      threshold(mask, mask, 255 * missingRate / 100, 255, THRESH_BINARY);
      Mat disparityMissing;
      multiply(disparityOriginal, mask / 255, disparityMissing);

      imwrite(outputMask, mask);
      imwrite(outputMissing, disparityMissing);
    }
  // Low rank
  else if(instruction == "L" )
    {
      string disparityPath = argv[2];
      string maskPath = argv[3];
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      string inpaintedPath = argv[4];
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      multiply(disparityMissing, mask / 255, disparityMissing);
      Mat inpainted = TNNR(disparityMissing, mask, 9, 9, 0.06);
      imwrite(argv[4], inpainted);
      
    }
  // only TV inpainting
  else if( instruction == "T" )
    {
      string disparityPath = argv[2];
      string maskPath = argv[3];
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      string inpaintedPath = argv[4];
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      multiply(disparityMissing, mask / 255, disparityMissing);
      // Mat denoised;
      // inpaint(disparityMissing, 255 - mask, denoised, 11, INPAINT_TELEA);

      // imwrite(inpaintedPath, denoised);

      // try our TV
      // we can use low rank to initialize U_
      Mat denoised = imread(argv[5], CV_LOAD_IMAGE_ANYCOLOR); //TNNR(disparityMissing, mask, 9, 9, 0.06);

      LRTV lrtv(disparityMissing, mask);
      // rho dt lambda_tv lambda_rank 100 10
      lrtv.setParameters(0, 1, 0.01, 0);
      lrtv.init_U(denoised);
      lrtv.sub_1();
      Mat M = lrtv.getM();
      Mat Y = lrtv.getY();
      Mat result = lrtv.getU();

      Mat output;
      result.convertTo(output, CV_8UC1);
      imwrite(inpaintedPath, output);
      imwrite("M.png", M);
      imwrite("Y.png", Y);
    }
  else if( instruction == "LRTV" )
    {
      string disparityPath = argv[2];
      string maskPath = argv[3];
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      string inpaintedPath = argv[4];
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      multiply(disparityMissing, mask / 255, disparityMissing);

      // Mat denoised;
      // inpaint(disparityMissing, 255 - mask, denoised, 11, INPAINT_TELEA);

      // imwrite(inpaintedPath, denoised);

      // try our TV
      // we can use low rank to initialize U_
      //Mat denoised = TNNR(disparityMissing, mask, 9, 9, 0.06);
      Mat denoised = imread(argv[5], CV_LOAD_IMAGE_GRAYSCALE);

      LRTV lrtv(disparityMissing, mask);
      // rho dt lambda_tv lambda_rank 100 10
      lrtv.setParameters(1.2, 0.1, 40, 10);
      lrtv.init_U(denoised);
      Mat result = lrtv.compute();
      Mat M = lrtv.getM();
      Mat Y = lrtv.getY();

      
      Mat output;
      result.convertTo(output, CV_8UC1);
      imwrite(inpaintedPath, output);
      imwrite("M.png", M);
      imwrite("Y.png", Y);

    }
  // for stat
  else if( instruction == "S" )
    {
      Mat dispU = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
      int H = dispU.rows;
      int W = dispU.cols;
      Mat disp = Mat::zeros(H, W, CV_32FC1);
      dispU.convertTo(disp, CV_32FC1);
      
      Mat kernelx_plus_ = (Mat_<float>(1,3)<<0.0,-1.0,1.0);
      Mat kernelx_minus_ = (Mat_<float>(1,3)<<-1.0,1.0,0.0);
      Mat kernely_plus_ = (Mat_<float>(3,1)<<0.0,-1.0,1.0);
      Mat kernely_minus_ = (Mat_<float>(3,1)<<-1.0,1.0,0.0);

      Mat grad_x_plus, grad_x_minus, grad_y_plus, grad_y_minus;
      filter2D(disp, grad_x_plus, -1, kernelx_plus_);
      filter2D(disp, grad_x_minus, -1, kernelx_minus_);
      filter2D(disp, grad_y_plus, -1, kernely_plus_);
      filter2D(disp, grad_y_minus, -1, kernely_minus_);
      Mat ux, uy;
      ux = (grad_x_minus + grad_x_plus) / 2.0;
      uy = (grad_y_minus + grad_y_plus) / 2.0;
      pow(ux, 2.0, ux);
      pow(uy, 2.0, uy);
      Mat grad;
      sqrt(ux + uy, grad);
      Mat r;
      grad.convertTo(r, CV_8UC1);
      vector <float> histogram(200,0);
      for(int i = 0; i < H; i++)
	for(int j = 0; j < W; j++)
	  {
	    if(r.at<uchar>(i,j) < 200)
	      {
		int id = r.at<uchar>(i,j);
		histogram[id] = histogram[id] + 1;
	      }
	  }
      
      float total = accumulate(histogram.begin(), histogram.end(), 0.0);
      fstream file(argv[3],ios::out);
      int i = 0;
      for (auto &x : histogram)
	{
	  i++;
	  cout << x << endl;
	  file << i  << " " << x / total << endl;
	}
    }
    else if( instruction == "L0" )
    {
      Mat dispU = imread(argv[2], CV_LOAD_IMAGE_GRAYSCALE);
      int H = dispU.rows;
      int W = dispU.cols;
      Mat disp = Mat::zeros(H, W, CV_32FC1);
      dispU.convertTo(disp, CV_32FC1);
      
      Mat kernelx_plus_ = (Mat_<float>(1,3)<<0.0,-1.0,1.0);
      Mat kernelx_minus_ = (Mat_<float>(1,3)<<-1.0,1.0,0.0);
      Mat kernely_plus_ = (Mat_<float>(3,1)<<0.0,-1.0,1.0);
      Mat kernely_minus_ = (Mat_<float>(3,1)<<-1.0,1.0,0.0);

      Mat grad_x_plus, grad_x_minus, grad_y_plus, grad_y_minus;
      filter2D(disp, grad_x_plus, -1, kernelx_plus_);
      filter2D(disp, grad_x_minus, -1, kernelx_minus_);
      filter2D(disp, grad_y_plus, -1, kernely_plus_);
      filter2D(disp, grad_y_minus, -1, kernely_minus_);
      Mat ux, uy;
      ux = (grad_x_minus + grad_x_plus) / 2.0;
      uy = (grad_y_minus + grad_y_plus) / 2.0;

      Mat grad;
      grad = abs(ux) + abs(uy);
      Mat r;
      grad.convertTo(r, CV_8UC1);
      int l0 = 0;
      for(int i = 0; i < H; i++)
	for(int j = 0; j < W; j++)
	  {
	    if (grad.at<uchar>(i,j ) <1)
	      l0++;
	  }
      cout << W*H - l0 << endl;
    }
  else if( instruction == "LRTVPHI" )
    {
      string disparityPath = argv[2]; //"../../MiddInpaint/ArtL/disp.png";
      string maskPath = argv[3]; //"../../MiddInpaint/ArtL/mask_50.png";
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      string inpaintedPath = argv[4]; //"just_a_test.png";
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      // int H_ = mask.rows;
      // int W_ = mask.cols;
      // mask = 255*Mat::ones(H_, W_, CV_8UC1);
      Mat orig;
      disparityMissing.copyTo(orig); orig.convertTo(orig, CV_32FC1);
      multiply(disparityMissing, mask / 255, disparityMissing);

      imshow("dd",disparityMissing);waitKey(0);
      LRTVPHI lrttv(disparityMissing, mask);
      lrttv.setShrinkageParam(1.0,1.0);

      Mat denoised = imread(argv[5], CV_LOAD_IMAGE_GRAYSCALE);
     
      // rho dt lambda_tv lambda_rank
      // rho = 1.2
      lrttv.setParameters(1.2, 0.1, 10, 0.01);
      lrttv.setNewtonParameters(0.001); // set gamma

      // imshow("temp", denoised);
      // waitKey(0);2
      lrttv.init_U(denoised);
      lrttv.init_M(denoised);
      cout << "optimal objective function value = " << lrttv.sub_1_val(orig) << endl;
      Mat result;
      
	    //      lrttv.sub_2();
	    //      lrttv.sub_3();

      lrttv.sub_1(1.0,10.0);
      cout << "optimal objective function value = " << lrttv.sub_1_val(orig) << endl;
      // cout << "OK  sub_1" << endl;
      //Mat result = lrttv.compute();
      Mat M = lrttv.getM();
      Mat Y = lrttv.getY();
      Mat output;
      result = lrttv.getU();
      result.convertTo(output, CV_8UC1);
      imwrite(inpaintedPath, output);
      imwrite("tM.png", M);
      imwrite("tY.png", Y);
    }
  else if( instruction == "X" )
    {
      Mat a = (Mat_<float>(2,2)<<0,1,2,3);
      Mat x;
      exp(a,x);
      Mat y;
      exp(-a,y);
      Mat result;
      divide(x-y,x+y,result);
      cout << result << endl;
      
    }
  else if( instruction == "LRL0" )
    {
      string disparityPath = argv[2]; //"../../MiddInpaint/ArtL/disp.png";
      string maskPath = argv[3]; //"../../MiddInpaint/ArtL/mask_50.png";
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      Mat orig;
      disparityMissing.copyTo(orig);
      string inpaintedPath = argv[4]; //"just_a_test.png";
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      int K = atoi(argv[6]);
      float lambda_l0 = atof(argv[7]);
      int max_iter = atoi(argv[8]);

      string path1 = argv[9];
      multiply(disparityMissing, mask / 255, disparityMissing);
      Mat denoised = imread(argv[5], CV_LOAD_IMAGE_GRAYSCALE);
      LRL0 lrl0(disparityMissing, mask);
      lrl0.setParameters(1.2,0.1,lambda_l0,10);
      lrl0.init_U(denoised);
      Mat result = lrl0.compute(K, max_iter, inpaintedPath, orig, path1);
      // Mat output;
      //result.convertTo(output, CV_8UC1);
      //imwrite(inpaintedPath, output);
      
      
    }
    else if( instruction == "LRL0PHI" )
    {
      string disparityPath = argv[2]; //"../../MiddInpaint/ArtL/disp.png";
      string maskPath = argv[3]; //"../../MiddInpaint/ArtL/mask_50.png";
      Mat disparityMissing = imread(disparityPath, CV_LOAD_IMAGE_GRAYSCALE);
      Mat orig;
      disparityMissing.copyTo(orig);
      string inpaintedPath = argv[4]; //"just_a_test.png";
      Mat mask = imread(maskPath, CV_LOAD_IMAGE_GRAYSCALE);

      int K = atoi(argv[6]);
      float lambda_l0 = atof(argv[7]);
      int max_iter = atoi(argv[8]);

      string path1 = argv[9];
      multiply(disparityMissing, mask / 255, disparityMissing);
      Mat denoised = imread(argv[5], CV_LOAD_IMAGE_GRAYSCALE);
      LRL0PHI lrl0phi(disparityMissing, mask);
      lrl0phi.setParameters(1.2,0.1,lambda_l0,10,0.75);
      lrl0phi.init_U(denoised);
      Mat result = lrl0phi.compute(K, max_iter, inpaintedPath, orig, path1);
      
    }
  else
    {
      cout << "Argument Error!" << endl;
      cout << argv[1] << endl;
    }
  return 0;
}
示例#29
0
Genome Species::ReproduceOne(Population& a_Pop, Parameters& a_Parameters, RNG& a_RNG)
{
    Genome t_baby; // for storing the result

    //////////////////////////
    // Reproduction

    // Spawn only one baby

    // this tells us if the baby is a result of mating
    bool t_mated = false;


    // There must be individuals there..
    ASSERT(NumIndividuals() > 0);

    // for a species of size 1 we can only mutate
    // NOTE: but does it make sense since we know this is the champ?
    if (NumIndividuals() == 1)
    {
        t_baby = GetIndividual(a_Parameters, a_RNG);
        t_mated = false;
    }
    // else we can mate
    else
    {
        Genome t_mom = GetIndividual(a_Parameters, a_RNG);

        // choose whether to mate at all
        // Do not allow crossover when in simplifying phase
        if ((a_RNG.RandFloat() < a_Parameters.CrossoverRate) && (a_Pop.GetSearchMode() != SIMPLIFYING))
        {
            // get the father
            Genome t_dad;
            bool t_interspecies = false;

            // There is a probability that the father may come from another species
            if ((a_RNG.RandFloat() < a_Parameters.InterspeciesCrossoverRate) && (a_Pop.m_Species.size()>1))
            {
                // Find different species (random one) // !!!!!!!!!!!!!!!!!
                // But the different species must have at least one evaluated individual
                int t_diffspec = 0;
                int t_giveup = 64;
                do
                {
                    t_diffspec = a_RNG.RandInt(0, static_cast<int>(a_Pop.m_Species.size()-1));
                }
                while ((a_Pop.m_Species[t_diffspec].m_AverageFitness == 0) && (t_giveup--));

                if (a_Pop.m_Species[t_diffspec].m_AverageFitness == 0)
                    t_dad = GetIndividual(a_Parameters, a_RNG);
                else
                    t_dad = a_Pop.m_Species[t_diffspec].GetIndividual(a_Parameters, a_RNG);

                t_interspecies = true;
            }
            else
            {
                // Mate within species
                t_dad = GetIndividual(a_Parameters, a_RNG);

                // The other parent should be a different one
                // number of tries to find different parent
                int t_tries = 32;
                while(((t_mom.GetID() == t_dad.GetID()) || ((!a_Parameters.AllowClones) && (t_mom.CompatibilityDistance(t_dad, a_Parameters) <= 0.00001)) ) && (t_tries--))
                {
                    t_dad = GetIndividual(a_Parameters, a_RNG);
                }
                t_interspecies = false;
            }

            // OK we have both mom and dad so mate them
            // Choose randomly one of two types of crossover
            if (a_RNG.RandFloat() < a_Parameters.MultipointCrossoverRate)
            {
                t_baby = t_mom.Mate( t_dad, false, t_interspecies, a_RNG);
            }
            else
            {
                t_baby = t_mom.Mate( t_dad, true, t_interspecies, a_RNG);
            }
            t_mated = true;
        }
        // don't mate - reproduce the mother asexually
        else
        {
            t_baby = t_mom;
            t_mated = false;
        }
    }

/*    if (t_baby.HasDeadEnds())
    {
        std::cout << "Dead ends in baby after crossover" << std::endl;
//        int p;
//        std::cin >> p;
    }*/

    // OK we have the baby, so let's mutate it.
    bool t_baby_is_clone = false;

    if ((!t_mated) || (a_RNG.RandFloat() < a_Parameters.OverallMutationRate))
        MutateGenome(t_baby_is_clone, a_Pop, t_baby, a_Parameters, a_RNG);

    // We have a new offspring now
    // give the offspring a new ID
    t_baby.SetID(a_Pop.GetNextGenomeID());
    a_Pop.IncrementNextGenomeID();

    // sort the baby's genes
    t_baby.SortGenes();

    // clear the baby's fitness
    t_baby.SetFitness(0);
    t_baby.SetAdjFitness(0);
    t_baby.SetOffspringAmount(0);

    t_baby.ResetEvaluated();

    // debug trap
/*    if (t_baby.NumLinks() == 0)
    {
        std::cout << "No links in baby after reproduction" << std::endl;
//        int p;
//        std::cin >> p;
    }

    if (t_baby.HasDeadEnds())
    {
        std::cout << "Dead ends in baby after reproduction" << std::endl;
//        int p;
//        std::cin >> p;
    }
*/
    return t_baby;
}
示例#30
0
Spectrum VSDScatteringIntegrator::LiMultiple(const Scene *scene, const Renderer *renderer,
        const RayDifferential &ray, const Sample *sample, RNG &rng,
        Spectrum *T, MemoryArena &arena) const {
    VolumeRegion *vr = scene->volumeRegion;
    float t0, t1;
    vr->IntersectP(ray, &t0, &t1);

    // Do multiple scattering volume integration in _vr_
    Spectrum Lv(0.);

    // Prepare for random walk
    Spectrum Tr(1.f);

    Point p = ray(t0), pPrev = ray.o;

    // printf("%f %f %f, ", p.x, p.y, p.z);

    int steps = 0;
    // Sample the events in a random walk

//    BBox bb = vr->WorldBound();
//    printf("%f %f %f & %f %f %f \n",
//           bb.pMin.x, bb.pMin.y, bb.pMin.z, bb.pMax.x, bb.pMax.y, bb.pMax.z);


    while(vr->WorldBound().Inside(p)) {
        //printf("%f %f %f %d \n", p.x, p.y, p.z, steps);
        steps++;
        // Sample direction
        Vector wi = -ray.d, wo;
        float pdfDirection = 0.f;
        if(!vr->SampleDirection(p, wi, wo, &pdfDirection, rng)) {
            // printf("return 1 \n");
            return Lv;
        }

        Ray r(p, wo, 0);

        // Sample a distance
        float pdfDistance = 0.f;
        float tDist;
        Point pSample;
        if(!vr->SampleDistance(r, &tDist, pSample, &pdfDistance, rng)) {
            // printf("return 2 \n");
            return Lv;
        }

        // Compute the transmittance
        pPrev = p;
        p = r(tDist);
        Ray tauRay(pPrev, p - pPrev, 0.f, 1.f, r.time, r.depth);
        Spectrum stepTau = vr->tau(tauRay, .5f * stepSize, rng.RandomFloat());
        Tr *= Exp(-stepTau);

        // Possibly terminate random walk if transmittance is small
        if (Tr.y() < 1e-3) {
            const float continueProb = .5f;
            if (rng.RandomFloat() > continueProb) {
                Tr = 0.f;
                // printf("return 3 \n");
                break;
            }
            Tr /= continueProb;
        }

        // Compute emission term at _p_
        Lv += Tr * vr->PhotonDensity(p) / (pdfDistance * pdfDirection);
    }

    // printf("%f %f %f %d \n", p.x, p.y, p.z, steps);

   // printf("%d, ", steps);
    return Lv;
}