폴크(FOLC)

알고리즘 - Edge 추출 방법 ( Optimally Oriented Flux )

folcjin — Mon, 20 Apr 2026 08:56:57 +0900

OOF는 국소적인 미분 연산의 한계를 넘어, 영역 기반의 에너지 흐름을 분석함으로써 복잡하고 밀집된 구조물에서 가장 신뢰할 수 있는 선 추출이 가능하다.

목적: 이미지에서 가늘고 길게 이어진 구조를 검출
적용 분야: 혈관, 신경 섬유, 기관지, 섬유 패턴 분석 등
핵심 아이디어:
- 픽셀 주변의 Hessian 행렬(2차 미분) 분석 + 인접 구조물의 간섭 활용
- 고유값 패턴으로 선형성 판단의 약점을 보완하고자 개발됨

장점
- 인접 구조 간섭에 강함
- 방향 정보 추출 가능
- scale 추정이 가능
- 분석적 계산 가능

한계
- 반지름 범위 설정이 중요
- 노이즈에 완전히 자유롭지 못함
- 분기점과 고곡률 구조는 후처리가 필요함.

소스 코드

// C++14 / OpenCV 4.x
#include <opencv2/opencv.hpp>
#include <algorithm>
#include <vector>
#include <cmath>

#include <opencv2/opencv.hpp>
#include <iostream>
#include <complex>

using namespace cv;
using namespace std;

// OOF 필터 함수
void applyOOF(const Mat& src, Mat& response, float radius) {
    Mat gray;
    if (src.channels() == 3) cvtColor(src, gray, COLOR_BGR2GRAY);
    else gray = src.clone();

    // 1. 입력을 float 형으로 변환 및 FFT를 위한 패딩
    Mat floatSrc;
    gray.convertTo(floatSrc, CV_32F, 1.0 / 255.0);

    int m = getOptimalDFTSize(floatSrc.rows);
    int n = getOptimalDFTSize(floatSrc.cols);
    Mat padded;
    copyMakeBorder(floatSrc, padded, 0, m - floatSrc.rows, 0, n - floatSrc.cols, BORDER_CONSTANT, Scalar::all(0));

    // 2. FFT 수행
    Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
    Mat complexI;
    merge(planes, 2, complexI);
    dft(complexI, complexI);

    // 3. 주파수 도메인에서 OOF 필터(Bessel 기반) 생성 및 적용
    // OOF 커널: 1/r * (sin(r*w) / w - cos(r*w)) 형태의 근사치 사용
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            float u = (i > m / 2) ? (float)i - m : (float)i;
            float v = (j > n / 2) ? (float)j - n : (float)j;
            float w = sqrt(u * u + v * v);

            if (w > 0) {
                // 주파수 영역에서의 OOF 가중치 계산
                float filterValue = (sin(radius * w) / (radius * w) - cos(radius * w)) / (w * w);

                complexI.at<Vec2f>(i, j)[0] *= filterValue;
                complexI.at<Vec2f>(i, j)[1] *= filterValue;
            }
        }
    }

    // 4. 역 FFT (Inverse DFT)
    idft(complexI, complexI);
    split(complexI, planes);

    // 5. 결과 후처리 (고유값 분석 대용으로 크기 계산)
    magnitude(planes[0], planes[1], response);
    response = response(Rect(0, 0, gray.cols, gray.rows));

    normalize(response, response, 0, 255, NORM_MINMAX, CV_8U);
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat gray = cv::imread("input.png", cv::IMREAD_GRAYSCALE);

    cv::Mat oofResult;

applyOOF(gray, oofResult, 5.f);

    // 보기 좋게 0~255로 변환해 저장
    cv::Mat vis; oofResult.convertTo(vis, CV_8U, 255.0);
    cv::imwrite(" oofResult.png", vis);
    return 0;
}

알고리즘 - Edge 추출 방법 ( Frangi-Vesselness )

folcjin — Wed, 13 Aug 2025 13:11:18 +0900

