LocalExpansionStereo FastGCStereo.h

最新推荐文章于 2019-09-19 15:55:45 发布
最新推荐文章于 2019-09-19 15:55:45 发布
阅读量99 收藏
点赞数 
#pragma once
#include "LayerManager.h"
#include "StereoEnergy.h"
#include "Utilities.hpp"
#include "TimeStamper.h"
#include "PMStereoBase.h"
#include "../maxflow/graph.h"

//#define USE_GPU

#define STOP_TIMER(eval) {if(eval != nullptr){eval->stop();}}
#define START_TIMER(eval) {if(eval != nullptr){eval->start();}}

class FastGCStereo : public PMStereoBase
{
public:

protected:
	LayerManager layermng;
	bool doInnerLoopLog;

	void localExpansionMovesForLayer_CPU(const struct LayerManager::Layer& layer, cv::Mat& currentCost, cv::Mat& currentLabeling, cv::Mat& currentLabeling_m, int mode, int i, int iteration, bool doGC = true)
	{
		// typically a 16-time loop
		cv::Mat proposalCost = cv::Mat(height, width, CV_32F);
		for (int j = 0; j < layer.disjointRegionSets.size(); j++)
		{
			//cv::Mat proposalLabeling = cv::Mat(currentLabeling.size(), currentLabeling.type(), INVALID_LABEL.toScalar());

			#pragma omp parallel for
			for (int n = 0; n < layer.disjointRegionSets[j].size(); n++)
			{
				int r = layer.disjointRegionSets[j][n];
				auto& sharedRegion = layer.sharedRegions[r];
				auto& unitRegion = layer.unitRegions[r];
				cv::Mat subCurrentCost = currentCost(sharedRegion);
				cv::Mat subProposalCost = proposalCost(sharedRegion);
				cv::Mat subCurrentLabeling = currentLabeling(sharedRegion);

				StereoEnergy::Reusable reusable;
				for (auto& proposer : layer.proposers)
				{
					auto prop = proposer->createInstance(); // Need to create a new instance for multi-threading
					prop->startIterations(currentLabeling, unitRegion, iteration);
					while (prop->isContinued())
					{
						auto label = prop->getNextProposal();

						stereoEnergy->ComputeUnaryPotential(layer.filterRegions[r], sharedRegion, proposalCost(layer.filterRegions[r]), label, reusable, mode);

						cv::Mat updateMask;
						if (doGC){
							updateMask = cv::Mat_<uchar>(sharedRegion.size());
							expansionMoveBK(updateMask, label, sharedRegion, subProposalCost, mode);
						}
						else {
							updateMask = subCurrentCost > subProposalCost;
						}
						subProposalCost.copyTo(subCurrentCost, updateMask);
						subCurrentLabeling.setTo(label.toScalar(), updateMask);
					}
					delete prop;
				}
			}
			if (debug && evaluator != nullptr && doInnerLoopLog) evaluator->evaluate(currentLabeling_m, currentCost, *stereoEnergy, false, false, false, 0, mode);
			//if (evaluator == nullptr)
			//{
			//	cv::imshow("disp", (stereoEnergy->computeDisparities(currentLabeling) - MIN_DISPARITY) / (MAX_DISPARITY - MIN_DISPARITY));
			//	cv::waitKey(1);
			//}
		}// for each disjoint group
	}


public:
	FastGCStereo(cv::Mat imL, cv::Mat imR, Parameters params, float maxDisparity, float minDisparity = 0, float maxVDisparity = 0)
		: PMStereoBase(imL, imR, params, maxDisparity, minDisparity, maxVDisparity)
		, layermng(imL.cols, imL.rows, params.windR, 0)
	{
		doInnerLoopLog = false;
	}


	virtual ~FastGCStereo(void)
	{
	}

	void addLayer(int unitRegionSize, std::vector<IProposer*> proposers)
	{
		layermng.addLayer(unitRegionSize);
		layermng.layers[layermng.layers.size() - 1].proposers = proposers;
	}

