윤곽선 검출

이미지에서 경계선을 찾아내는 과정

경계선 - 색상/밝기가 급격

Sobel Filter (1차 미분 기반)

밝기의 변화가 급격한 부분 = 엣지 라고 보고

수학적으로 1차 미분값이 큰 부분을 엣지로 간주

- x축 / y축 방향으로 미분 필터 적용

- 밝기의 변화율(∂I/∂x, ∂I/∂y) 계산

Prewitt / Scharr Filter

Sobel을 변형해서 좀 더 부드럽거나 강하게 강조하는 필터

Prewitt: 고전적인 평균 기반의 미분 필터

Scharr: Sobel보다 회전 불변성과 선명도가 개선됨

Laplacian (2차 미분 기반)

밝기 변화가 가장 급격하게 꺾이는 지점 = 엣지

2차 미분 == 0 되는 점 = 변화가 급격한 지점

Laplacian 연산자(∇²I)

∂²I/∂x² + ∂²I/∂y²

밝기의 휨 정도(curvature)를 계산

Marr-Hildreth (LoG: Laplacian of Gaussian)

엣지를 정확히 감지하려면 미분 전에 노이즈를 제거해야 함

Laplacian + Gaussian smoothing을 결합

이미지에 가우시안 블러 적용

그 결과에 Laplacian 적용

LoG(I)=∇2(G∗I)

Canny (다단계 + 최적 이론 기반)

엣지를 단순히 감지하는 것이 아니라, 의미 있는 엣지만 정확히 얇게 검출

1. Noise Reduction (노이즈 제거)

Gaussian Blur(가우시안 필터)를 사용하여 이미지의 노이즈제거

2. Gradient Calculation (그래디언트 계산)

Gradient = 변화량

이미지의 x축, y축 방향의 미분(Sobel 필터)을 통해 각 픽셀의 변화율(gradient)을 계산

→ 한 픽셀 주변에서 밝기가 얼마나 빠르게 변하느냐를 계산

엣지의 강도(magnitude)와 방향(angle)을 구함

3. Non-Maximum Suppression (비최대 억제)

가장 두드러진 엣지만 남기고 나머지 엣지는 억제

각 픽셀의 엣지 방향(θ)을 기준으로,

그 방향의 양 옆 픽셀들과 비교해서 자기보다 크면 유지, 작으면 제거(=0)

가장 강한 픽셀만 유지

4. Double Threshold (이중 임계값)

엣지를 두 단계로 나눔

강한 엣지(strong edge): 확실한 엣지

약한 엣지(weak edge): 엣지일 수도 있고 아닐 수도 있는 후보

무시할 엣지: 임계값보다 낮은 값

예: low threshold = 50, high threshold = 150

5. Edge Tracking by Hysteresis (히스테리시스를 통한 엣지 추적)

히스테리시스(Hysteresis) - 어떤 시스템의 현재 상태가, 단순히 현재 입력에만 따라 결정되는 게 아니라  과거의 입력 상태에도 영향을 받음

강한 엣지는 확실한 엣지로 확정

약한 엣지는 주변에 강한 엣지가 연결되어 있으면 엣지로 간주

실제 이미지에서 노이즈 + 엣지 겹침 + 약한 윤곽선 문제를 해결하려 함

SELECT TOP 10
    name,
    type_desc,
    create_date,
    modify_date
FROM sys.objects o
WHERE o.type IN ('P','V', 'FN', 'IF', 'TF', 'TR') 
ORDER BY modify_date DESC

텐서(Tensor)

💻 벡터와 스칼라를 일반화한 다차원 배열(N-dimensional array)
⚛️ 좌표계가 바뀌어도 일관된 법칙 아래 변환되는 수학적 객체

📐 선형 변환(곱연산)을 통해 서로 연결된 공간을 표현하는 수학적 구조

딥러닝 프레임워크에서는 "모든 연산과 저장을 기본적으로 텐서(Tensor)라는 형태로 처리"

텐서 하나로 통일하는 이유?

→ 계산 효율성