이미지(또는 볼륨)에서 선형/관 구조(line-/tube-like structure)를 강조하는 필터로, 핵심은 각 픽셀에서 Hessian 행렬(2차 미분)의 고유값을 보고 한 축으로는 휘도 변화가 강하고(굵직함) 직교 축으로는 변화가 약한(가늘게 길게) 패턴을 높은 점수를 준다.

목적: 이미지에서 길쭉한 선형 패턴 검출
적용 분야: 혈관 영상 분석, 스크래치/크랙 검출, 섬유 패턴 분석 등
핵심 아이디어:
- 픽셀 주변의 Hessian 행렬(2차 미분) 분석
- 고유값 패턴으로 선형성 판단
- 다양한 **스케일(σ)**에서 선 구조 탐색

장점
- 선형 구조에 특화, 노이즈 강인
- 다양한 굵기 대응 가능 (멀티스케일)

한계
- 교차/분기부 반응 약함
- 극성 혼합 시 두 번 계산 필요
- σ 범위와 파라미터에 따라 성능 차이 큼

예시
- 혈관 네트워크 추출
- 금속 표면 스크래치 검출
- 섬유/패턴 분석

소스 코드

// C++14 / OpenCV 4.x
#include <opencv2/opencv.hpp>
#include <algorithm>
#include <vector>
#include <cmath>

cv::Mat FrangiVesselnessMultiScaleOCV(const cv::Mat& src8or32f,
                                      const std::vector<double>& sigmas,
                                      bool bright_on_dark = false, // 밝은 선 찾기(true) / 어두운 선(false, 기본)
                                      double beta = 0.5,
                                      double c = 15.0)
{
    CV_Assert(!sigmas.empty());
    CV_Assert(src8or32f.channels() == 1);

    cv::Mat f;
    if (src8or32f.type() == CV_32F) {
        f = src8or32f.clone();
    } else {
        src8or32f.convertTo(f, CV_32F, 1.0 / 255.0);
    }

    cv::Mat V = cv::Mat::zeros(f.size(), CV_32F);
    const double beta2 = 2.0 * beta * beta;
    const double c2    = 2.0 * c * c;

    for (double sigma : sigmas) {
        if (sigma <= 0) continue;

        // 1) 가우시안으로 스무딩(스케일-스페이스)
        cv::Mat g;
        cv::GaussianBlur(f, g, cv::Size(), sigma, sigma, cv::BORDER_REFLECT101);

        // 2) Hessian 근사: 2차/혼합 미분 (스무딩된 영상에 Sobel 적용)
        cv::Mat Ixx, Iyy, Ixy;
        // d2/dx2, d2/dy2, d2/dxdy
        cv::Sobel(g, Ixx, CV_32F, 2, 0, 3, 1, 0, cv::BORDER_REFLECT101);
        cv::Sobel(g, Iyy, CV_32F, 0, 2, 3, 1, 0, cv::BORDER_REFLECT101);
        cv::Sobel(g, Ixy, CV_32F, 1, 1, 3, 1, 0, cv::BORDER_REFLECT101);

        // 3) 스케일 정규화 (sigma^2)
        float s2 = static_cast<float>(sigma * sigma);
        Ixx *= s2; Iyy *= s2; Ixy *= s2;

        // 4) Frangi vesselness (단일 스케일) + 5) 멀티스케일 max-projection
        const int rows = f.rows, cols = f.cols;
        for (int y = 0; y < rows; ++y) {
            const float* ax = Ixx.ptr<float>(y);
            const float* bx = Ixy.ptr<float>(y);
            const float* dx = Iyy.ptr<float>(y);
            float*       vx = V  .ptr<float>(y);
            for (int x = 0; x < cols; ++x) {
                double a = ax[x], b = bx[x], d = dx[x];
                // eigenvalues of [[a,b],[b,d]] with |λ1| ≤ |λ2|
                double tr = a + d;
                double det = a * d - b * b;
                double disc2 = 0.25 * tr * tr - det;
                double disc = std::sqrt(disc2 > 0.0 ? disc2 : 0.0);
                double l1 = 0.5 * tr - disc;
                double l2 = 0.5 * tr + disc;

                // polarity (밝은 선/어두운 선)
                if (bright_on_dark) { if (l2 < 0.0) continue; }
                else                 { if (l2 > 0.0) continue; }

                double Rb = (l2 == 0.0) ? 0.0 : std::abs(l1) / std::abs(l2); // blob 대비 선형성
                double S2 = l1*l1 + l2*l2;                                   // ‖H‖_F^2
                double v  = std::exp(-(Rb*Rb)/beta2) * (1.0 - std::exp(-S2/c2));

                if (v > vx[x]) vx[x] = static_cast<float>(v); // max over scales
            }
        }
    }

    // 6) (선택) 0~1 클램프
    cv::threshold(V, V, 1.0, 1.0, cv::THRESH_TRUNC);
    cv::threshold(V, V, 0.0, 0.0, cv::THRESH_TOZERO);
    return V;
}