	void initCurrentFast(int mode, cv::Mat& labeling)
	{
		cv::Mat currentCost = currentCost_[mode];
		cv::Mat currentLabeling = currentLabeling_[mode];
		cv::Mat currentLabeling_m = currentLabeling_m_[mode];

		if (labeling.empty())
		{
			currentCost = 0;
			auto& layer = layermng.layers[0];
			#pragma omp parallel for
			for (int j = 0; j < layer.unitRegions.size(); j++){
				cv::Rect unit = layer.unitRegions[j];
				cv::Point pnt = selectRandomPixelInRect(unit);
				auto label = stereoEnergy->createRandomLabel(pnt);
				currentLabeling(unit) = label.toScalar();

				const int R = params.windR;
				cv::Rect filterRegion = cv::Rect(unit.x - R, unit.y - R, unit.width + R * 2, unit.height + R * 2) & imageDomain;
				stereoEnergy->ComputeUnaryPotential(filterRegion, unit, currentCost(filterRegion), label, NaiveStereoEnergy::Reusable(), mode);
			}
		}
		else // May start from a given labeling but this is very slow.
		{
			labeling.copyTo(currentLabeling);

			#pragma omp parallel for
			for (int y = 0; y < height; y++)
			for (int x = 0; x < width; x++)
			{
				const int R = params.windR;
				cv::Rect unit(x, y, 1, 1);
				cv::Rect filterRegion = cv::Rect(unit.x - R, unit.y - R, unit.width + R * 2, unit.height + R * 2) & imageDomain;

				stereoEnergy->ComputeUnaryPotential(filterRegion, unit, currentCost(filterRegion), currentLabeling.at<Plane>(y, x), NaiveStereoEnergy::Reusable(), mode);
			}
		}
	}

	virtual void run(int maxIteration, const std::vector<int>& viewModes = {0, 1}, int pmInit = 0, cv::Mat& labeling = cv::Mat(), cv::Mat& rawlabeling = cv::Mat())
	{
		for (int mode : viewModes)
		{
			currentCost_[mode] = INFINITY;
			initCurrentFast(mode, labeling);
			if (debug && evaluator != nullptr) evaluator->evaluate(currentLabeling_m_[mode], currentCost_[mode], *stereoEnergy, true, true, true, 0, mode);
		}
		START_TIMER(evaluator);

		for (int iteration = 0; iteration < pmInit; iteration++)
		{
			for (int mode : viewModes)
			{
				cv::Mat currentCost = currentCost_[mode];
				cv::Mat currentLabeling = currentLabeling_[mode];
				cv::Mat currentLabeling_m = currentLabeling_m_[mode];

				for (int i = 0; i < layermng.layers.size(); i++){
					const auto& layer = layermng.layers[i];

					localExpansionMovesForLayer_CPU(layer, currentCost, currentLabeling, currentLabeling_m, mode, i, iteration, false);
				}
				if (debug && evaluator != nullptr) evaluator->evaluate(currentLabeling_m, currentCost, *stereoEnergy, true, true, true, iteration + 1, mode);
			}//endfor viewModes

			// Do consistency check at the end of each iteration
			if (debug && viewModes.size() == 2)
			{
				STOP_TIMER(evaluator);
				cv::Mat check0, check1;
				viewConsistencyCheck(check0, check1);
				cv::imwrite(cv::format("%s/result0C%02d.png", saveDir.c_str(), iteration + 1), check0);
				cv::imwrite(cv::format("%s/result1C%02d.png", saveDir.c_str(), iteration + 1), check1);
				START_TIMER(evaluator);
			}
		}

		for (int iteration = 0; iteration < maxIteration; iteration++){
			for (int mode : viewModes)
			{
				cv::Mat currentCost = currentCost_[mode];
				cv::Mat currentLabeling = currentLabeling_[mode];
				cv::Mat currentLabeling_m = currentLabeling_m_[mode];

				for (int i = 0; i < layermng.layers.size(); i++){
					const auto& layer = layermng.layers[i];

					localExpansionMovesForLayer_CPU(layer, currentCost, currentLabeling, currentLabeling_m, mode, i, iteration);
				}
				if (debug && evaluator != nullptr) evaluator->evaluate(currentLabeling_m, currentCost, *stereoEnergy, true, true, true, iteration + 1 + pmInit, mode);

			}//endfor viewModes

			// Do consistency check at the end of each iteration
			if (debug && viewModes.size() == 2)
			{
				STOP_TIMER(evaluator);
				cv::Mat check0, check1;
				viewConsistencyCheck(check0, check1);
				cv::imwrite(cv::format("%s/result0C%02d.png", saveDir.c_str(), iteration + pmInit + 1), check0);
				cv::imwrite(cv::format("%s/result1C%02d.png", saveDir.c_str(), iteration + pmInit + 1), check1);
				START_TIMER(evaluator);
			}
		}

		if (viewModes.size() == 2)
		{
			rawlabeling = currentLabeling_[0].clone();
			postProcess(currentLabeling_[0], currentLabeling_[1], 1.5);
			labeling = currentLabeling_[0].clone();

			if (debug && evaluator != nullptr) evaluator->evaluate(currentLabeling_m_[0], currentCost_[0], *stereoEnergy, true, true, true, maxIteration + 1 + pmInit, 0);
			if (debug && evaluator != nullptr) evaluator->evaluate(currentLabeling_m_[1], currentCost_[1], *stereoEnergy, true, true, true, maxIteration + 1 + pmInit, 1);
			
			if(debug)
			{
				STOP_TIMER(evaluator);
				cv::Mat check0, check1;
				viewConsistencyCheck(check0, check1);
				cv::imwrite(cv::format("%s/result0C%02d.png", saveDir.c_str(), maxIteration + 1 + pmInit), check0);
				cv::imwrite(cv::format("%s/result1C%02d.png", saveDir.c_str(), maxIteration + 1 + pmInit), check1);
				START_TIMER(evaluator);
			}
		}
		else {
			for (int mode : viewModes)
			if(mode == 0)
			{
				rawlabeling = currentLabeling_[0].clone();
				labeling = currentLabeling_[0].clone();
			}
		}
	}


protected:

	cv::Point selectRandomPixelInRect(cv::Rect rect)
	{
		int n = cv::theRNG().uniform(0, rect.height * rect.width);

		int xx = n % rect.width;
		int yy = n / rect.width;
		return cv::Point(rect.x + xx, rect.y + yy);
	}


	double fusionMoveBK(cv::Mat updateMask, const cv::Mat& labeling1_m, cv::Rect region, const cv::Mat proposalCosts, int mode = 0)
	{
		std::vector<cv::Mat> cost00;
		std::vector<cv::Mat> cost01;
		std::vector<cv::Mat> cost10;
		std::vector<cv::Mat> cost11;

		cv::Mat currentCost = currentCost_[mode];
		cv::Mat currentLabeling = currentLabeling_[mode];
		cv::Mat currentLabeling_m = currentLabeling_m_[mode];


		cv::Mat labeling1 = labeling1_m(imageDomain + cv::Point(M, M));
		stereoEnergy->computeSmoothnessTermsFusion(currentLabeling_m, labeling1_m, region, cost00, cost01, cost10, cost11, true);
		// We do not use cost11 here, since they can be ignored with our smoothness term formutation

		int N = region.width * region.height;
		typedef Graph<float, float, double> G;
		G graph(N, 4 * N);

		graph.add_node(N);
		cv::Mat subCurrent = currentCost(region);
		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width; x++){
				int s = y*region.width + x;
				graph.add_tweights(s, subCurrent.at<float>(y, x), proposalCosts.at<float>(y, x));

				bool x0 = x == 0;
				bool x1 = x == region.width - 1;
				bool y0 = y == 0;
				bool y1 = y == region.height - 1;

				if (x0 || x1 || y0 || y1)
				{
					cv::Point ps = cv::Point(x, y) + region.tl();
					for (int k = 0; k < stereoEnergy->neighbors.size(); k++)
					{
						cv::Point pt = ps + stereoEnergy->neighbors[k];
						if (region.contains(pt))
							continue;
						if (imageDomain.contains(pt) == false)
							continue;

						// pt is always label0
						float _cost00 = stereoEnergy->computeSmoothnessTerm(currentLabeling.at<Plane>(ps), currentLabeling.at<Plane>(pt), ps, k, mode);
						float _cost10 = stereoEnergy->computeSmoothnessTerm(labeling1.at<Plane>(ps), currentLabeling.at<Plane>(pt), ps, k, mode);

						graph.add_tweights(s, _cost00, _cost10);
					}
				}
			}
		}

		// ee <-> ge
		// ***
		// **@
		// ***
		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width - 1; x++){
				int i = y*region.width + x;
				int j = y*region.width + x + 1;
				float B = cost10[StereoEnergy::NB_GE].at<float>(y, x);
				float C = cost01[StereoEnergy::NB_GE].at<float>(y, x);
				float D = cost00[StereoEnergy::NB_GE].at<float>(y, x);
				graph.add_edge(i, j, B + C - D, 0);
				graph.add_tweights(i, C, 0);
				graph.add_tweights(j, D - C, 0);
			}
		}

		// ee <-> eg
		// ***
		// ***
		// *@*
		for (int y = 0; y < region.height - 1; y++){
			for (int x = 0; x < region.width; x++){
				int i = y*region.width + x;
				int j = (y + 1)*region.width + x;
				float B = cost10[StereoEnergy::NB_EG].at<float>(y, x);
				float C = cost01[StereoEnergy::NB_EG].at<float>(y, x);
				float D = cost00[StereoEnergy::NB_EG].at<float>(y, x);
				graph.add_edge(i, j, B + C - D, 0);
				graph.add_tweights(i, C, 0);
				graph.add_tweights(j, D - C, 0);
			}
		}

		if (stereoEnergy->neighbors.size() >= 8)
		{
			// ee <-> gg
			// ***
			// ***
			// **@
			for (int y = 0; y < region.height - 1; y++){
				for (int x = 0; x < region.width - 1; x++){
					int i = y*region.width + x;
					int j = (y + 1)*region.width + x + 1;
					float B = cost10[StereoEnergy::NB_GG].at<float>(y, x);
					float C = cost01[StereoEnergy::NB_GG].at<float>(y, x);
					float D = cost00[StereoEnergy::NB_GG].at<float>(y, x);
					graph.add_edge(i, j, B + C - D, 0);
					graph.add_tweights(i, C, 0);
					graph.add_tweights(j, D - C, 0);
				}
			}

			// ee <-> lg
			// ***
			// ***
			// @**
			for (int y = 0; y < region.height - 1; y++){
				for (int x = 1; x < region.width; x++){
					int i = y*region.width + x;
					int j = (y + 1)*region.width + x - 1;
					float B = cost10[StereoEnergy::NB_LG].at<float>(y, x);
					float C = cost01[StereoEnergy::NB_LG].at<float>(y, x);
					float D = cost00[StereoEnergy::NB_LG].at<float>(y, x);
					graph.add_edge(i, j, B + C - D, 0);
					graph.add_tweights(i, C, 0);
					graph.add_tweights(j, D - C, 0);
				}
			}
		}


		double flow = graph.maxflow();

		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width; x++){
				updateMask.at<uchar>(y, x) = graph.what_segment(y*region.width + x) == G::SOURCE ? 255 : 0;
			}
		}