텐서는 GPU / TPU에서 병렬로 연산하기 좋은 구조 (CUDA 등)

Matrix multiplication, convolution, dot product, 전부 텐서 기반

→ 프레임워크 일관성

PyTorch, TensorFlow 등 딥러닝 프레임워크는 입력부터 가중치, 출력, 손실, 역전파 gradient까지 모두 텐서로 다룸

다양한 구조(벡터, 행렬, 이미지, 시계열)도 텐서로 표현하면 코드가 단순해짐

↪ 메모리 저장도 텐서 단위로 관리되지만, 파일로 저장할 땐 조금 다름

텐서의 내부 메모리 구조

→ 데이터 포인터 (data pointer)

실제 값들이 메모리에 연속적으로 저장된 주소

예: [1, 2, 3, 4]이면 메모리에 float32 4개가 쭉 저장됨

→ shape (모양)

텐서가 몇 차원이고, 각 차원에 몇 개의 값이 있는지를 나타냄

예: (2, 3)이면 2행 3열

→ stride (스트라이드) 

다음 차원으로 넘어가기 위해 몇 칸을 건너뛰는지

예: (2, 3) 텐서에서 한 행당 3개 원소 → 다음 행 가려면 3칸 이동

✔ 생성할 때 메모리 공간이 고정 →  배열처럼 크기 고정(내부적으로 재할당 안 됨)

✔ 데이터 크기 → shape(모양) × element_size(dtype에 따라 결정)

✔  인덱스(index) 기반 접근

Tensor  메타데이터( TensorImpl → c++ )

(데이터를 설명하는 정보)

Heatmap?

데이터를 시각적으로 표현하는 방법

숫자 값의 크기를 색상의 강도로 나타내는 그래프

히스토그램 평탄화 + 히트맵 적용

import cv2
import numpy as np

# 1. 이미지 로드
img = cv2.imread("./assets/scramble.jpg")
if img is None:
    raise FileNotFoundError("이미지를 찾을 수 없습니다.")

# 2. 그레이스케일 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imwrite("./assets/gray.png", gray)

# 3. 히스토그램 평탄화
equalized = cv2.equalizeHist(gray)
cv2.imwrite("./assets/equalized_gray.png", equalized)