#include <opencv2/opencv.hpp>
int main() {
    cv::Mat gray = cv::imread("input.png", cv::IMREAD_GRAYSCALE);
    std::vector<double> sigmas = {1.0, 2.0, 3.0, 4.0};

    // 어두운 선(스크래치) 강조: bright_on_dark=false
    cv::Mat vessel = FrangiVesselnessMultiScaleOCV(gray, sigmas, /*bright_on_dark=*/false, 0.5, 15.0);

    // 보기 좋게 0~255로 변환해 저장
    cv::Mat vis; vessel.convertTo(vis, CV_8U, 255.0);
    cv::imwrite("vessel.png", vis);
    return 0;
}

알고리즘 - Edge 추출 방법 ( Phase Congruency )

folcjin — Fri, 8 Aug 2025 23:59:06 +0900

영상에서 에지(edge)나 코너(corner) 같은 **특징(feature)**을 밝기(intensity) 값에 의존하지 않고 검출하는 방법입니다.
이는 인간 시각 시스템(HVS, Human Visual System)이 위상(phase) 정보를 통해 형태와 구조를 인식

픽셀의 절대 밝기 변화가 아니라 위상이 일치하는 정도를 측정합니다. 즉, 조명 변화나 콘트라스트 변화에 강건하며, 동일한 구조를 다양한 밝기 조건에서도 안정적으로 검출

2. 기본 원리
이미지를 주파수 영역(특히 다중 스케일 및 다중 방향)으로 변환했을 때, 각 주파수 성분은 **진폭(amplitude)**과 위상(phase) 정보

에지나 코너 부근에서는 여러 주파수 성분의 위상이 같은 위치에서 최대값

3. 장점
1. 조명 변화 불변성 — 밝기나 명암 대비가 달라도 특징 위치가 동일하게 검출됨.
2. 스케일/방향 분석 가능 — 멀티스케일, 멀티방향 필터 사용으로 정밀한 특징 분석 가능.
3. 정규화 필요 없음 — 이미지 명암값의 전처리(normalization)가 불필요.

4. 구현 방식

가장 널리 쓰이는 구현은 Log-Gabor 필터를 다중 스케일·다중 방향으로 적용한 뒤,
각 위치에서 위상 일치도를 계산하는 방법입니다.

구현 절차:

이미지 → Log-Gabor 필터 뱅크 변환
각 스케일·방향별 진폭과 위상 계산
모든 스케일·방향에서 위상 평균 계산
위상 일치도(phase congruency) 산출
결과를 특징 맵(feature map)으로 변환

소스 코드

#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <cmath>

using namespace cv;
using namespace std;

// 간단한 Log-Gabor 필터 생성 (주파수 영역)
Mat createLogGaborKernel(Size size, double wavelength, double sigmaOnf, double theta) {
    Mat kernel(size, CV_32FC2, Scalar(0, 0));
    Point center(size.width / 2, size.height / 2);

    double thetaRad = theta * CV_PI / 180.0;
    double cosTheta = cos(thetaRad);
    double sinTheta = sin(thetaRad);

    for (int y = 0; y < size.height; y++) {
        for (int x = 0; x < size.width; x++) {
            double u = (x - center.x) / (double)size.width;
            double v = (y - center.y) / (double)size.height;

            // 회전 좌표계로 변환
            double uRot = u * cosTheta + v * sinTheta;
            double vRot = -u * sinTheta + v * cosTheta;

            double radius = sqrt(uRot * uRot + vRot * vRot);
            if (radius == 0) continue;

            // Log-Gabor 필터 방정식
            double logGabor = exp((-(log(radius / (1.0 / wavelength)) * log(radius / (1.0 / wavelength)))) /
                                  (2 * log(sigmaOnf) * log(sigmaOnf)));

            kernel.at<Vec2f>(y, x)[0] = logGabor; // 실수부
            kernel.at<Vec2f>(y, x)[1] = 0.0f;     // 허수부
        }
    }
    return kernel;
}