#if 0
		// check if the flow and graph-construciton are correct
		const cv::Point po(M, M);
		cv::Mat newCost = subCurrent.clone();
		proposalCosts.copyTo(newCost, updateMask);
		double _flow = cv::sum(newCost)[0];
		cv::Mat newLabeling_m = currentLabeling_m.clone();
		newLabeling_m(region + po).setTo(label1.toScalar(), updateMask);

		cv::Rect region_m = cv::Rect(region.x - M, region.y - M, region.width + 2 * M, region.height + 2 * M) & imageDomain;

		for (int y = region_m.y; y < region_m.y + region_m.height; y++)
		for (int x = region_m.x; x < region_m.x + region_m.width; x++){
			cv::Point ps(x, y);

			for (int i = 0; i < stereoEnergy->neighbors.size(); i++)
			{
				cv::Point n = stereoEnergy->neighbors[i];
				cv::Point pt = ps + n;
				if (imageDomain.contains(pt) == false)
					continue;
				if (region.contains(ps) == false && region.contains(pt) == false)
					continue;

				// if forward
				if (n.y > 0 || (n.y == 0 && n.x > 0))
				{
					_flow += stereoEnergy->computeSmoothnessTerm(newLabeling_m.at<Plane>(ps + po), newLabeling_m.at<Plane>(pt + po), ps, pt);
				}
			}
		}
		printf("f1 = %lf, f2 = %lf, df = %lf\n", flow, _flow, (flow - _flow) / _flow);
		CV_Assert(fabs(flow - _flow) <= _flow * 1e-5);