# 4. 히트맵 적용 전: normalize (optional but safe)
gray_norm = cv2.normalize(gray, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
equalized_norm = cv2.normalize(equalized, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)

# 5. 히트맵 생성
heatmap_orig = cv2.applyColorMap(gray_norm, cv2.COLORMAP_JET)
heatmap_equalized = cv2.applyColorMap(equalized_norm, cv2.COLORMAP_JET)

# 히트맵만 적용
cv2.imwrite("./assets/heatmap_original.png", heatmap_orig)
# 평탄화 후 히트맵 적용
cv2.imwrite("./assets/heatmap_equalized.png", heatmap_equalized)

# 6. 비교를 위한 합성 이미지 생성
blended_orig = cv2.addWeighted(img, 0.5, heatmap_orig, 0.5, 0)
blended_equalized = cv2.addWeighted(img, 0.5, heatmap_equalized, 0.5, 0)

# 히트맵만 적용
cv2.imwrite("./assets/blended_heatmap_original.png", blended_orig)
# 평탄화 후 히트맵 적용
cv2.imwrite("./assets/blended_heatmap_equalized.png", blended_equalized)

print("완료")

cv2.applyColorMap()

그레이스케일 이미지를 컬러맵을 이용해서 컬러 이미지로 변환

→ 단순 밝은 정도를 컬러 치환

진짜 히트맵은?

데이터 자체가 뭔가를 나타내는 ‘강도’ 가 있어야 HeatMap이라고 볼 수 있음

→  수동으로 좌표 기반 수치화 혹은

Grad-CAM (CNN 모델이 이미지를 분류할 때, 어느 부분을 보고 판단했는지를 시각화하는 기술)

이미지를 반으로 나눠서 하단에서 밝은 부분만 추출

import cv2
import numpy as np

# 1. 이미지 로드
img = cv2.imread("./assets/scramble.jpg")
if img is None:
    raise FileNotFoundError("이미지를 찾을 수 없습니다.")

h, w = img.shape[:2]

# 2. 그레이스케일 변환
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 3. 하단 절반 추출
bottom_half = gray[h//2:, :]  # 아래 절반

# 4. 밝은 부분만 추출 - 100이상
mask = np.zeros_like(gray, dtype=np.uint8)
mask[h//2:, :] = np.where(bottom_half > 100, 255, 0)

# 5. 히트맵 생성
heatmap = cv2.applyColorMap(mask, cv2.COLORMAP_JET)

# 6. 원본 이미지와 히트맵 합성
# → 강조할 부분만 합성, 나머지는 원본 유지
blended = img.copy()
highlight_area = cv2.addWeighted(img, 0.5, heatmap, 0.5, 0)
blended = np.where(mask[..., None] > 0, highlight_area, img)  # 밝은 부분만 교체

# 7. 저장
cv2.imwrite("./assets/highlight_mask.png", mask)
cv2.imwrite("./assets/highlight_heatmap.png", heatmap)
cv2.imwrite("./assets/blended_highlighted.png", blended)

print("생성 완료")

히스토그램(Histogram)?

이미지의 밝기 값 분포를 막대그래프로 나타낸 것

히스토그램 균일화

명암 대비가 높아져야 물체를 더 잘 식별할 수 있기에

밝기 값의 분포를 더 고르게 만들어서, 전체 밝기 범위를 활용하도록 하는 과정

흑백(Grayscale) 이미지는 2차원 배열  (*예시)

gray_img = [
  [ 12,  50,  90,  80 ],
  [ 34,  45,  70, 100 ],
  [ 60,  62,  58,  80 ],
  [ 90,  95,  85,  60 ]
]

픽셀당 밝기값만 있으니까, 바로 히스토그램 평활화를 바로 적용하면 됨

컬러 이미지는 3차원 배열 (*예시)

color_img = [
  [ [12, 40, 90], [50, 80, 100], [90, 30, 50], [80, 80, 80] ],
  [ [34, 50, 70], [45, 90, 60], [70, 20, 90], [100, 40, 70] ],
  [ [60, 70, 60], [62, 75, 65], [58, 80, 70], [80, 50, 50] ],
  [ [90, 20, 30], [95, 40, 80], [85, 70, 90], [60, 60, 60] ]
]

각 픽셀당 R(빨강), G(초록), B(파랑)로 구성되어있어서 그냥 균일화를 적용하면 색이 왜곡 될 수 있음

밝기 정보와 색상 정보를 분리하는 색공간을 이용해서 색공간 변환 후 밝기 채널만 평활화 해야함

HSV - 색상(H), 채도(S), 밝기(V)로 분리

YCrCb - 밝기(Y), 색차(Cr, Cb)로 분리

과정

1. 입력 이미지의 히스토그램 계산

픽셀 밝기값(0~255)이 이미지에 각각 몇 번 나오는지 계산

img = cv2.imread('image.jpg')
    
# 컬러 - ycrcb 변환
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
y, cr, cb = cv2.split(ycrcb)

# 컬러 - hsv 변환
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h, s, v = cv2.split(hsv)

# 흑백
hist = np.zeros(256, dtype=int)
for pixel in img.flatten(): # 컬러면 v or y 변환값
    hist[pixel] += 1

2. 누적 분포 함수(CDF, 누적 히스토그램) 계산

CDF : 밝기 값 분포의 상대 위치. 밝기 값이 특정 값 이하인 픽셀이 얼마나 누적돼 있는지를 알려주는 함수

cdf[i] = ∑ hist[j] for j in 0 to i

→ i는 "현재 밝기 값",
→ cdf[i]는 "밝기 값이 0부터 i까지인 픽셀들의 누적 수"

기준값인 i 이하인 픽셀의 개수

이러한 이미지에서 기준값을 70으로 하면 36 ( 0인 곳은 세지 않음 )

밝기 최소값은 52, 밝기 최대값은 154

3. CDF를 정규화해서 새 픽셀 값을 계산

[CDF 정규화]

T(i) = round( (CDF[i] - CDF_min) / (전체 픽셀 수 - CDF_min) × (L - 1) )

CDF의 범위를 → 밝기값의 범위(0~255)로 선형 변환(linear mapping)

round() → 소수점 불가로, 정수형으로 변환

[ 선형 스케일 변환 공식]

x_new = (x - min) / (max - min) × (새_최댓값 - 새_최솟값) + 새_최솟값

[min, max] 범위를  [a,b] 범위로 선형적으로 변환

# 컬러 타입 정규화
cdf = hist.cumsum()
cdf_min = cdf[np.nonzero(cdf)].min()
cdf_normalized = ((cdf - cdf_min) / (v.size - cdf_min) * 255).astype(np.uint8) # v,y


# 흑백 정규화 (LUT 생성)
cdf_normalized = ((cdf - cdf_min) / (total_pixels - cdf_min) * 255).astype(np.uint8)

4. 기존 픽셀 값을 새로운 값으로 매핑해서 출력 이미지 생성

정규화 결과를 새로 매핑해서 이미지 생성

# 흑백 - 새값 매핑
equalized_img = cdf_normalized[gray_img]

# 컬러 - 새값 매핑 
eq = cdf_normalized[v]

# HSV → BGR
hsv_eq = cv2.merge((h, s, eq))
img_eq = cv2.cvtColor(hsv_eq, cv2.COLOR_HSV2BGR)

# YCrCb → BGR
ycrcb_eq = cv2.merge((eq, cr, cb))
img_eq = cv2.cvtColor(ycrcb_eq, cv2.COLOR_YCrCb2BGR)

쿼리를 100번 돌려서 걸리는 시간 계산하기

DECLARE @i INT = 0;
DECLARE @elapsed1 INT = 0;
DECLARE @elapsed2 INT = 0;

DECLARE @tempStart DATETIME;
DECLARE @result1 INT;
DECLARE @result2 INT;

-- 프로시저 결과 저장용 테이블
DECLARE @temp TABLE (
   [프로시저 결과 스키마]
);

WHILE @i < 100 -- 100번 돌림, 반복 많을수록 오차 감소
BEGIN
	-- [비교 1]
    SET @tempStart = GETDATE();
    -- 스칼라
	SELECT @result1 = [스칼라];
	
	-- 프로시저
	-- 프로시저 결과를 임시 테이블에 저장
    	DELETE FROM @temp;
    	INSERT INTO @temp
    	EXEC [프로시저];

	-- 결과 가져오기
	SELECT TOP 1 @result1 = PRICE FROM @temp;
    SET @elapsed1 += DATEDIFF(MILLISECOND, @tempStart, GETDATE());
    
	-- [비교 2]
    SET @tempStart = GETDATE();
    
	-- 스칼라
	SELECT @result2 = [스칼라];

	-- 프로시저
	DELETE FROM @temp;
    	INSERT INTO @temp
    	EXEC [프로시저];
    
	-- 결과 가져오기
	SELECT TOP 1 @result2 = PRICE FROM @temp;
    SET @elapsed2 += DATEDIFF(MILLISECOND, @tempStart, GETDATE());

    SET @i += 1;
END

-- 최종 결과 출력
SELECT 
    @result1 AS 결과Q1,
    @result2 AS 결과Q2,
    @elapsed1 / 100.0 AS 평균Q1ms,
    @elapsed2 / 100.0 AS 평균Q2ms,
    (@elapsed1 - @elapsed2) AS Time_Diff_Total_ms,
    (@elapsed1 - @elapsed2) / 10.0 AS Avg_Time_Diff_Per_Run_ms;​

프로시저 (Stored Procedure)

개념

미리 저장된 SQL 문들의 집합으로, 반복적으로 수행하는 작업을 재사용 가능하게 만들어줌.

파라미터를 받아 복잡한 작업을 수행할 수 있음.

주요 특징

장점

복잡한 로직을 DB에 저장해서 비즈니스 로직 분산 가능

재사용 가능하고, 보안성 향상 (권한 제어 가능)

파라미터를 이용한 동적 쿼리 가능

단점

유지보수가 어려워질 수 있음 (버전 관리 문제)

함수보다 결과 반환이 자유롭지만, SELECT 내에서 직접 호출 불가

성능

한 번 컴파일된 실행계획을 프로시저 캐시에 저장하여 재사용

하지만 매개변수 스니핑(Parameter Sniffing) 문제로 성능 저하 가능성 있음

트리거 (Trigger)

개념

INSERT, UPDATE, DELETE 등의 DML 작업이 일어날 때 자동으로 실행되는 객체

주요 특징

장점

데이터 무결성 보장 (자동 체크 및 로깅 등 가능)

복잡한 트랜잭션 로직을 자동화 가능

단점

숨겨진 로직으로 인해 디버깅 어려움

다단 트리거 호출 시 성능 저하 및 무한루프 가능성 있음

대량 DML 작업 시 성능에 큰 영향을 줄 수 있음

성능

DML과 함께 실행되기 때문에 성능 민감

가볍고 단순하게 구성해야 함

로깅, 감사 용도로는 유용하지만 데이터 가공에는 부적절

뷰 (View)

개념

하나 이상의 테이블을 조합한 가상의 테이블. 실제 데이터를 저장하지 않음 (일반 뷰 기준)

주요 특징

장점

쿼리 복잡도를 낮추고 재사용성 증가

사용자에게 복잡한 구조를 숨김

보안 레이어로 활용 가능 (Role-Based 접근 제어)

단점

복잡한 조인/서브쿼리 뷰는 성능 이슈 발생 가능

인덱스가 없으면 큰 테이블일수록 성능 저하

성능

일반 뷰는 실행 시점에 쿼리 수행 → 실행계획 캐시에 의존

인덱싱된 뷰(Materialized View 비슷) 사용 시 성능 향상 가능하지만 제약 조건 많음

사용자 정의 함수 (User Defined Function, UDF)

개념

반복적인 작업을 함수로 정의하여 사용. 결과 반환이 명확하고, 쿼리 내부에서 사용 가능

유형

스칼라 함수: 단일 값 반환

테이블 반환 함수: 하나 이상의 행 반환

Inline (가장 빠름)

Multi-statement (성능 저하 가능성 있음)

주요 특징

장점

재사용성 우수

쿼리 내에서 직접 사용 가능 (다양한 위치에서)

특정 계산식, 포맷, 조건 등에 유용

단점

복잡할 경우 실행계획 분리로 인해 성능 저하 발생 가능

스칼라 함수는 특히 비효율적인 루프 연산을 일으키기 쉬움

성능

Inline Table-Valued Function (iTVF) 은 성능 우수

Scalar 함수 또는 Multi-Statement 함수는 쿼리 옵티마이저가 병렬처리 못함 → 성능 저하

가급적 복잡한 로직은 프로시저나 iTVF로 분리

PIP

원래 웹 프론트를 해와서 그런지 웹이랑 비교하면 이해가 쉬운 것 같다!

주요 명령어

pip install 패키지명 -- 패키지 설치
pip uninstall 패키지명	-- 패키지 제거
pip freeze	-- 현재 설치된 패키지 목록 출력 (버전 포함)
pip show 패키지명	-- 특정 패키지 정보 확인

가상환경

다른 프로젝트랑 충돌 없이 각자 필요한 라이브러리만 설치해서 쓸 수 있게 해주는 "격리된 공간"

venv는 격리된 공간을 만드는 것( 컨테이너 기반 x ) 이 아닌

Python 실행 파일, 패키지 설치 경로, 환경 설정 등을 디렉토리로 격리해 놓은 구조

Docker → 전체 환경 격리

✅ 배포시에는 Docker, ML에는 Conda, Python만 venv