int main() {
    // 입력 이미지
    Mat imgGray = imread("test.png", IMREAD_GRAYSCALE);
    if (imgGray.empty()) {
        cerr << "이미지를 불러올 수 없습니다." << endl;
        return -1;
    }
    imgGray.convertTo(imgGray, CV_32F, 1.0 / 255.0);

    // FFT 준비
    Mat padded;
    int m = getOptimalDFTSize(imgGray.rows);
    int n = getOptimalDFTSize(imgGray.cols);
    copyMakeBorder(imgGray, padded, 0, m - imgGray.rows, 0, n - imgGray.cols, BORDER_CONSTANT, Scalar::all(0));

    Mat planes[] = {padded.clone(), Mat::zeros(padded.size(), CV_32F)};
    Mat complexImg;
    merge(planes, 2, complexImg);
    dft(complexImg, complexImg);

    // 다중 스케일 & 방향 설정
    vector<double> wavelengths = {3.0, 5.0, 8.0}; // 스케일
    vector<double> orientations = {0, 45, 90, 135}; // 방향

    Mat sumAmp = Mat::zeros(padded.size(), CV_32F);
    Mat sumPC  = Mat::zeros(padded.size(), CV_32F);

    for (double wl : wavelengths) {
        for (double angle : orientations) {
            // Log-Gabor 필터 생성
            Mat logGabor = createLogGaborKernel(padded.size(), wl, 0.55, angle);

            // 주파수 영역에서 곱셈
            Mat filtered;
            mulSpectrums(complexImg, logGabor, filtered, 0);

            // 역 FFT
            Mat invDFT;
            idft(filtered, invDFT, DFT_SCALE | DFT_REAL_OUTPUT);

            // 진폭과 위상 계산
            Mat magImg, phaseImg;
            magnitude(invDFT, Mat::zeros(invDFT.size(), CV_32F), magImg);
            phase(invDFT, Mat::zeros(invDFT.size(), CV_32F), phaseImg);

            // 위상 평균(단순 예시)
            sumAmp += magImg;
            sumPC += magImg.mul(cos(phaseImg - mean(phaseImg)[0]));
        }
    }

    // Phase Congruency 계산
    Mat PC = sumPC / (sumAmp + 1e-9);

    // 시각화
    normalize(PC, PC, 0, 1, NORM_MINMAX);
    imshow("Phase Congruency", PC);
    waitKey(0);

    return 0;
}

치수 계산하기 - smooth filtering 8

folcjin — Sat, 28 Jun 2025 10:39:32 +0900

Wavelet Denoising은 신호의 주파수와 시간 정보를 동시에 고려하여 노이즈를 제거하는 고급 기법

- 특히 경계(에지)를 보존하면서 노이즈를 억제하는 데 효과적이며, 의료 신호, 이미지, 음향 신호, 과학 데이터 등에 널리 사용됩니다.

Wavelet Denoising은 다음 세 단계로 수행됩니다:
1 단계 : Wavelet Transform: 입력 신호를 다중 해상도(다양한 주파수)로 분해.
2 단계 : Thresholding: 노이즈가 주로 포함된 세부 계수(detail coefficients)에 임계값을 적용해 제거.
3 단계 : Inverse Transform: 노이즈가 제거된 계수를 기반으로 신호를 복원.

1D Soft Thresholding:

예제

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

// Soft thresholding
double softThreshold(double val, double lambda) {
    if (std::abs(val) <= lambda) return 0.0;
    return (val > 0) ? (val - lambda) : (val + lambda);
}