#endif

		return flow;
	}
	double expansionMoveBK(cv::Mat updateMask, const Plane label1, const cv::Rect region, const cv::Mat proposalCosts, int mode = 0)
	{
		std::vector<cv::Mat> cost00;
		std::vector<cv::Mat> cost01;
		std::vector<cv::Mat> cost10;

		cv::Mat currentCost = currentCost_[mode];
		cv::Mat currentLabeling = currentLabeling_[mode];
		cv::Mat currentLabeling_m = currentLabeling_m_[mode];


		stereoEnergy->computeSmoothnessTermsExpansion(currentLabeling_m, label1, region, cost00, cost01, cost10, true, mode);

		int N = region.width * region.height;
		typedef Graph<float, float, double> G;
		G graph(N, 4 * N);

		graph.add_node(N);
		cv::Mat subCurrent = currentCost(region);
		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width; x++){
				int s = y*region.width + x;
				graph.add_tweights(s, subCurrent.at<float>(y, x), proposalCosts.at<float>(y, x));

				bool x0 = x == 0;
				bool x1 = x == region.width - 1;
				bool y0 = y == 0;
				bool y1 = y == region.height - 1;

				if (x0 || x1 || y0 || y1)
				{
#if 0
					if (x0)
						graph.add_tweights(s, cost00[StereoEnergy::NB_LE].at<float>(y, x), cost10[StereoEnergy::NB_LE].at<float>(y, x));
					if (x1)
						graph.add_tweights(s, cost00[StereoEnergy::NB_GE].at<float>(y, x), cost10[StereoEnergy::NB_GE].at<float>(y, x));
					if (y0)
						graph.add_tweights(s, cost00[StereoEnergy::NB_EL].at<float>(y, x), cost10[StereoEnergy::NB_EL].at<float>(y, x));
					if (y1)
						graph.add_tweights(s, cost00[StereoEnergy::NB_EG].at<float>(y, x), cost10[StereoEnergy::NB_EG].at<float>(y, x));

					if (x0 || y0)
						graph.add_tweights(s, cost00[StereoEnergy::NB_LL].at<float>(y, x), cost10[StereoEnergy::NB_LL].at<float>(y, x));
					if (x1 || y0)
						graph.add_tweights(s, cost00[StereoEnergy::NB_GL].at<float>(y, x), cost10[StereoEnergy::NB_GL].at<float>(y, x));
					if (x0 || y1)
						graph.add_tweights(s, cost00[StereoEnergy::NB_LG].at<float>(y, x), cost10[StereoEnergy::NB_LG].at<float>(y, x));
					if (x1 || y1)
						graph.add_tweights(s, cost00[StereoEnergy::NB_GG].at<float>(y, x), cost10[StereoEnergy::NB_GG].at<float>(y, x));
#else
					cv::Point ps = cv::Point(x, y) + region.tl();
					for (int k = 0; k < stereoEnergy->neighbors.size(); k++)
					{
						cv::Point pt = ps + stereoEnergy->neighbors[k];
						if (region.contains(pt))
							continue;
						if (imageDomain.contains(pt) == false)
							continue;

						// pt is always label0
						float _cost00 = stereoEnergy->computeSmoothnessTerm(currentLabeling.at<Plane>(ps), currentLabeling.at<Plane>(pt), ps, k, mode);
						float _cost10 = stereoEnergy->computeSmoothnessTerm(label1, currentLabeling.at<Plane>(pt), ps, k, mode);

						graph.add_tweights(s, _cost00, _cost10);
					}
#endif
				}
			}
		}

		// ee <-> ge
		// ***
		// **@
		// ***
		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width - 1; x++){
				int i = y*region.width + x;
				int j = y*region.width + x + 1;
				float B = cost10[StereoEnergy::NB_GE].at<float>(y, x);
				float C = cost01[StereoEnergy::NB_GE].at<float>(y, x);
				float D = cost00[StereoEnergy::NB_GE].at<float>(y, x);
				graph.add_edge(i, j, std::max(0.f, B + C - D), 0); // Values B+C-D can be slightly negative due to numerical errors
				graph.add_tweights(i, C, 0);
				graph.add_tweights(j, D - C, 0);
			}
		}

		// ee <-> eg
		// ***
		// ***
		// *@*
		for (int y = 0; y < region.height - 1; y++){
			for (int x = 0; x < region.width; x++){
				int i = y*region.width + x;
				int j = (y + 1)*region.width + x;
				float B = cost10[StereoEnergy::NB_EG].at<float>(y, x);
				float C = cost01[StereoEnergy::NB_EG].at<float>(y, x);
				float D = cost00[StereoEnergy::NB_EG].at<float>(y, x);
				graph.add_edge(i, j, std::max(0.f, B + C - D), 0);
				graph.add_tweights(i, C, 0);
				graph.add_tweights(j, D - C, 0);
			}
		}

		if (stereoEnergy->neighbors.size() >= 8)
		{
			// ee <-> lg
			// ***
			// ***
			// @**
			for (int y = 0; y < region.height - 1; y++){
				for (int x = 1; x < region.width; x++){
					int i = y*region.width + x;
					int j = (y + 1)*region.width + x - 1;
					float B = cost10[StereoEnergy::NB_LG].at<float>(y, x);
					float C = cost01[StereoEnergy::NB_LG].at<float>(y, x);
					float D = cost00[StereoEnergy::NB_LG].at<float>(y, x);
					graph.add_edge(i, j, std::max(0.f, B + C - D), 0);
					graph.add_tweights(i, C, 0);
					graph.add_tweights(j, D - C, 0);
				}
			}

			// ee <-> gg
			// ***
			// ***
			// **@
			for (int y = 0; y < region.height - 1; y++){
				for (int x = 0; x < region.width - 1; x++){
					int i = y*region.width + x;
					int j = (y + 1)*region.width + x + 1;
					float B = cost10[StereoEnergy::NB_GG].at<float>(y, x);
					float C = cost01[StereoEnergy::NB_GG].at<float>(y, x);
					float D = cost00[StereoEnergy::NB_GG].at<float>(y, x);
					graph.add_edge(i, j, std::max(0.f, B + C - D), 0);
					graph.add_tweights(i, C, 0);
					graph.add_tweights(j, D - C, 0);
				}
			}

		}

		double flow = graph.maxflow();

		for (int y = 0; y < region.height; y++){
			for (int x = 0; x < region.width; x++){
				updateMask.at<uchar>(y, x) = graph.what_segment(y*region.width + x) == G::SOURCE ? 255 : 0;
			}
		}

