ReturnType ZoomInOut::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
if(pData != NULL){
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL){
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_result_img == NULL){
m_pre_zoom = m_zoom;
m_result_img = cvCreateImage(cvSize((int)(m_in_width * m_zoom),
(int)(m_in_height * m_zoom)), IPL_DEPTH_8U, 3);
}
// 영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
cvResize(m_orig_img, m_result_img, m_interpolation);
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_result_img->width, m_result_img->height, m_result_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_result_img->width * m_result_img->height * m_result_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_result_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
return OPROS_SUCCESS;
}
ReturnType HVR2300ImageCapture::onExecute()
{
RawImage result; // 데이터 포트타입은 RawImage
BYTE *buff;
buff = new BYTE[m_img_width * m_img_height];
if(1 != HVR_camGetImageData(m_img_width * m_img_height, buff, CAMERA_NO)) {
std::cout<<"Buffer fail"<<std::endl;
Sleep(30);
getFlag = false;
} else {
getFlag = true;
}
if(getFlag == true) {
m_image->imageData = (char*)buff;
cvCvtColor(m_image, m_image_tp, CV_BayerGB2BGR);
// 영상의 복사 작업(영상데이터 & 영상 크기(Pixel수)
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_image_tp->width, m_image_tp->height, m_image_tp->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_image_tp->width * m_image_tp->height * m_image_tp->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_image_tp->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
}
delete buff;
return OPROS_SUCCESS;
}
ReturnType ErodeDilate::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
if(pData != NULL){
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL){
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_gray_img == NULL){
m_gray_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1);
}
if(m_result_img == NULL){
m_result_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
// 영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
if(m_RGB_mode == "Gray"){ // m_RGB_mode:1 흑백
// 컬러영상을 그레이스케일로 변환
cvCvtColor( m_orig_img, m_gray_img, CV_RGB2GRAY );
// 그레이이미지(1채널)을 3채널로 변경, 팽창침식연산위해 다시 m_image_buff에 저장
cvMerge(m_gray_img, m_gray_img, m_gray_img, NULL, m_orig_img);
}
if(m_Change_mode == "Erode"){ // m_change_mode:Erode 침식
cvErode(m_orig_img, m_result_img, NULL, m_Repeat_count);
}else if(m_Change_mode == "Dilate"){ // m_change_mode:Dilate 팽창
cvDilate(m_orig_img, m_result_img, NULL, m_Repeat_count);
}else{
cvCopy(m_orig_img, m_result_img);
}
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_result_img->width, m_result_img->height, m_result_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_result_img->width * m_result_img->height * m_result_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_result_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
return OPROS_SUCCESS;
}
ReturnType Rotate::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
if(pData != NULL){
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL){
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_trans_img == NULL){
m_trans_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_result_img == NULL){
m_result_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
// 영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
//*************************회전
// 회전 중심 위치 설정
CvPoint2D32f center = cvPoint2D32f( m_orig_img->width/2.0, m_orig_img->height/2.0);
// 회전각도에 따른 행렬생성
cv2DRotationMatrix( center, m_angle, 1.0, m_rotate_mat );
// cv2DRotationMatrix( center, 50.0, 1.0, m_rotate_mat );
// 이미지회전
cvWarpAffine( m_orig_img, m_result_img, m_rotate_mat,
CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_result_img->width, m_result_img->height, m_result_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_result_img->width * m_result_img->height * m_result_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_result_img->imageData, size);
// 포트아웃
// opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
return OPROS_SUCCESS;
}
ReturnType ColorTracking::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
// 데이터 포트 백터
std::vector<PositionDataType> data;
if(pData != NULL){
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL){
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_dest_img == NULL){
m_dest_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_hsv_img == NULL){
m_hsv_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_gray_img == NULL){
m_gray_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1);
}
//영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
//HSV변환
cvCvtColor(m_orig_img, m_hsv_img, CV_BGR2HSV);
//hsv 영역 축소 후, 설정값에 따라 해당 영역 이진 영상 추출
color_config(m_hsv_img, m_color);
//영상정리
image_filter(m_gray_img);
//검출 갯수 담을 변수 초기화
circle_cnt = 0;
rect_cnt = 0;
//검출된 원을 위한 메모리 공간 할당
storage0 = cvCreateMemStorage(0);
//원 그리기
draw_circle(m_gray_img);
//사각형 그리기
draw_square(m_gray_img);
//// DataOut
//한가지라도 검출되면
if(circles || rects != NULL)
{
//원 데이터가 존재함
if(circles)
{
//원의 갯수만큼
for(int k = 0; k < circles->total; k++)
{
float* cir;
int circle_x, circle_y;
double radi;
//검출된 원을 저장한 circles에서 원의 파라미터를 cir에 저장
//원의 중심 좌표 및 반지름이 배열에 순서대로 저장됨
cir = (float*)cvGetSeqElem(circles, k);
//검출된 원을 저장한 circles에서 원의 파라미터를 cir에 저장
//원의 중심 좌표 및 반지름이 배열에 순서대로 저장됨
circle_x = cvRound(cir[0]); //중심점 x 좌표
circle_y = cvRound(cir[1]); //중심점 y 좌표
radi = (double)cvRound(cir[2]); //반지름
PositionDataType base;
base.setName("circle");
base.setX(circle_x);
base.setY(circle_y);
base.setRadian(radi);
base.setHeight(NULL);
base.setWidth(NULL);
data.push_back(base);
}
}
//사각형 데이터가 존재함
if(rects != NULL)
{
for(int j = 0; j < rect_cnt; j++)
{
int rect_x, rect_y, rect_width, rect_height;
rect_x = rects[j].x;
rect_y = rects[j].y;
rect_width = rects[j].width;
rect_height = rects[j].height;
PositionDataType base;
base.setName("rectangle");
base.setX(rect_x);
base.setY(rect_y);
base.setHeight(rect_height);
base.setWidth(rect_width);
base.setRadian(NULL);
data.push_back(base);
}
}
PositionOut.push(data);
}
//// ImageOut
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_orig_img->width, m_orig_img->height, m_orig_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_orig_img->width * m_orig_img->height * m_orig_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_orig_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
return OPROS_SUCCESS;
}
ReturnType FrequencyFilter::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
if(pData != NULL) {
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 받은 영상의 2의 승수임을 확인
if(!Check2Square(m_in_width) || !Check2Square(m_in_height)) {
std::cout << "This image is not a multifplier of 2" << std::endl;
return OPROS_BAD_INPUT_PARAMETER;
}
// 받은 영상의 가로 세로 사이즈가 같은지 확인
if(m_in_width != m_in_height) {
std::cout << "Size(width and height) of Image is not equal" << std::endl;
return OPROS_BAD_INPUT_PARAMETER;
}
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL) {
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
// 바이너리 영상영역의 확보
if(m_gray_img == NULL) {
m_gray_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1);
}
// 수행결과 영상영역의 확보
if(m_result_img == NULL) {
m_result_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1);
}
// 출력결과 영상영역의 확보
if(m_final_img == NULL) {
m_final_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
// Re영역 영상영역의 확보(실수)
if(m_image_Re == NULL) {
m_image_Re = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 1);
}
// Im영역 영상영역의 확보(허수)
if(m_image_Im == NULL) {
m_image_Im = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 1);
}
// 주파수 변환 영상영역의 확보.
if(m_pDFT_A == NULL) {
m_pDFT_A = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 2);
}
// 영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
// 둘다 none 이 아니거나, 둘중에 하나가 none 일경우
if((m_low_Pass_Filtering != "none" || m_high_Pass_Filtering != "none") &&
(m_low_Pass_Filtering == "none" || m_high_Pass_Filtering == "none")) {
// 입력 받은 영상을 이진화 시킴
cvCvtColor( m_orig_img, m_gray_img, CV_BGR2GRAY );
// 주파수영역으로의 작업을 위한 깊이 정보 변경
cvConvertScale(m_gray_img, m_image_Re); // 8U -> 32F
// m_image_Im의 초기화
cvZero(m_image_Im);
// shift center
// 입력영상을 실수부로 변환한 이미지가 홀수인 화소의 부호를 변경하여
// 푸리에변환에 의한 주파수 영역의 원점을 중심으로 이동시키기 위함
ChangePosition(m_image_Re);
cvMerge(m_image_Re, m_image_Im, NULL, NULL, m_pDFT_A);
// m_pDFT_A에 대해 푸리에 변환을 수행
cvDFT(m_pDFT_A, m_pDFT_A, CV_DXT_FORWARD);
// 이상적 저주파 통과 필터링 실행
if(m_low_Pass_Filtering == "ideal" && m_high_Pass_Filtering == "none") {
IdealLowPassFiltering(m_pDFT_A, m_cutoff_Frequency);
}
// 버터워스 저주파 통과 필터링 실행
else if(m_low_Pass_Filtering == "butterworth" && m_high_Pass_Filtering == "none") {
ButterworthLowPassFiltering(m_pDFT_A, m_cutoff_Frequency, 2);
}
// 가우시안 저주파 통과 필터링 실행
else if(m_low_Pass_Filtering == "gaussian" && m_high_Pass_Filtering == "none") {
GaussianLowPassFiltering(m_pDFT_A, m_cutoff_Frequency);
}
// 이상적 고주파 통과 필터링 실행
else if(m_high_Pass_Filtering == "ideal" && m_low_Pass_Filtering == "none") {
IdealHighPassFiltering(m_pDFT_A, m_cutoff_Frequency);
}
// 버터워스 고주파 통과 필터링 실행
else if(m_high_Pass_Filtering == "butterworth" && m_low_Pass_Filtering == "none") {
ButterworthHighPassFiltering(m_pDFT_A, m_cutoff_Frequency, 2);
}
// 가우시안 고주파 통과 필터링 실행
else if(m_high_Pass_Filtering == "gaussian" && m_low_Pass_Filtering == "none") {
GaussianHighpassFiltering(m_pDFT_A, m_cutoff_Frequency);
}
else {
//none
}
// 퓨리에 역변환 실행
cvDFT(m_pDFT_A, m_pDFT_A, CV_DXT_INV_SCALE);
// 다중 채널의 행렬을 단일 채널 행렬로 분할(Re, Im으로)
cvSplit(m_pDFT_A, m_image_Re, m_image_Im, NULL, NULL);
// 저주파일때만 실행
if((m_low_Pass_Filtering == "ideal" || m_low_Pass_Filtering == "butterworth" || m_low_Pass_Filtering == "gaussian")
&& m_high_Pass_Filtering == "none") {
ChangePosition(m_image_Re);
cvScale(m_image_Re, m_result_img, 1);
}
// 고주파일때만 실행
if((m_high_Pass_Filtering == "ideal" || m_high_Pass_Filtering == "butterworth" || m_high_Pass_Filtering == "gaussian")
&& m_low_Pass_Filtering == "none") {
// 스펙트럼의 진폭을 계산 Mag=sqrt(Re^2 + Im^2)
cvPow(m_image_Re, m_image_Re, 2.0);
cvPow(m_image_Im, m_image_Im, 2.0);
cvAdd(m_image_Re, m_image_Re, m_image_Re);
cvPow(m_image_Re, m_image_Re, 0.5);
// 진폭 화상의 픽셀치가 min과 max사이에 분포하로독 스케일링
double min_val, max_val;
cvMinMaxLoc(m_image_Re, &min_val, &max_val, NULL, NULL);
cvScale(m_image_Re, m_result_img, 255.0/max_val);
}
// 1채널 영상의 3채널 영상으로의 변환
cvMerge(m_result_img, m_result_img, m_result_img, NULL, m_final_img);
// 아웃풋 push
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_final_img->width, m_final_img->height, m_final_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_final_img->width * m_final_img->height * m_final_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_final_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
} else {
// 아웃풋 push
// 아웃풋 push
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_orig_img->width, m_orig_img->height, m_orig_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_orig_img->width * m_orig_img->height * m_orig_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_orig_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
}
return OPROS_SUCCESS;
}
ReturnType HumanDetection::onExecute()
{
// 영상을 Inport로부터 취득
opros_any *pData = ImageIn.pop();
RawImage result;
std::vector<PositionDataType> data;
if(pData != NULL){
// 포트로 부터 이미지 취득
RawImage Image = ImageIn.getContent(*pData);
RawImageData *RawImage = Image.getImage();
// 현재영상의 크기를 취득
m_in_width = RawImage->getWidth();
m_in_height = RawImage->getHeight();
// 원본영상의 이미지영역 확보
if(m_orig_img == NULL){
m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
if(m_result_img == NULL){
m_result_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3);
}
// 영상에 대한 정보를 확보!memcpy
memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize());
m_img_mat = Mat(m_orig_img);
vector<Rect> found, found_filtered;
m_hog.detectMultiScale(m_img_mat, found, 0, Size(8,8), Size(32,32), 1.05, 2);
int i, j;
// 사이즈의 검출
for(i = 0; i < found.size(); i++){
Rect r = found[i];
for(j = 0; j < found.size(); j++){
if(j != i && (r & found[i]) == r){
break;
}
}
if(j == found.size()){
found_filtered.push_back(r);
}
}
outPoint.x = 0;
outPoint.y = 0;
rect_width = 0;
rect_height = 0;
// 사람 검출에대한 위치지정
for(i = 0; i < found_filtered.size(); i++){
Rect r = found_filtered[i];
r.x += cvRound(r.width*0.1);
r.width = cvRound(r.width*0.8);
r.y += cvRound(r.height*0.07);
r.height = cvRound(r.height*0.8);
rectangle(m_img_mat, r.tl(), r.br(), cv::Scalar(0, 255, 0), 3);
//사각형 시작점 보존
outPoint.x = r.tl().x;
outPoint.y = r.tl().y;
rect_width = r.br().x - r.tl().x;
rect_height = r.br().y - r.tl().y;
}
// 위치 정보 출력
if(outPoint.x != 0 && outPoint.y !=0)
{
PositionDataType base;
base.setName("");
base.setX(outPoint.x);
base.setY(outPoint.y);
base.setHeight(rect_height);
base.setWidth(rect_width);
base.setRadian(NULL);
data.push_back(base);
PositionDataOut.push(data);
}
m_result_img = &IplImage(m_img_mat);
// RawImage의 이미지 포인터 변수 할당
RawImageData *pimage = result.getImage();
// 입력된 이미지 사이즈 및 채널수로 로 재 설정
pimage->resize(m_result_img->width, m_result_img->height, m_result_img->nChannels);
// 영상의 총 크기(pixels수) 취득
int size = m_result_img->width * m_result_img->height * m_result_img->nChannels;
// 영상 데이터로부터 영상값만을 할당하기 위한 변수
unsigned char *ptrdata = pimage->getData();
// 현재 프레임 영상을 사이즈 만큼 memcpy
memcpy(ptrdata, m_result_img->imageData, size);
// 포트아웃
opros_any mdata = result;
ImageOut.push(result);//전달
delete pData;
}
return OPROS_SUCCESS;
}