// 1-Level Haar Wavelet Decomposition + Denoising + Reconstruction
std::vector<double> waveletDenoise(const std::vector<double>& signal, double lambda) {
    int N = signal.size();
    int half = N / 2;
    std::vector<double> approx(half), detail(half);

    // Haar Transform (decomposition)
    for (int i = 0; i < half; ++i) {
        approx[i] = (signal[2 * i] + signal[2 * i + 1]) / std::sqrt(2.0);
        detail[i] = (signal[2 * i] - signal[2 * i + 1]) / std::sqrt(2.0);
    }

    // Thresholding (soft)
    for (int i = 0; i < half; ++i) {
        detail[i] = softThreshold(detail[i], lambda);
    }

    // Inverse Haar Transform (reconstruction)
    std::vector<double> denoised(N);
    for (int i = 0; i < half; ++i) {
        denoised[2 * i]     = (approx[i] + detail[i]) / std::sqrt(2.0);
        denoised[2 * i + 1] = (approx[i] - detail[i]) / std::sqrt(2.0);
    }

    return denoised;
}

int main() {
    std::vector<double> signal = {1.2, 0.9, 1.1, 1.0, 10.0, 10.2, 9.9, 10.1}; // 신호 + 잡음
    double lambda = 0.5;

    std::vector<double> denoised = waveletDenoise(signal, lambda);

    std::cout << "Original vs Denoised:\n";
    for (size_t i = 0; i < signal.size(); ++i) {
        std::cout << "x[" << i << "] = " << signal[i]
                  << "\t=>\t" << denoised[i] << std::endl;
    }

    return 0;
}

치수 계산하기 - smooth filtering 7

folcjin — Sat, 28 Jun 2025 10:34:47 +0900

Elliptic 필터(= Cauer filter)는 가장 급격한 주파수 전이 특성을 가지는 IIR 필터입니다. 동일한 필터 스펙(통과대역, 저지대역, ripple, 차단 감쇠)을 만족시키는 필터 중 **가장 낮은 차수(order)**로 구현 가능

- 실시간 DSP, 고정밀 신호 처리, 자원 제약 환경 등에 매우 유리합니다.

Elliptic Filter란?

통과대역과 저지대역 모두에 ripple이 존재.
**Elliptic 함수 (Jacobian elliptic function)**을 이용해 설계.
Butterworth, Chebyshev보다 더 적은 차수로 동일 성능 구현 가능.

설계 파라미터

요소설명

Order (차수)	필터의 sharpness 및 정확도 결정
Passband ripple (rpr_p)	통과대역에서 허용되는 최대 리플 (dB)
Stopband attenuation (rsr_s)	저지대역에서 요구되는 최소 감쇠량 (dB)
Cutoff freq	컷오프 주파수
Sampling rate	디지털 필터이므로 필수

주파수 응답 형태

Rn : nth-order elliptic rational function (특수함수)
통과대역/저지대역 모두에서 잔류 리플 존재
가장 빠른 roll-off 제공

예제

#include <vector>

class EllipticIIR {
public:
    EllipticIIR(const double* b, const double* a, int order)
        : b(b), a(a), order(order) {
        w.assign(order, 0.0);
    }

    double process(double x) {
        double y = b[0] * x + w[0];
        for (int i = 1; i < order; ++i) {
            w[i - 1] = b[i] * x + w[i] - a[i] * y;
        }
        w[order - 1] = -a[order] * y;
        return y;
    }

private:
    const double* b;
    const double* a;
    int order;
    std::vector<double> w;
};

#include <iostream>

const double b_ellip[5] = {
    0.01967436, -0.01713698, 0.0332899, -0.01713698, 0.01967436
};
const double a_ellip[5] = {
    1.0, -3.03300954, 3.81179517, -2.29109673, 0.55535694
};

int main() {
    EllipticIIR filter(b_ellip, a_ellip, 5); // 4차 → 계수 5개

    for (int i = 0; i < 50; ++i) {
        double input = (i % 2 == 0) ? 1.0 : -1.0;  // 고주파 성분 포함 신호
        double output = filter.process(input);
        std::cout << "input: " << input << "\toutput: " << output << std::endl;
    }

    return 0;
}

