Dreamer GUNDAM의 블로그::무료로 뉴타입이 되는 별까지 앞으로 356광년

    // Set ROI

    cv::Mat imageROI = image(cv::Rect(127, 170 , 120 , 80));

    cv::rectangle(image,cv::Rect(127, 170 , 120 , 80),cv::Scalar(0,0,255));

    // Get HUE histogram

    ColorHistogram hc;

    int minSat = 65;

    //cv::MatND colorhist = hc.getHueHistogram( imageROI ,  minSat );

    cv::MatND colorhist = hc.getHueHistogram( imageROI );

	// Computes the 1D Hue histogram with a mask.

	// BGR source image is converted to HSV

	cv::MatND getHueHistogram(const cv::Mat &image) {

		cv::MatND hist;

		// Convert to Lab color space

		cv::Mat hue;

		cv::cvtColor(image, hue, CV_BGR2HSV);

		// Prepare arguments for a 1D hue histogram

		hranges[0]= 0.0;

		hranges[1]= 180.0;

		channels[0]= 0; // the hue channel 

		// Compute histogram

		cv::calcHist(&hue, 

			1,			// histogram of 1 image only

			channels,	// the channel used

			cv::Mat(),	// no mask is used

			hist,		// the resulting histogram

			1,			// it is a 1D histogram

			histSize,	// number of bins

			ranges		// pixel value range

		);

		return hist;

	}

    // Object Finder

    ObjectFinder finder;

    finder.setHistogram(colorhist);

    finder.setThreshold(0.2f);

	// Sets the reference histogram

	void setHistogram(const cv::MatND& h) {

		isSparse= false;

		histogram= h;

		cv::normalize(histogram,histogram,1.0);

	}

finder.setThreshold(0.2f);



은 그냥 내부 변수중 Threshld값을 0.2f로 설정해준다. 이 값은 나중에 연산할 때 사용한다.



Step 4 : 이미지를 HSV로 변경한 후에 이미지를 분할한다. 

    //convert to HSV space

    cv::cvtColor(image, hsv, CV_BGR2HSV);

    //split image

    vector<cv::Mat> v;

    cv::split(hsv,v);

    // Identify pixel with low saturation

    cv::threshold(v[1],v[1], minSat, 255,cv::THRESH_BINARY);

    // Let's obtain backrojection of the hue channel

    // Get back-projection of hue histogram

    int ch[1]={0};

    cv::Mat result= finder.find(hsv,0.0f,180.0f,ch,1);

    cv::namedWindow("Result Hue");

    cv::imshow("Result Hue",result);

    // Eliminate low saturation pixels

    cv::bitwise_and(result,v[1],result);

    cv::namedWindow("Result Hue and");

    cv::imshow("Result Hue and",result);

 이미지는 아래와 같다.

 앞서의 이미지보다는 약간 정돈된 느낌을 주지만, 뭐...

     cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER,10,0.01);

     cout << "meanshift= " << cv::meanShift(result,rect,criteria) << endl;

#include <iostream>

#include <vector>

using namespace std;

 

#include <QtCore/QCoreApplication>

#include <opencv2/core/core.hpp>

#include <opencv2/highgui/highgui.hpp>

#include <opencv2/imgproc/imgproc.hpp>

#include <opencv2/opencv.hpp>

#include <opencv2/contrib/contrib.hpp>

#include "colorhistogram.h"

#include "objectFinder.h"

 

int main(int argc, char *argv[])

