C++그 레이스 케 일 기반 Gray ToColorFromOther 구현

장면 수요
       이전에 그 레이스 케 일 에 색 을 칠 하 는 수요 가 언급 되 었 는데 이 를 바탕 으로 또 다른 수요 가 있다.바로 그 레이스 케 일 을 참고 하 는 색 판 을 바탕 으로 현재 의 그 레이스 케 일 에 색 을 칠 하 는 것 이다.예 를 들 어 그 레이스 케 일 그림 의 수치 구간 은-10 에서 10 이 고 색 채 는 파란색 에서 녹색 에서 빨간색 까지 이 며 현재 의 그 레이스 케 일 그림 의 데이터 구간 은-1 에서 1 이다.만약 에 그 레이스 케 일 을 참고 하 는 색 판 을 바탕 으로 데이터 에 대응 하 는 색 채 를 확인한다 면 현재 그 레이스 케 일 그림 의 색 채 는 녹색 좌우 에서 변동 해 야 한다.
       아래 는 함수 와 테스트 코드 를 구체 적 으로 실현 합 니 다.
기능 함수 코드

/**
 * @brief GrayToColorFromOther                  ,          
 * @param phase1                                  ,   1,    
 * @param phase2                                  ,   1,  phase1     
 * @return                                       
 */
cv::Mat GrayToColorFromOther(cv::Mat &phase1, cv::Mat &phase2)
{
	CV_Assert(phase1.channels() == 1);
	CV_Assert(phase2.channels() == 1);
	if (phase1.empty() || phase2.empty())
	{
		cv::Mat result = cv::Mat::zeros(100, 100, CV_8UC3);
		return result;
	}
	cv::Mat temp, result, mask;
	double max1, min1;
	int row = phase2.rows;
	int col = phase2.cols;
	//             
	cv::minMaxIdx(phase1, &min1, &max1, nullptr, nullptr, phase1 == phase1);
	//                     ,      
	temp = phase2.clone();
	for (int i = 0; i < row; ++i)
	{
		float *t2 = temp.ptr<float>(i);
		for (int j = 0; j < col; ++j)
		{
			t2[j] = 255.0f*(phase2.at<float>(i, j) - min1) / (max1 - min1);
		}
	}
	temp.convertTo(temp, CV_8UC1);
	//     ,       nan    
	mask = cv::Mat::zeros(phase2.size(), CV_8UC1);
	mask.setTo(255, phase2 == phase2);
 
	//          
	cv::Mat color1, color2, color3;
	color1 = cv::Mat::zeros(temp.size(), temp.type());
	color2 = cv::Mat::zeros(temp.size(), temp.type());
	color3 = cv::Mat::zeros(temp.size(), temp.type());
 
	//           ,    ,      0   (255,0,0),      255   (0,0,255),      127   (0,255,0)
	for (int i = 0; i < row; ++i)
	{
		uchar *c1 = color1.ptr<uchar>(i);
		uchar *c2 = color2.ptr<uchar>(i);
		uchar *c3 = color3.ptr<uchar>(i);
		uchar *r = temp.ptr<uchar>(i);
		uchar *m = mask.ptr<uchar>(i);
		for (int j = 0; j < col; ++j)
		{
			if (m[j] == 255)
			{
				if (r[j] > (3 * 255 / 4) && r[j] <= 255)
				{
					c1[j] = 255;
					c2[j] = 4 * (255 - r[j]);
					c3[j] = 0;
				}
				else if (r[j] <= (3 * 255 / 4) && r[j] > (255 / 2))
				{
					c1[j] = 255 - 4 * (3 * 255 / 4 - r[j]);
					c2[j] = 255;
					c3[j] = 0;
				}
				else if (r[j] <= (255 / 2) && r[j] > (255 / 4))
				{
					c1[j] = 0;
					c2[j] = 255;
					c3[j] = 4 * (255 / 2 - r[j]);
				}
				else if (r[j] <= (255 / 4) && r[j] >= 0)
				{
					c1[j] = 0;
					c2[j] = 255 - 4 * (255 / 4 - r[j]);
					c3[j] = 255;
				}
				else {
					c1[j] = 0;
					c2[j] = 0;
					c3[j] = 0;
				}
			}
		}
	}
 
	//      ,     
	vector<cv::Mat> images;
	images.push_back(color3);
	images.push_back(color2);
	images.push_back(color1);
	cv::merge(images, result);
 
	return result;
}
C++테스트 코드

#include<iostream>
#include<opencv2/opencv.hpp>
#include<ctime>
using namespace std;
using namespace cv;
 
void UnitPolar(int squaresize, cv::Mat& mag,cv::Mat& ang);
void UnitCart(int squaresize, cv::Mat& x, cv::Mat& y);
cv::Mat GrayToColor(cv::Mat &phase);
cv::Mat GrayToColorFromOther(cv::Mat &phase1, cv::Mat &phase2);
 