치수 계산하기 - smooth filtering 6

folcjin — Sat, 28 Jun 2025 10:32:03 +0900

Chebyshev 필터는 클래식 IIR 필터 설계법 중 하나로, 주어진 사양(통과대역 ripple, 차단대역 감쇠, 전이대역 너비)을 만족시키면서 빠른 롤오프(roll-off)를 제공하는 고성능 필터

- 특히 Butterworth 필터보다 짧은 전이대역을 갖지만, **통과대역 또는 저지대역에 ripple(잔류진동)**을 허용합니다.

Chebyshev 필터

- Chebyshev Type I (1형)

통과대역에 ripple, 저지대역은 단조롭게 감쇠.
롤오프가 Butterworth보다 빠름.

- Chebyshev Type II (2형)

저지대역에 ripple, 통과대역은 평탄함.
Type I보다 덜 사용됨 (주로 특수 목적).

주파수 응답 (Type I)

: n차 Chebyshev 다항식
ωc : 컷오프 주파수
ϵ : ripple 크기 제어 (0일 때 Butterworth와 동일)

예제

#include <vector>

class ChebyshevIIR {
public:
    ChebyshevIIR(const double* b, const double* a, int order)
        : b(b), a(a), order(order) {
        w.assign(order, 0.0);
    }

    double process(double x) {
        double y = b[0] * x + w[0];
        for (int i = 1; i < order; ++i) {
            w[i - 1] = b[i] * x + w[i] - a[i] * y;
        }
        w[order - 1] = -a[order] * y;
        return y;
    }

private:
    const double* b;
    const double* a;
    int order;
    std::vector<double> w;
};

#include <iostream>

// (4차 필터)
const double b_cheby[5] = {
    0.00183555, 0.0073422, 0.0110133, 0.0073422, 0.00183555
};
const double a_cheby[5] = {
    1.0, -3.05433968, 3.82899923, -2.29245173, 0.55074452
};

int main() {
    ChebyshevIIR filter(b_cheby, a_cheby, 5); // 4차 → 계수 5개

    for (int i = 0; i < 50; ++i) {
        double input = (i % 2 == 0) ? 1.0 : -1.0;  // 고주파 성분 포함된 신호
        double output = filter.process(input);
        std::cout << "input: " << input << "\toutput: " << output << std::endl;
    }

    return 0;
}

치수 계산하기 - smooth filtering 5

folcjin — Sat, 28 Jun 2025 10:27:51 +0900

Butterworth Filter

매끄럽고 평탄한 주파수 응답 (통과대역에서 ripple이 없음).
필터 차수가 증가할수록 롤오프가 더 급격해짐.

특징

응답이 가장 "부드러운" 필터
급격한 에지 응답은 부족하지만 안정적

주파수 응답 (저역통과 기준)

#include <iostream>
#include <cmath>

class ButterworthLPF {
public:
    ButterworthLPF(double sampleRate, double cutoffFreq) {
        double fr = cutoffFreq / sampleRate;
        double ita = 1.0 / std::tan(M_PI * fr);
        double q = std::sqrt(2.0);  // Q factor for 2nd-order Butterworth

        a0 = 1.0 / (1.0 + q * ita + ita * ita);
        a1 = 2 * a0;
        a2 = a0;
        b1 = 2.0 * (ita * ita - 1.0) * a0;
        b2 = (1.0 - q * ita + ita * ita) * a0;

        x1 = x2 = y1 = y2 = 0.0;
    }

    double process(double x0) {
        double y0 = a0 * x0 + a1 * x1 + a2 * x2
                    - b1 * y1 - b2 * y2;

        // 시프트
        x2 = x1;
        x1 = x0;
        y2 = y1;
        y1 = y0;

        return y0;
    }

private:
    double a0, a1, a2, b1, b2;
    double x1, x2, y1, y2;
};