{

    cv::Mat hsv;

    QCoreApplication a(argc, argv);

    // Read Data

    cv::Mat image = cv::imread( "./0172.jpg" );

    if (!image.data)

            return 0;

 

    // Set ROI

    cv::Mat imageROI = image(cv::Rect(127, 170 , 120 , 80));

    cv::rectangle(image,cv::Rect(127, 170 , 120 , 80),cv::Scalar(0,0,255));

 

    //Display Origitanl Image

    cv::namedWindow("Image 1 :: Orignal");

    cv::imshow("Image 1 :: Orignal",image);

 

    // Get HUE histogram

    ColorHistogram hc;

    int minSat = 65;

 

    //cv::MatND colorhist = hc.getHueHistogram( imageROI ,  minSat );

    cv::MatND colorhist = hc.getHueHistogram( imageROI );

 

    // Object Finder

    ObjectFinder finder;

    finder.setHistogram(colorhist);

    finder.setThreshold(0.2f);

 

    //convert to HSV space

    cv::cvtColor(image, hsv, CV_BGR2HSV);

 

    //split image

    vector<cv::Mat> v;

    cv::split(hsv,v);

 

    // Identify pixel with low saturation

    cv::threshold(v[1],v[1], minSat, 255,cv::THRESH_BINARY);

    cv::namedWindow("Saturation");

    cv::imshow("Saturation",v[1]);

 

    // Let's obtain backrojection of the hue channel

    // Get back-projection of hue histogram

    int ch[1]={0};

    cv::Mat result= finder.find(hsv,0.0f,180.0f,ch,1);

    cv::namedWindow("Result Hue");

    cv::imshow("Result Hue",result);

 

    // Eliminate low saturation pixels

    cv::bitwise_and(result,v[1],result);

    cv::namedWindow("Result Hue and");

    cv::imshow("Result Hue and",result);

 

    // load second image

    image = cv::imread("./0181.jpg");

    // Display image

     cv::namedWindow("Image 2");

     cv::imshow("Image 2",image);

 

     // Convert to HSV space

     cv::cvtColor(image, hsv, CV_BGR2HSV);

     // Split the image

     cv::split(hsv,v);

     // Eliminate pixels with low saturation

     cv::threshold(v[1],v[1],minSat,255,cv::THRESH_BINARY);

     cv::namedWindow("Saturation");

     cv::imshow("Saturation",v[1]);

 

     // Get back-projection of hue histogram

     result= finder.find(hsv,0.0f,180.0f,ch,1);

     cv::namedWindow("Result Hue");

     cv::imshow("Result Hue",result);

 

     // Eliminate low stauration pixels

     cv::bitwise_and(result,v[1],result);

     cv::namedWindow("Result Hue and");

     cv::imshow("Result Hue and",result);

 

     // Get back-projection of hue histogram

     finder.setThreshold(-1.0f);

     result= finder.find(hsv,0.0f,180.0f,ch,1);

     cv::bitwise_and(result,v[1],result);

     cv::namedWindow("Result Hue and raw");

     cv::imshow("Result Hue and raw",result);

 

     cv::Rect rect(127, 170 , 120 , 80);

     cv::rectangle(image, rect, cv::Scalar(0,0,255));

     cv::TermCriteria criteria(cv::TermCriteria::MAX_ITER,10,0.01);

     cout << "meanshift= " << cv::meanShift(result,rect,criteria) << endl;

     cv::rectangle(image, rect, cv::Scalar(0,255,0));

 

    // Display Image

    cv::namedWindow("Image Result");

    cv::imshow("Image Result",image);

 

    cv::waitKey();

    return 0;

}

void MainWindow::on_PB_OpenImage_clicked()

{

}

#include <QFileDialog>

...

 
void MainWindow::on_PB_OpenImage_clicked()

{

    QString filename = QFileDialog::getOpenFileName( this, tr("Open Image") , "." , tr("Image Files (*.png *.jpg * jpeg *.bmp)")) ;

    image = cv::imread(filename.toAscii().data());

    cv::namedWindow("Original Image");

    cv::imshow("Original Image", image);

}

 

그리고 컴파일을 하면 아래와 같이 실행됩니다.

- project 파일에 옵션 추가하는 것은 2번째 글을 참고하시기 바랍니다.





 

void MainWindow::on_PB_Process_clicked()

{

 cv::flip(image , image , 1);

 cv::namedWindow("Output Image");

 cv::imshow("Output Image", image);

}

이제 좀더 다음 단계로  다이얼로그 박스에 결과를 내보내는 것을 해보겠습니다.

먼저 Qt에서는 그래픽 데이터를 Label로 출력할 수 있으므로 Dialog에 label을 추가 합니다.

그리고 코드를 다음과 같이 수정합니다.

void MainWindow::on_PB_Process_clicked()

{

 cv::flip(image , image , 1);

 // cv::namedWindow("Output Image");

 // cv::imshow("Output Image", image);

 // Qt Image

 QImage img = QImage (( const unsigned char *) (image.data) , image.cols , image.rows, QImage::Format_RGB888);

// display on label

 ui->label->setPixmap( QPixmap::fromImage(img));

 ui->label->resize(ui->label->pixmap()->size());

}

  이제 실행하면 됩니다.

  

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    cv::Mat image = cv::imread("baboon.jpg");
    cv::namedWindow("My First QT Window");
    cv::imshow("My First QT Window",image);
    cv::waitKey(5000);
    return a.exec();
}