int main(void)
{
	cv::Mat mag, ang,result,result2;
	UnitPolar(2001, mag, ang);
	mag.at<float>(10, 10) = nan("");
	cv::Mat mag2 = mag / 2;
 
	result = GrayToColor(mag);
	result2= GrayToColorFromOther(mag,mag2);
 
	system("pause");
	return 0;
}
 
void UnitPolar(int squaresize, cv::Mat& mag,cv::Mat& ang) {
	cv::Mat x;
	cv::Mat y;
	UnitCart(squaresize, x, y);                //              ,        
	// OpenCV          ,          
	//cv::cartToPolar(x, y, mag, ang, false); //    
 
	mag = cv::Mat(x.size(), x.type());
	ang = cv::Mat(x.size(), x.type());
	int row = mag.rows;
	int col = mag.cols;
	float *m, *a, *xx, *yy;
	for (int i = 0; i < row; ++i)
	{
		m = mag.ptr<float>(i);
		a = ang.ptr<float>(i);
		xx = x.ptr<float>(i);
		yy = y.ptr<float>(i);
		for (int j = 0; j < col; ++j)
		{
			m[j] = sqrt(xx[j] * xx[j] + yy[j] * yy[j]);
			a[j] = atan2(yy[j], xx[j]);
		}
	}
}
 
void UnitCart(int squaresize, cv::Mat& x, cv::Mat& y) {
	CV_Assert(squaresize % 2 == 1);
	x.create(squaresize, squaresize, CV_32FC1);
	y.create(squaresize, squaresize, CV_32FC1);
	//    
	x.col(0).setTo(-1.0);
	x.col(squaresize - 1).setTo(1.0f);
	y.row(0).setTo(1.0);
	y.row(squaresize - 1).setTo(-1.0f);
 
	float delta = 2.0f / (squaresize - 1.0f);  //       
 
	//        
	for (int i = 1; i < squaresize - 1; ++i) {
		x.col(i) = -1.0f + i * delta;
		y.row(i) = 1.0f - i * delta;
	}
}
 
/**
 * @brief GrayToColor                           
 * @param phase                                   ,   1
 * @return                                       
 */
cv::Mat GrayToColor(cv::Mat &phase)
{
	CV_Assert(phase.channels() == 1);
 
	cv::Mat temp, result, mask;
	//           0-255
	cv::normalize(phase, temp, 255, 0, cv::NORM_MINMAX);
	temp.convertTo(temp, CV_8UC1);
	//     ,       nan    
	mask = cv::Mat::zeros(phase.size(), CV_8UC1);
	mask.setTo(255, phase == phase);
 
	//          
	cv::Mat color1, color2, color3;
	color1 = cv::Mat::zeros(temp.size(), temp.type());
	color2 = cv::Mat::zeros(temp.size(), temp.type());
	color3 = cv::Mat::zeros(temp.size(), temp.type());
	int row = phase.rows;
	int col = phase.cols;
 
	//           ,    ,      0   (255,0,0),      255   (0,0,255),      127   (0,255,0)
	//           (255,0,0),  OpenCV  BGR   RGB
	for (int i = 0; i < row; ++i)
	{
		uchar *c1 = color1.ptr<uchar>(i);
		uchar *c2 = color2.ptr<uchar>(i);
		uchar *c3 = color3.ptr<uchar>(i);
		uchar *r = temp.ptr<uchar>(i);
		uchar *m = mask.ptr<uchar>(i);
		for (int j = 0; j < col; ++j)
		{
			if (m[j] == 255)
			{
				if (r[j] > (3 * 255 / 4) && r[j] <= 255)
				{
					c1[j] = 255;
					c2[j] = 4 * (255 - r[j]);
					c3[j] = 0;
				}
				else if (r[j] <= (3 * 255 / 4) && r[j] > (255 / 2))
				{
					c1[j] = 255 - 4 * (3 * 255 / 4 - r[j]);
					c2[j] = 255;
					c3[j] = 0;
				}
				else if (r[j] <= (255 / 2) && r[j] > (255 / 4))
				{
					c1[j] = 0;
					c2[j] = 255;
					c3[j] = 4 * (255 / 2 - r[j]);
				}
				else if (r[j] <= (255 / 4) && r[j] >= 0)
				{
					c1[j] = 0;
					c2[j] = 255 - 4 * (255 / 4 - r[j]);
					c3[j] = 255;
				}
				else {
					c1[j] = 0;
					c2[j] = 0;
					c3[j] = 0;
				}
			}
		}
	}
 
	//      ,     
	vector<cv::Mat> images;
	images.push_back(color3);
	images.push_back(color2);
	images.push_back(color1);
	cv::merge(images, result);
 
	return result;
}
 
/**
 * @brief GrayToColorFromOther                  ,          
 * @param phase1                                  ,   1,    
 * @param phase2                                  ,   1,  phase1     
 * @return                                       
 */