#if 0
		// check if the flow and graph-construciton are correct
		const cv::Point po(M, M);
		cv::Mat newCost = subCurrent.clone();
		proposalCosts.copyTo(newCost, updateMask);
		double _flow = cv::sum(newCost)[0];
		cv::Mat newLabeling_m = currentLabeling_m.clone();
		newLabeling_m(region + po).setTo(label1.toScalar(), updateMask);

		cv::Rect region_m = cv::Rect(region.x - M, region.y - M, region.width + 2 * M, region.height + 2 * M) & imageDomain;

		for (int y = region_m.y; y < region_m.y + region_m.height; y++)
		for (int x = region_m.x; x < region_m.x + region_m.width; x++){
			cv::Point ps(x, y);

			for (int i = 0; i < pmEnergy->neighbors.size(); i++)
			{
				cv::Point n = pmEnergy->neighbors[i];
				cv::Point pt = ps + n;
				if (imageDomain.contains(pt) == false)
					continue;
				if (region.contains(ps) == false && region.contains(pt) == false)
					continue;

				// if forward
				if (n.y > 0 || (n.y == 0 && n.x > 0))
				{
					_flow += pmEnergy->computeSmoothnessTerm(newLabeling_m.at<Plane>(ps + po), newLabeling_m.at<Plane>(pt + po), ps, pt);
				}
			}
		}
		printf("f1 = %lf, f2 = %lf, df = %lf\n", flow, _flow, (flow - _flow) / _flow);
		CV_Assert(fabs(flow - _flow) <= _flow * 1e-5);