LIBS+= -L/usr/local/lib \

-lopencv_core\

-lopencv_highgui\

-lopencv_imgproc\

-lopencv_features2d\

-lopencv_calib3d



그리고 컴파일한 뒤에 실행하면 아래와 같은 창이 보입니다.

Alpha Blending

알파 블랜딩을 OpenCV에서 하는 것을 구현해 보았습니다.

코드를 읽어가면서 정리하였습니다.

1. 프로그램의 순서

순서는 다음과 같습니다.

(1) 이미지 화일을 읽어들이고

      ...

      cvLoadImage

  ...

(2) 알파블랜딩할 이미지를 만듭니다. - 이경우는 만들었지만 다른 이미지를 사용해도 됩니다.

...

cvFillPoly

...

(3) 원본 이미지와 알파블랜딩할 이미지의 크기가 틀리다면

      ROI로 서로의 크기를 맞추어 줍니다.

.....

cvSetImageROI

....

cvResetImageROI

...

(4) 적절한 비율로 블랜딩합니다.

....

cvAddWeighted

....

(5) 이후에 정리합니다.

  cvSaveImage(argv[2] , imgA );

  .....

      cvReleaseImage(&imgA);

      cvReleaseImage(&imgB);

2. 새로운 함수

2.1 cvFillPoly

여기에서 새로 나온 이미지 처리 함수는 다음과 같습니다.

cvFillPoly

2차원 폴리곤을 만들어서 그 폴리곤을 그리고 내부를 채웁니다.

폴리곤의 꼭지점 개수는 제한이 없습니다. 다만 시작하기 전에 해당 폴리곤의 꼭지점 개수를 알려주어야 합니다.

이 함수를 사용하기 위해서 다음과 같은 순서로 합니다.

(1)  폴리곤을 만듭니다. 이 프로그램에서 코드는 아래와 같습니다.

  ....

  CvPoint imgb_rectangle_pts[4] = { cvPoint( 0, 0) ,

    cvPoint(0,imgb_size.width),

    cvPoint(imgb_size.height,imgb_size.width),

    cvPoint(imgb_size.height,0)

  };

   ...

  CvPoint *PointArray[2] = { & imgb_rectangle_pts[0]  , 0 } ;

  ...

 (2) 폴리곤의 개수와 각 폴리곤의 꼭지점 개수를 정합니다.

  int PolyVertexNumber[2] = { 4 , 0 } ;

  int PolyNumber = 1 ;

  지금은 하나뿐이므로, 한개의 폴리곤만을 지정한다.

 (3) 그리고 함수를 호출합니다.

  cvFillPoly(imgB ,

    PointArray ,

    PolyVertexNumber ,

    PolyNumber,

    CV_RGB(5,5,5),8,0);

2.2 cvAddWeighted

알파블랜딩을 해주는 함수입니다.

사용은 쉽습니다.

각 이미지 별로 가중치를 곱해서 더하는 것입니다

호출은 아래와 같습니다.

  ......

  double alpha = 0.5 ;

  double beta  = 1.0 - alpha ;

  cvAddWeighted(imgA, alpha , imgB , beta , 0.0 , imgA );

  ......

3. 전체 코드

전체 코드는 아래와 같습니다.

--------------------------------------------------------------------------------------------------

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <errno.h>

#include <opencv/cv.h>

#include <opencv/highgui.h>

