옵티컬 플로우 .flo 파일

Question

옵티컬 플로우 프로젝트를 수행하는 데있어 몇 가지 질문이 있습니다. 나는 Python 2 (lasagne를 사용하여 옵티컬 플로우를 배우는 데 깊은 배움을 사용하고자 함)를 사용하고, C++ 함수를 플로우의 시각화에서 파이썬의 함수로 변환하는 방법을 모른다.

1. 나는 내가 그들의 광학 흐름을 추정해야 할 몇 가지 이미지 쌍 (http://vision.middlebury.edu/flow/data/comp/zip/other-gt-flow.zip에서) 다운로드, 그들의 지상 진실 흐름 (.flo 파일). 문제는, .flo 파일을 프로그램에 읽어 들일 때 벡터화 된 코드라는 것입니다. 웹 페이지 (http://vision.middlebury.edu/flow/data/)에 어떻게 표시되는지를 어떻게 볼 수 있습니까? 나는 다양한 출처에서 읽고 다음을 시도했지만 작동하지 않습니다.

2. 내 예측을 .flo 파일과 비교해야하는 경우 어떤 형식으로 EPE (엔드 포인트 오류)를 평가할 때 있습니까?

코드 :

################################ Reading flow file ################################ 

f = open('flow10.flo', 'rb') 

x = np.fromfile(f, np.int32, count=1) # not sure what this gives 
w = np.fromfile(f, np.int32, count=1) # width 
h = np.fromfile(f, np.int32, count=1) # height 
print 'x %d, w %d, h %d flo file' % (x, w, h) 

data = np.fromfile(f, np.float32) # vector 

data_2D = np.reshape(data, newshape=(388,584,2)); # convert to x,y - flow 
x = data_2D[...,0]; y = data_2D[...,1]; 

################################ visualising flow file ################################ 
mag, ang = cv2.cartToPolar(x,y) 
hsv = np.zeros_like(x) 
hsv = np.array([ hsv,hsv,hsv ]) 
hsv = np.reshape(hsv, (388,584,3)); # having rgb channel 
hsv[...,1] = 255; # full green channel 
hsv[...,0] = ang*180/np.pi/2 # angle in pi 
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX) # magnitude [0,255] 
bgr = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR) 
bgr = draw_hsv(data_2D) 
cv2.imwrite('opticalhsv.png',bgr) 

Answer 1

미들의 페이지에서 컬러 이미지로 그 .flo 파일을 변환 할 수 color_flow라는 도구를 제공합니다 흐름 코드 (http://vision.middlebury.edu/flow/code/flow-code.zip)라는 압축 파일이있다.

반면에 변환을 수행하기 위해 고유 한 코드를 구현하려는 경우이 코드를 사용하여 색상을 먼저 계산할 때 도움이되는 코드를 작성합니다 (원래 작성자는 제공 할 수 없습니다. :

static void drawOpticalFlow(const Mat_<Point2f>& flow, Mat& dst, float maxmotion = -1) 
{ 
dst.create(flow.size(), CV_8UC3); 
dst.setTo(Scalar::all(0)); 

// determine motion range: 
float maxrad = maxmotion; 

if (maxmotion <= 0) 
{ 
    maxrad = 1; 
    for (int y = 0; y < flow.rows; ++y) 
    { 
     for (int x = 0; x < flow.cols; ++x) 
     { 
      Point2f u = flow(y, x); 

      if (!isFlowCorrect(u)) 
       continue; 

      maxrad = max(maxrad, sqrt(u.x * u.x + u.y * u.y)); 
     } 
    } 
} 

for (int y = 0; y < flow.rows; ++y) 
{ 
    for (int x = 0; x < flow.cols; ++x) 
    { 
     Point2f u = flow(y, x); 

     if (isFlowCorrect(u)) 
      dst.at<Vec3b>(y, x) = computeColor(u.x/maxrad, u.y/maxrad); 
    } 
} 
} 

이 OpenCV의 내 사용하지만, 코드 도움을 원하는 사람은 비슷한 달성해야

static Vec3b computeColor(float fx, float fy) 
{ 
static bool first = true; 

// relative lengths of color transitions: 
// these are chosen based on perceptual similarity 
// (e.g. one can distinguish more shades between red and yellow 
// than between yellow and green) 
const int RY = 15; 
const int YG = 6; 
const int GC = 4; 
const int CB = 11; 
const int BM = 13; 
const int MR = 6; 
const int NCOLS = RY + YG + GC + CB + BM + MR; 
static Vec3i colorWheel[NCOLS]; 

if (first) 
{ 
    int k = 0; 

    for (int i = 0; i < RY; ++i, ++k) 
     colorWheel[k] = Vec3i(255, 255 * i/RY, 0); 

    for (int i = 0; i < YG; ++i, ++k) 
     colorWheel[k] = Vec3i(255 - 255 * i/YG, 255, 0); 

    for (int i = 0; i < GC; ++i, ++k) 
     colorWheel[k] = Vec3i(0, 255, 255 * i/GC); 

    for (int i = 0; i < CB; ++i, ++k) 
     colorWheel[k] = Vec3i(0, 255 - 255 * i/CB, 255); 

    for (int i = 0; i < BM; ++i, ++k) 
     colorWheel[k] = Vec3i(255 * i/BM, 0, 255); 

    for (int i = 0; i < MR; ++i, ++k) 
     colorWheel[k] = Vec3i(255, 0, 255 - 255 * i/MR); 

    first = false; 
} 

const float rad = sqrt(fx * fx + fy * fy); 
const float a = atan2(-fy, -fx)/(float)CV_PI; 

const float fk = (a + 1.0f)/2.0f * (NCOLS - 1); 
const int k0 = static_cast<int>(fk); 
const int k1 = (k0 + 1) % NCOLS; 
const float f = fk - k0; 

Vec3b pix; 

for (int b = 0; b < 3; b++) 
{ 
    const float col0 = colorWheel[k0][b]/255.f; 
    const float col1 = colorWheel[k1][b]/255.f; 

    float col = (1 - f) * col0 + f * col1; 

    if (rad <= 1) 
     col = 1 - rad * (1 - col); // increase saturation with radius 
    else 
     col *= .75; // out of range 

    pix[2 - b] = static_cast<uchar>(255.f * col); 
} 

return pix; 
} 

는 그런 다음 모든 픽셀에 대해 위의 함수를 호출합니다.