#endif

		return flow;
	}
};
weixin_39273207
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三维重建之视图差的计算--SGBM和GC算法
blank_screen的博客
04-15 8714
最近一直在做三维重建的毕业设计，看了好多的算法、论文和代码。在查找资料的过程中发现很多人上传的东西真的是没法用，而且全都要积分。我虽说是一个水货，也不致力于从事着方面的研究和工作，但是为了毕设也没办法，目前调通了很多算法，虽然说不清原理，但是还是把代码创传上来，供大家使用。 一、win32项目工程，stereo vision1 1、头文件： #include "stdafx.h" #
立体匹配 -- GC-Net网络结构分析
weixin_41405284的博客
10-30 5495
参考 GC-Net pytorch版本 首先看代码要对应着网络结构图和网络层的表格。 一.Unary Features 特征提取 1.使用2-D卷积提取深度特征。首先使用fiter size:5*5,stride:2的conv2d 将输入降维(1/2H,1/2W). imgl0=F.relu(self.bn0(self.conv0(imgLeft))) imgr0=F.relu(self.bn0(self.conv0(imgRight))) self.conv0=nn.Conv2d(3,3.
local expansion
weeeeeida的博客
09-08 1096
local expansion解读 1.graph cut（分成前景和背景） 2.Alpha-expansion（分成多个平滑平面） 3.local-expansion grab cut 主要目的：通过在前景和背景各画几画作为输入，将建立各个像素点与前景背景相似度的赋权图，通过求解最小切割区分为前景和后景。 图的定义 顶点集V,边集E,图G可以定义为有序对G=(...
论文《Continuous 3D Label Stereo Matching using Local Expansion Moves》学习
Orange_Wu的博客
09-19 1272
Abstract （SCI一区）提出了一种基于图割的局部展开运动的精确立体匹配方法。这种新的运动生成方法被用来有效地在一对马尔可夫随机场(MRF)上推断每个像素的三维平面标签，该随机场有效地结合了最近提出的斜斑匹配和曲率正则化项。对于小网格区域，局部展开运动表现为定义的多个α-展开。局部扩张运动通过两种方式扩展了传统的扩张运动：局部化和空间传播。通过定位，我们根据局部α展开的位置使用不同的候选α-...
opencv stereo 解析
billbliss的专栏
06-19 2067
双目测距与三维重建的OpenCV实现问题集锦（一）图像获取与单目定标https://blog.csdn.net/chenyusiyuan/article/details/5961769双目测距与三维重建的OpenCV实现问题集锦（二）双目定标与双目校正https://blog.csdn.net/chenyusiyuan/article/details/5963256双目测距与三维重建的OpenCV...
双目立体视觉匹配算法-----SAD匹配算法、BM算法、SGBM算法、GC算法
热门推荐
liulina603的专栏
11-23 7万+
一、 SAD算法 1.算法原理         SAD(Sum of absolute differences)是一种图像匹配算法。基本思想：差的绝对值之和。此算法常用于图像块匹配，将每个像素对应数值之差的绝对值求和，据此评估两个图像块的相似度。该算法快速、但并不精确，通常用于多级处理的初步筛选。 2.基本流程 输入：两幅图像，一幅Left-Image，一幅Right-Im
GC算法：GC算法
02-09
GC算法笔记
【视觉=立体视觉】立体匹配算法 StereoBM/StereoSGBM/StereoVar（OpenCV中源码分析）+SAD块匹配算法+GC算法+HH算法
开源节流
02-04 1万+
OpenCV2源码： // OpenCVTest.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include /* * stereo_match.cpp * calibration * * Created by Victor Eruhimov on 1/18/10. * Copyright 2010 Argus Corp. All
LocalExpansionStereo ArgsParser.h
weixin_39273207的博客
07-26 106
#pragma once #include <vector> #include <map> #include <string> class ArgsParser { std::vector<std::string> args; std::map<std::string, std::string> argMap; void par...
LocalExpansionStereo PMStereoBase.h
weixin_39273207的博客
07-26 107
#pragma once #include "StereoEnergy.h" #include "Utilities.hpp" #include "Evaluator.h" #include <vector> class PMStereoBase { public: bool debug; std::string saveDir; protected: cv::Mat cur...
OpenCV中GC方法求视差图的实现
gsw2276435493gsw的博客
03-31 8110
前段时间需要用到GC方法实现视差图，参考了http://blog.csdn.net/mailang2008/article/details/5873883的内容， 试验之后发现还有一些需要注意的地方，记录下来方便以后查看 1.影像的读取 由于GC方法要求左右影像均是8位的灰度图像故读取影像时需要进行一次转换。 //读取左右影像 IplImage* pImgleft = cvLoadIma
红色龙年2024新年工作计划PPT模板
07-13
【作品名称】：红色龙年2024新年工作计划PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
项目管理策划编写模板.docx
07-13
项目管理策划编写模板.docx
架子管及扣件现场管理规定.docx
07-13
架子管及扣件现场管理规定.docx
Swift语言教程&案例.docx
07-13
Swift 是由 Apple 开发的一种现代、安全、快速的编程语言，适用于 iOS、macOS、watchOS 和 tvOS 应用程序开发。以下是一个详细的 Swift 语言教程，适合初学者逐步学习。
ctf_tools_list.md
07-13
ctf_tools_list
巴比达内网穿透.txt
07-13
巴比达内网穿透
URL编码.exe
07-13
URL编码
scipy-1.10.0rc1-cp39-cp39-manylinux-2-17-x86-64.manylinux2014-x8
最新发布
07-13
scipy-1.10.0rc1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值