int main(int argc , char * argv[] ){

  // 파라미터를 체크합니다.

  // 귀찮으니까 간단하게 개수만 체크합니다.

  if( argc < 2 )

   {

      printf("usage : alpha src dst\n");

      exit(0);

   }

  // 원본 이미지를 읽어들입니다.

  IplImage *imgA = cvLoadImage( argv[1] , 1);

  //알파 블랜딩할 이미지를 만듭니다. 사각형으로 만들기로 하겠습니다.

  //입력되는 이미지의 크기가 정해진 것이 아니므로,

  //입력 이미지의 크기를 갖고 와서 상대적으로 높이를 맞춥니다.

  //넓이는 150 픽셀 정도로 맞춥니다.

  CvSize imga_size = cvGetSize(imgA);

  CvSize imgb_size = cvSize(150,imga_size.height);

  IplImage *imgB = cvCreateImage( imgb_size  , IPL_DEPTH_8U, 3);

  // 이제 내부에 채워지는 4각형을 만듭니다.

  // 사용할 함수는 cvFillPoly 입니다.

  CvPoint imgb_rectangle_pts[4] = { cvPoint( 0, 0) ,

    cvPoint(0,imgb_size.width),

    cvPoint(imgb_size.height,imgb_size.width),

    cvPoint(imgb_size.height,0)

  };

  CvPoint *PointArray[2] = { & imgb_rectangle_pts[0]  , 0 } ;

  int PolyVertexNumber[2] = { 4 , 0 } ;

  int PolyNumber = 1 ;

  cvFillPoly(imgB ,

    PointArray ,

    PolyVertexNumber ,

    PolyNumber,

    CV_RGB(5,5,5),8,0);

  // 원본 이미지와, 채울 이미지의 크기가 틀리기 때문에 원본 이미지에서 관심 대상

  // 영역을 설정합니다.

  cvSetImageROI(imgA, cvRect(0,0,imgb_size.width,imgb_size.height));

  // 드디어 알파블랜딩을 합니다. 

  double alpha = 0.5 ;

  double beta  = 1.0 - alpha ;

  cvAddWeighted(imgA, alpha , imgB , beta , 0.0 , imgA );

  // 이제 관심 영역으로 설정된 것을 풉니다.

  cvResetImageROI(imgA);

  // 폰트를 정합니다.

  CvFont font1;

  double hscale = 0.5;

  double vscale = 0.5;

  double shear = 0.0;

  int thickness = 1;

  int line_type = CV_AA;

  cvInitFont(&font1,CV_FONT_HERSHEY_COMPLEX,hscale,vscale,shear,thickness,line_type);

  // 글을 집어 넣습니다.

  cvPutText(imgA,"GUNDAM",cvPoint( 0,100) ,&font1,CV_RGB(255,255,255));

  cvPutText(imgA,"Red Commet",cvPoint( 0,120) ,&font1,CV_RGB(255,255,255));

  // 화면에 출력하고

  cvNamedWindow( "ImageA-1", 1) ;

  cvShowImage( "ImageA-1", imgA );

  cvWaitKey(0);

  cvDestroyWindow("ImageA-1");

  // 파일은 따로 저장합니다.

  cvSaveImage(argv[2] , imgA );

  // 그리고 끝냅니다.

  cvReleaseImage(&imgA);

  cvReleaseImage(&imgB);

}//end of main

--------------------------------------------------------------------------------------------------

4. 처리 결과

다음 그림은 그 결과입니다.

OpenCV Convert Image

(주) 글을 읽기 전에
이 글은 저와 같은 OpenCV초보자를 위해서 정리하는 것입니다.
전문가시라면 굳이 읽을 필요가 없습니다.
공부하면서 정리하는 글이라서 서툰 부분이 많이많이 보입니다.

영상 처리를 하기 위해서는 때때로 컬러 공간을 바꾸어 줘야 할 때가 많습니다.

영상에서 필요한 정보를 찾아서 추출하기 위해서는 RGB공간에서 얻을 수 없는 정보를

다른 컬러 공간에서 얻어낼 수 있기 때문입니다.

예를들어서 사진에서 휘도를 바꾸고 싶을 경우

YCbCr로 바꾼후에 Y를 변경하고 다시 이것을 RGB로 바꾸는 과정을 거치게 됩니다.

이럴 경우 컬러 공간을 변환하는 함수가 있어야 하는데

OpenCV에서는 아래 함수가 그 동작을 도와줍니다.

cvCvtColor( 입력 이미지 , 출력 이미지 , 옵션 ); 

옵션은 아주 많이 있지만 아래에 몇가지 중요한 옵션을 설명하였습니다.

  CV_RGB2GRAY  : 흑백으로 바꾸기

                            수식은 다음과 같다.