int main() {
    ButterworthLPF lpf(1000.0, 100.0);  // fs=1000Hz, cutoff=100Hz

    for (int i = 0; i < 20; ++i) {
        double input = (i % 2 == 0) ? 1.0 : -1.0;  // 대역 외 고주파 입력
        double output = lpf.process(input);
        std::cout << "Input: " << input << "\tFiltered: " << output << std::endl;
    }
    return 0;
}

치수 계산하기 - smooth filtering 4

folcjin — Sat, 28 Jun 2025 10:25:58 +0900

Band-pass Filter (대역통과 필터)

특정 주파수 범위만 통과시키고, 그 이외의 저주파와 고주파는 차단합니다.
예: 5~~15Hz만 통과 → 0~~5Hz, 15Hz~ 이상은 제거

용도

특정 이벤트나 센서가 생성하는 주파수만 추출하고 싶을 때
잡음이 저역 또는 고역에 집중되어 있을 때

Notch Filter (대역저지 필터)

특정 좁은 주파수 대역만 제거하고 나머지는 통과시킵니다.
예: 60Hz 전력 노이즈 제거 (Line frequency)

용도

주기적이고 명확한 간섭 신호(기계 진동, 전력 간섭 등) 제거
신호 구조를 최대한 유지하면서 잡음만 제거하고자 할 때

예제

#include <iostream>
#include <vector>
#include <cmath>

const double PI = 3.14159265358979323846;

// 간단한 IIR 2차 Band-pass 필터 클래스
class BandPassFilter {
public:
    BandPassFilter(double sampleRate, double lowCut, double highCut) {
        double nyq = 0.5 * sampleRate;
        double low = lowCut / nyq;
        double high = highCut / nyq;

        // Butterworth 2차 설계 (biquad 형태)
        double theta = PI * (high - low);
        double d = 1.0 / std::tan(theta);
        double beta = 0.5 * ((1.0 - d) / (1.0 + d));
        a0 = 0.5 * (1.0 - beta);
        a1 = 0.0;
        a2 = -a0;
        b1 = -2.0 * beta;
        b2 = (1.0 - beta);

        x1 = x2 = y1 = y2 = 0.0;
    }

    double process(double input) {
        double output = a0 * input + a1 * x1 + a2 * x2
                        - b1 * y1 - b2 * y2;

        x2 = x1;
        x1 = input;
        y2 = y1;
        y1 = output;

        return output;
    }

private:
    double a0, a1, a2, b1, b2;
    double x1, x2, y1, y2;
};

int main() {
    // 예제 신호 (노이즈 + 10Hz 사인파)
    double fs = 100.0;  // 샘플링 주파수
    double f_target = 10.0;
    double duration = 2.0;
    int N = static_cast<int>(fs * duration);

    std::vector<double> signal(N);
    for (int i = 0; i < N; ++i) {
        double t = i / fs;
        signal[i] = sin(2 * PI * f_target * t) + 0.5 * sin(2 * PI * 60.0 * t); // 60Hz 노이즈 포함
    }

    // 8~12Hz Band-pass 필터
    BandPassFilter bpf(fs, 8.0, 12.0);

    // 필터링
    std::vector<double> filtered(N);
    for (int i = 0; i < N; ++i) {
        filtered[i] = bpf.process(signal[i]);
    }

    // 결과 출력 (일부만)
    for (int i = 0; i < 20; ++i) {
        std::cout << "raw: " << signal[i] << "\tfiltered: " << filtered[i] << "\n";
    }

    return 0;
}

치수 계산하기 - smooth filtering 3

folcjin — Sat, 28 Jun 2025 10:19:11 +0900

Wiener Filter
- 노이즈를 억제하면서 신호를 왜곡 없이 보존하는 것이 목표.
- 선형 필터 중 평균 제곱 오차(Mean Square Error, MSE)를 최소화함.

동작 방식
- 입력 (신호 + 잡음)
- 출력 y[n]는 다음 조건을 만족하도록 설계:

- 주파수 영역에서의 형태 (1D 버전):

S(f) : 신호 파워 스펙트럼
N(f) : 노이즈 파워 스펙트럼

간단한 1D Wiener Filter 구현 로직

핵심 공식 (시간영역 근사)

