void InitNodeBuf(Node *nodes, const unsigned char *img, int imgWidth, int imgHeight)
{
int nodeIndex = 0;
for (int row = 0; row < imgHeight; row++)
{
for (int col = 0; col < imgWidth; col++){
Node& curNode = nodes[nodeIndex++];
curNode.column = col;
curNode.row = row;
curNode.prevNode = NULL;
}
}
//Calculate MaxD and d-links for each pixel for each kernel
double **dlink = new double*[8];
double maxDlink = 0;
for (int i = 0; i < 8; i++)
{
double *rsltImg = new double[imgWidth * imgHeight * 3];
image_filter(rsltImg, img, NULL, imgWidth, imgHeight, kernels[i], 3, 3, 1./2., 0.);
// Matrix[i][j] where i = link and j = node
dlink[i] = new double[imgWidth * imgHeight];
for (int row = 0; row < imgHeight; row++)
{
for (int col = 0; col < imgWidth; col++)
{
double sum = pow(rsltImg[3*(row*imgWidth+col)+0],2) + pow(rsltImg[3*(row*imgWidth+col)+1],2) +
pow(rsltImg[3*(row*imgWidth+col)+2],2);
double magnitude = sqrt((sum/3.));
dlink[i][row*imgWidth+col] = magnitude;
maxDlink = (maxDlink > magnitude) ? maxDlink : magnitude;
}
}
delete [] rsltImg;
}
for (nodeIndex = 0; nodeIndex < imgWidth * imgHeight; nodeIndex++)
{
Node& curNode = nodes[nodeIndex];
for (int linkIndex = 0; linkIndex < 8; linkIndex++)
{
double deriv = dlink[linkIndex][nodeIndex];
// Relies on odd-numbered links being diagonal
double cost = (maxDlink - deriv) * ((linkIndex % 2 == 0) ? 1 : SQRT2);
curNode.linkCost[linkIndex] = cost;
}
}
for (int i = 0; i < 8; i++)
{
delete [] dlink[i];
}
delete [] dlink;
}
void InitNodeBuf(Node *nodes, const unsigned char *img, int imgWidth, int imgHeight)
{
int knlWidth, knlHeight;
knlWidth = knlHeight = 3; // Currently kernels are 3 x 3
double maxD = 0;
for (int link = 0; link < 8; link++)
{
double *filterImg = new double[imgWidth * imgHeight * 3];
image_filter(filterImg,
img,
NULL,
imgWidth,
imgHeight,
kernels[link],
knlWidth,
knlHeight,
1,
0);
for (int row = 0; row < imgHeight; row++)
{
for (int col = 0; col < imgWidth; col++)
{
double sum = 0;
for (int color = 0; color < 3; color++)
{
double cost = filterImg[3 * (row * imgWidth + col) + color];
if (cost > maxD)
maxD = cost;
sum += cost * cost;
}
sum = sqrt(sum/3);
nodes[row * imgWidth + col].linkCost[link] = sum;
}
}
delete[] filterImg;
}
// Once maxD is determined, compute the final cost for each link.
for (int row = 0; row < imgHeight; row++)
{
for (int col = 0; col < imgWidth; col++)
{
Node *node = nodes + row * imgWidth + col;
node->column = col;
node->row = row;
for (int link = 0; link < 8; link++)
{
node->linkCost[link] = maxD - node->linkCost[link];
node->linkCost[link] *= (link % 2 == 0) ? 1 : SQRT2;
}
}
}
}
/* Begin the Main Function */
int main(int argc, char *argv[])
{
int npes, myrank;
int r, c; // actual image size
int pict[IM_SIZE][IM_SIZE];
int new_pict[IM_SIZE][IM_SIZE];
double flt[FILTER_SIZE][FILTER_SIZE]={{-1.25, 0, -1.25},
{0, 10, 0},
{-1.25, 0, -1.25}};
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&npes);
MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
/* master initializes work*/
if (myrank == 0) {
read_pict(pict, &r, &c);
} /* 8/4/2013 */
MPI_Bcast(&r, 1, MPI_INT, 0, MPI_COMM_WORLD); /* 8/4/2013 */
MPI_Bcast(&c, 1, MPI_INT, 0, MPI_COMM_WORLD); /* 8/4/2013 */
image_filter(pict, r, c, flt, new_pict, npes, myrank); /* 8/8/2013*/
/* 0 write */
if(myrank==0){
write_pict(new_pict, r, c);
} /* 8/4/2013 */
MPI_Finalize();
return(0);
/* End Main Function */
}
MagickExport MagickBooleanType InvokeStaticImageFilter(const char *tag,
Image **image,const int argc,const char **argv,ExceptionInfo *exception)
{
PolicyRights
rights;
assert(image != (Image **) NULL);
assert((*image)->signature == MagickSignature);
if ((*image)->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
rights=ReadPolicyRights;
if (IsRightsAuthorized(FilterPolicyDomain,rights,tag) == MagickFalse)
{
errno=EPERM;
(void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
"NotAuthorized","`%s'",tag);
return(MagickFalse);
}
#if defined(MAGICKCORE_BUILD_MODULES)
(void) tag;
(void) argc;
(void) argv;
(void) exception;
#else
{
extern size_t
analyzeImage(Image **,const int,char **,ExceptionInfo *);
ImageFilterHandler
*image_filter;
image_filter=(ImageFilterHandler *) NULL;
if (LocaleCompare("analyze",tag) == 0)
image_filter=(ImageFilterHandler *) analyzeImage;
if (image_filter != (ImageFilterHandler *) NULL)
{
size_t
signature;
if ((*image)->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),
"Invoking \"%s\" static image filter",tag);
signature=image_filter(image,argc,argv,exception);
if ((*image)->debug != MagickFalse)
(void) LogMagickEvent(CoderEvent,GetMagickModule(),"\"%s\" completes",
tag);
if (signature != MagickImageFilterSignature)
{
(void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
"ImageFilterSignatureMismatch","`%s': %8lx != %8lx",tag,
(unsigned long) signature,(unsigned long)
MagickImageFilterSignature);
return(MagickFalse);
}
}
}
#endif
return(MagickTrue);
}
int main (int argc, char** argv) {
IplImage* src = cvLoadImage(INPUT_IMAGE);
IplImage* dst = cvCreateImage(cvGetSize(src), src->depth, src->nChannels);
AXI_STREAM src_axi, dst_axi;
IplImage2AXIvideo(src, src_axi);
image_filter(src_axi, dst_axi, src->height, src->width);
AXIvideo2IplImage(dst_axi, dst);
cvSaveImage(OUTPUT_IMAGE, dst);
int ret = 0 ;
return ret;
}
void img_process(ZNQ_S32 *rgb_data_in, ZNQ_S32 *rgb_data_out, int height, int width, int stride, int flag_OpenCV)
{
int i, j;
// constructing OpenCV interface
IplImage* src_dma = cvCreateImageHeader(cvSize(width, height), IPL_DEPTH_8U, 4);
IplImage* dst_dma = cvCreateImageHeader(cvSize(width, height), IPL_DEPTH_8U, 4);
src_dma->imageData = (char*)rgb_data_in;
dst_dma->imageData = (char*)rgb_data_out;
src_dma->widthStep = 4 * stride;
dst_dma->widthStep = 4 * stride;
if (flag_OpenCV) {
opencv_image_filter(src_dma, dst_dma);
} else {
AXI_STREAM src_axi, dst_axi;
IplImage2AXIvideo(src_dma, src_axi);
image_filter(src_axi, dst_axi, height, width);
AXIvideo2IplImage(dst_axi, dst_dma);
}
cvReleaseImageHeader(&src_dma);
cvReleaseImageHeader(&dst_dma);
}
void sw_image_filter(IplImage* src, IplImage* dst) {
AXI_STREAM src_axi, dst_axi;
IplImage2AXIvideo(src, src_axi);
image_filter(src_axi, dst_axi, src->height, src->width);
AXIvideo2IplImage(dst_axi, dst);
}
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;
}
/*----------------------------------------------------------------------------*/
void video_filter_frame(my1video_t *video)
{
if (video->flags&VIDEO_FLAG_NO_FILTER) return;
if (!video->ppass) return;
video->frame = image_filter(video->frame,video->ppass);
}