RGB[A]->Gray: Y<-0.299*R + 0.587*G + 0.114*B

  CV_RGB2YCrCb : YCrCb로 바꾸기

    Y <- 0.299*R + 0.587*G + 0.114*B

  Cr <- (R-Y)*0.713 + delta

  Cb <- (B-Y)*0.564 + delta

  CV_RGB2HLS    : ( Hue Lightness Saturation ) 으로 변환한다.

   // In case of 8-bit and 16-bit images

  // R, G and B are converted to floating-point format and scaled to fit 0..1 range

  V,,max,, <- max(R,G,B)

  V,,min,, <- min(R,G,B)

  L <- (V,,max,, + V,,min,,)/2

  S <- (V,,max,, - V,,min,,)/(V,,max,, + V,,min,,)  if L < 0.5

        (V,,max,, - V,,min,,)/(2 - (V,,max,, + V,,min,,))  if L = 0.5

           (G - B)*60/S,  if V,,max,,=R

  H <- 180+(B - R)*60/S,  if V,,max,,=G

        240+(R - G)*60/S,  if V,,max,,=B

  if H<0 then H<-H+360

  On output 0=L=1, 0=S=1, 0=H=360.

  The values are then converted to the destination data type:

      8-bit images:

           L <- L*255, S <- S*255, H <- H/2

      16-bit images (currently not supported):

          L <- L*65535, S <- S*65535, H <- H

      32-bit images:

          H, L, S are left as is

  CV_RGB2HSV : RGB 값을 HSV로 바꾼다. HSV란 Hue Saturation Value를 의미한다.

  // In case of 8-bit and 16-bit images

  // R, G and B are converted to floating-point format and scaled to fit 0..1 range

  V <- max(R,G,B)

  S <- (V-min(R,G,B))/V   if V?0, 0 otherwise

           (G - B)*60/S,  if V=R

  H <- 120+(B - R)*60/S,  if V=G

       240+(R - G)*60/S,  if V=B

  if H<0 then H<-H+360

  On output 0=V=1, 0=S=1, 0=H=360.

  The values are then converted to the destination data type:

      8-bit images:

          V <- V*255, S <- S*255, H <- H/2 (to fit to 0..255)

      16-bit images (currently not supported):

          V <- V*65535, S <- S*65535, H <- H

      32-bit images:

          H, S, V are left as is

  CV_RGB2Lab : CIE Lab Color로 변환한다.

  // In case of 8-bit and 16-bit images

  // R, G and B are converted to floating-point format and scaled to fit 0..1 range

  // convert R,G,B to CIE XYZ

  |X|    |0.412453  0.357580  0.180423| |R|

  |Y| <- |0.212671  0.715160  0.072169|*|G|

  |Z|    |0.019334  0.119193  0.950227| |B|

  X <- X/Xn, where Xn = 0.950456

  Z <- Z/Zn, where Zn = 1.088754

  L <- 116*Y^1/3-16      for Y>0.008856

  L <- 903.3*Y           for Y<=0.008856

  a <- 500*(f(X)-f(Y)) + delta

  b <- 200*(f(Y)-f(Z)) + delta

  where f(t)=t^1/3^              for t>0.008856

        f(t)=7.787*t+16/116   for t<=0.008856

  where delta = 128 for 8-bit images,

                0 for floating-point images

  On output 0=L=100, -127=a=127, -127=b=127

  The values are then converted to the destination data type:

      8-bit images:

          L <- L*255/100, a <- a + 128, b <- b + 128

       16-bit images are currently not supported

       32-bit images:

          L, a, b are left as is