cv::Mat GrayToColorFromOther(cv::Mat &phase1, cv::Mat &phase2)
{
	CV_Assert(phase1.channels() == 1);
	CV_Assert(phase2.channels() == 1);
	if (phase1.empty() || phase2.empty())
	{
		cv::Mat result = cv::Mat::zeros(100, 100, CV_8UC3);
		return result;
	}
	cv::Mat temp, result, mask;
	double max1, min1;
	int row = phase2.rows;
	int col = phase2.cols;
	//             
	cv::minMaxIdx(phase1, &min1, &max1, nullptr, nullptr, phase1 == phase1);
	//                     ,      
	temp = phase2.clone();
	for (int i = 0; i < row; ++i)
	{
		float *t2 = temp.ptr<float>(i);
		for (int j = 0; j < col; ++j)
		{
			t2[j] = 255.0f*(phase2.at<float>(i, j) - min1) / (max1 - min1);
		}
	}
	temp.convertTo(temp, CV_8UC1);
	//     ,       nan    
	mask = cv::Mat::zeros(phase2.size(), CV_8UC1);
	mask.setTo(255, phase2 == phase2);
 
	//          
	cv::Mat color1, color2, color3;
	color1 = cv::Mat::zeros(temp.size(), temp.type());
	color2 = cv::Mat::zeros(temp.size(), temp.type());
	color3 = cv::Mat::zeros(temp.size(), temp.type());
 
	//           ,    ,      0   (255,0,0),      255   (0,0,255),      127   (0,255,0)
	for (int i = 0; i < row; ++i)
	{
		uchar *c1 = color1.ptr<uchar>(i);
		uchar *c2 = color2.ptr<uchar>(i);
		uchar *c3 = color3.ptr<uchar>(i);
		uchar *r = temp.ptr<uchar>(i);
		uchar *m = mask.ptr<uchar>(i);
		for (int j = 0; j < col; ++j)
		{
			if (m[j] == 255)
			{
				if (r[j] > (3 * 255 / 4) && r[j] <= 255)
				{
					c1[j] = 255;
					c2[j] = 4 * (255 - r[j]);
					c3[j] = 0;
				}
				else if (r[j] <= (3 * 255 / 4) && r[j] > (255 / 2))
				{
					c1[j] = 255 - 4 * (3 * 255 / 4 - r[j]);
					c2[j] = 255;
					c3[j] = 0;
				}
				else if (r[j] <= (255 / 2) && r[j] > (255 / 4))
				{
					c1[j] = 0;
					c2[j] = 255;
					c3[j] = 4 * (255 / 2 - r[j]);
				}
				else if (r[j] <= (255 / 4) && r[j] >= 0)
				{
					c1[j] = 0;
					c2[j] = 255 - 4 * (255 / 4 - r[j]);
					c3[j] = 255;
				}
				else {
					c1[j] = 0;
					c2[j] = 0;
					c3[j] = 0;
				}
			}
		}
	}
 
	//      ,     
	vector<cv::Mat> images;
	images.push_back(color3);
	images.push_back(color2);
	images.push_back(color1);
	cv::merge(images, result);
 
	return result;
}
테스트 효과
 
그림 1 그 레이스 케 일 색상 효과 참조
 
그림 2 그 레이스 케 일 팔레트 의 색칠 효과 참조
       위의 그림 에서 보 듯 이 편 의 를 위해 저 는 2001*2001 의 이미지 행렬 을 만 들 었 고 다른 대비 이미 지 를 설 치 했 습 니 다.이 이미 지 는 원래 이미지 의 1/2 입 니 다.그러면 원래 이미 지 는 그 레이스 케 일 을 참고 하 는 것 이 고 대비 이미 지 는 그 레이스 케 일 팔레트 의 그 레이스 케 일 을 참고 하 는 것 입 니 다.그림 1 은 그 레이스 케 일의 색칠 효 과 를 참고 하기 위해 그림 2 는 그 레이스 케 일 팔레트 를 참고 하여 이미지 에 색칠 을 하 는 효과 그림 이다.원래 이미지 의 데 이 터 는 0-1.3 정도 이 고 그 색채 변 화 는 파란색 에서 녹색 에서 빨간색 까지 이 며 이미지 의 데 이 터 를 0-1.3/2 정도 비교 하면 색채 가 파란색 에서 녹색 으로 변화 하여 앞에서 언급 한 수 요 를 만족 시 켰 다.
C++그 레이스 케 일 기반 Gray ToColor FromOther 구현 에 관 한 이 글 은 여기까지 소개 되 었 습 니 다.더 많은 C+그 레이스 케 일 기반 Gray ToColor FromOther 내용 은 저희 의 이전 글 을 검색 하거나 아래 의 관련 글 을 계속 찾 아 보 세 요.앞으로 도 많은 응원 부 탁 드 리 겠 습 니 다!

좋은 웹페이지 즐겨찾기