μ : 로컬 윈도우 평균
σ2 : 로컬 신호 분산
ν2 : 노이즈 추정 분산 (전역 평균 또는 사전 정보)

예제

#include <iostream>
#include <vector>
#include <numeric>
#include <cmath>
#include <algorithm>

// 평균 계산 함수
double mean(const std::vector<double>& data) {
    return std::accumulate(data.begin(), data.end(), 0.0) / data.size();
}

// 분산 계산 함수
double variance(const std::vector<double>& data, double data_mean) {
    double var = 0.0;
    for (auto v : data) {
        var += (v - data_mean) * (v - data_mean);
    }
    return var / data.size();
}

// 1D Wiener Filter
std::vector<double> wienerFilter(const std::vector<double>& signal, int windowSize, double noiseVariance = -1.0) {
    int N = signal.size();
    int half = windowSize / 2;
    std::vector<double> output(N);

    // 전체 평균 기반으로 노이즈 분산 추정 (옵션)
    if (noiseVariance < 0) {
        double global_mean = mean(signal);
        noiseVariance = variance(signal, global_mean) * 0.1;  // 약한 노이즈 가정
    }

    for (int i = 0; i < N; ++i) {
        std::vector<double> window;
        for (int j = -half; j <= half; ++j) {
            int idx = std::clamp(i + j, 0, N - 1);
            window.push_back(signal[idx]);
        }

        double local_mean = mean(window);
        double local_var = variance(window, local_mean);

        double gain = (local_var > 0.0) ? std::max(0.0, (local_var - noiseVariance) / local_var) : 0.0;
        output[i] = local_mean + gain * (signal[i] - local_mean);
    }

    return output;
}

int main() {
    std::vector<double> input = {10, 12, 11, 80, 12, 11, 10};  // 스파이크 포함된 노이즈 신호
    int windowSize = 3;

    std::vector<double> filtered = wienerFilter(input, windowSize);

    std::cout << "Wiener Filter Output:\n";
    for (double v : filtered) {
        std::cout << v << " ";
    }
    std::cout << std::endl;
    return 0;
}

치수 계산하기 - smooth filtering 2

folcjin — Sat, 28 Jun 2025 10:12:53 +0900

윈도우 내 값들을 오름차순 정렬.

특정 순위(rank) 또는 백분위(percentile)에 해당하는 값을 반환.
- Percentile filter: 0~100 중 하나의 백분위값 (e.g., 20%)
- Rank filter: 윈도우 내 인덱스로 직접 지정 (e.g., 3번째 작은 값)

입력: [8, 3, 4, 2, 10], 커널 size = 5
정렬: [2, 3, 4, 8, 10]

20% percentile → 1번째 값 → 3
50% percentile → 중앙값 → 4
80% percentile → 4번째 값 → 8

Median보다 더 다양한 filtering 특성이 가능
특정 방향성 있는 노이즈 억제 가능 (e.g. 아래쪽 스파이크 제거)

예제

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

// percentile 필터 함수
std::vector<double> percentileFilter(const std::vector<double>& signal, int windowSize, double percentile) {
    int half = windowSize / 2;
    int N = signal.size();
    std::vector<double> output(N);

    for (int i = 0; i < N; ++i) {
        std::vector<double> window;

        // 윈도우 추출
        for (int j = -half; j <= half; ++j) {
            int idx = i + j;
            if (idx < 0) idx = 0;
            if (idx >= N) idx = N - 1;
            window.push_back(signal[idx]);
        }

        // 정렬
        std::sort(window.begin(), window.end());

        // Percentile 인덱스 계산 (0~100 → 0~windowSize-1)
        int rank = std::floor((percentile / 100.0) * (windowSize - 1));
        output[i] = window[rank];
    }

    return output;
}

int main() {
    std::vector<double> input = {8, 3, 4, 2, 10, 7, 6};
    int windowSize = 5;
    double percentile = 20.0;  // 하위 20% 값

    std::vector<double> result = percentileFilter(input, windowSize, percentile);

    std::cout << "Filtered output: ";
    for (double val : result) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    return 0;
}