•   CV_RGB2Luv  CIE Luv Color로 변환한다.

  // In case of 8-bit and 16-bit images

  // R, G and B are converted to floating-point format and scaled to fit 0..1 range

  // convert R,G,B to CIE XYZ

  |X|    |0.412453  0.357580  0.180423| |R|

  |Y| <- |0.212671  0.715160  0.072169|*|G|

  |Z|    |0.019334  0.119193  0.950227| |B|

  L <- 116*Y^1/3^      for Y>0.008856

  L <- 903.3*Y      for Y<=0.008856

  u' <- 4*X/(X + 15*Y + 3*Z)

  v' <- 9*Y/(X + 15*Y + 3*Z)

  u <- 13*L*(u' - u,,n,,), where u,,n,,=0.19793943

  v <- 13*L*(v' - v,,n,,), where v,,n,,=0.46831096

  On output 0=L=100, -134=u=220, -140=v=122

  The values are then converted to the destination data type:

      8-bit images:

          L <- L*255/100, u <- (u + 134)*255/354, v <- (v + 140)*255/256

      16-bit images are currently not supported

      32-bit images:

          L, u, v are left as is

코드는 아래와 같습니다.

아래는 각각의 옵션으로 했을때의 그림입니다.

컬러 스페이스가 틀린것을 강제로 출력한 형태이므로 다른 컬러 공간의 그림은 정확하게 표현되지는 않습니다. 그냥 이렇게 되었다는 것만 보면 될 듯 합니다.

원본 이미지

흑백으로 변환 이미지

(주) 글을 읽기 전에 

이 글은 저와 같은 OpenCV초보자를 위해서 정리하는 것입니다.

전문가시라면 굳이 읽을 필요가 없습니다.

공부하면서 정리하는 글이라서 서툰 부분이 많이많이 보입니다.

이미지에서 특정 부분 추출하기

cvCopy(

const CvArr * src,

CvArr *          dst,

const CvArr * mask = NULL

);

이것은 원본과 복사 대상이 같은 크기와 , 같은 타입의 이미지라는 전제하에서 이루어 집니다.

이미지의 크기가 틀리다면, 다음 함수를 써서 원본의 이미지중에 일부를 추출할 수 있습니다.

void cvSetImageROI( IplImage* image, CvRect rect );

CvRect는 사각형 영역을 설정하는 것입니다.

cvRect는 다음과 같이 정의되어 있습니다.

그럼 이제 이미지를 복사하여 만들어 보는 것을 해보겠습니다.

소스는 간단해서 그닥 어려운 부분이 없습니다.

원본에서 ROI를 지정한 뒤에 복사하면 잘 됩니다.

--------------------------------------------------------------------------------

아래 그림은 결과 이미지입니다

(주) 글을 읽기 전에
이 글은 저와 같은 OpenCV초보자를 위해서 정리하는 것입니다.
전문가시라면 굳이 읽을 필요가 없습니다.
공부하면서 정리하는 글이라서 서툰 부분이 많이많이 보입니다.

OpenCV로 하는 Rotate를 해보도록 하겠습니다.

1) 공간 확보와 정리
먼저 생성될 공간을 확보해야 하는데요
IplImage *image = cvCreateImage(cvSize(width, height), depth, nChannels);
size는 말 그대로 창의 크기를 말합니다.
depth는 영상을 표현하는 정보의 내용을 의미합니다.
 • IPL_DEPTH_1U : 1비트 양의 정수영상
 • IPL_DEPTH_8U : 8비트 양의 정수영상
 • IPL_DEPTH_16U : 16비트 양의 정수영상
 • IPL_DEPTH_32U : 32비트 양의 정수영상

이 됩니다.

nChannels는 색의 종류를 의미하는 것으로 1이면 흑백 3이면 컬러가 됩니다.

사용을 다 하면 정리해줘야 합니다.
물론 프로그램을 빠져나갈때 정리를 하지 않아도 O/S가 뒤져서 찾아가는 경우도 있지만
원칙은 사용한 프로그램이 다시 그것을 O/S에 돌려줘야 한다는 것입니다.

cvReleaseImage(&image);

를 하여서 정리합니다.

(2) cvPoint2D32f
 2차원 좌표 상에서 32비트 플로팅 포인트로 x와 y좌표를 설정합니다.

(3) WrapAffine
affine transform을 수행합니다.
인자는 다음과 같습니다.

void cvWarpAffine(
 const CvArr* src,  당연히 원본 이미지
 CvArr* dst,    이것도 당연히 결과를 받아내는 이미지
 const CvMat* map_matrix, affine transform을 하는 매트릭스
    int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, 이것은 인터폴레이션을 선택
    CvScalar fillval=cvScalarAll(0)     채워지는 값
);

결과 그림은 아래와 같습니다.

유클리드 제곱 거리

이 부분의 구성은 이곳에서 인용하였습니다.

http://www.cherrynet.co.kr/bbs_view.php?s=37&pseq=11&mnid=1

다차원 공간 상에서 두점 사이의 거리를 구하는 것을 말합니다.

다차원이라고 해도 2차원상의 거리를 구하는 것과 비슷한 방법입니다.

두 점을 (p₁, p₂, p₃, p₄,...)와 (q₁, q₂, q₃, q₄, ...)로 표기한 경우 유클리디안 거리 공식은 아래와 같습니다.

def euclidean(p,q) :

     sumSq = 0.0

     # 차의 제곱을 더함

       for i in range( len(p) ) :

                sumSq += ( p[i] - q[i] ) **2

     # 루트를 취함

       return ( sumSq**0.5 )