정보 엔트로피(information entropy)

step1. 정보량

• 어떤 사건이 자주 일어나면 별로 놀랍지 않고, 거의 안 일어나는 사건이 발생하면 놀라움
• 정보이론에서는 이 “놀라움의 정도”를 정보량이라고 봄

• 어떤 사건의 확률이 0.5라면 정보량은 비교적 작고, 확률이 0.01이라면 정보량은 훨씬 큼 그러면 아래와 같이

step2. 왜 -(log P(x))를 사용할까?

• 확룰이 작을수록 정보량이 커져야함

• 100% 일어나는 사건은 새로운 정보가 없음을 의미

하지만

드문 사건일수록 정보량이 커짐

step3. 왜 로그를 쓰는가?

로그 성질때문에 이렇게 진행이 됨

step4. 그러면 엔트로피는 무엇인가? -> 정보량의 평균값

• 각 사건마다 정보량이 다르기 때문에 전체 시스템이 평균적으로 얼마나 많은 정보를 가지는지를 계산함

발생 확률 × 그 사건의 정보량

step5. 주사위로 보면

• 해당 부분에서 머신러닝을 진행할때 softmax가 확률을 출력함

• 모델이 얼마나 확신하고 있는지 판단하는 데 사용할 수 있음

• bit를 사용한 것은 log_{2}를 사용했을 떄의 정보량 단위임

ex) 빨강 100% 파랑 0%

꺼내기 전에도 “무조건 빨간색이겠네.”

라고 알 수 있습니다. 별로 놀랍지 않습니다. 그래서 Entropy가 낮습니다.

빨간 사탕 50개, 파란 사탕 50개라면? 빨강 50% 파랑 50%

뽑기 전에는 무슨 색인지 모릅니다. “빨간색일까? 파란색일까?”

불확실성이 큽니다. 그래서 Entropy가 높습니다. 즉, entropy는 결과가 얼마나 불확실한가를 본다.

크로스 엔트로피(cross entropy)

실제 분포 (P)를 기준으로 봤을 때, 모델이 예측한 분포 (Q)가 얼마나 잘못되었는지를 나타내는 값 -> 예측과 달라서 생기는 깜놀도(즉 정보량)을 의미함

• 핵심은 정답이 실제로 발생했는데, 모델이 그 정답에 낮은 확률을 줬다면 큰 손실을 준다는 것

• 정답이 0 또는 1인 이진 분류에서는 다음과 같이 씀

여기서 보이듯이

• 정답이 높은 확률을 부여하면 -> cross entropy가 작음
• 정답에 낮은 확률을 부여하면 -> cross entropy 큼

ex) 실제 정답은 고양이

입니다. AI A 고양이 90% 강아지 10%

라고 예측했습니다. 정답인 고양이에 높은 확률을 줬죠. 그래서 “잘 맞췄네.”

Cross Entropy가 작습니다

AI B 고양이 1% 강아지 99%

라고 예측했습니다. 그런데 실제로는 고양이입니다. AI는 “강아지라고 거의 확신했는데 고양이라고?”

하게 됩니다. 이런 경우 Cross Entropy가 매우 큽니다

정답과 예측이 얼마나 안맞는가를 봄

Entropy와 Cross Entropy의 차이

-> 실제 분포 (P) 자체가 얼마나 불확실한가 = entropy

-> 실제는 (P)인데 모델이 (Q)라고 생각했을 때 필요한 평균 정보량 = Cross Entropy

KL Divergence는?

• KL Divergence는 두 확률분포 (P)와 (Q)가 얼마나 다른지를 정보량 관점에서 나타낸 값

즉 해당 것은 모델 떄문에 추가로 발생한 차이임 두 생각의 차이가 얼마나 큰가로

ex) 이제 두 사람이 사탕 상자를 보고 있다고 합시다. 실제 상자는 빨강 80% 파랑 20%

입니다. 이게 실제 확률 분포 (P)입니다. 그런데 철수는 빨강 70% 파랑 30%

이라고 생각합니다. 실제와 꽤 비슷합니다. 그래서 KL Divergence가 작습니다. 그런데 영희는 빨강 10% 파랑 90%

이라고 생각합니다. 실제는 빨강이 대부분인데 완전히 반대로 생각하고 있습니다. 그래서 KL Divergence가 큽니다. -> 원래 문제 자체도 어려움 + 내 예측도 틀림 = Cross Entropy가 큼

MSE에 간단 개념

• 오차(error)를 제곱한 값의 평균임
• 오차란 알고리즘이 예측한 값과 실제 정답과의 차이를 의미함
• 알고리즘이 정답을 잘 맞출수록 MSE 값은 작음
• MSE 값은 작을수록 알고리즘의 성능이 좋다고 볼 수 있음

오차 대비 큰 손실 함수의 증가폭

• MSE는 오차가 커질수록 손실 함수 값이 빠르게 증가하는 특징
• 하단 그림은 MSE를 좌표평면에 나타낸 것
• 손실 함수(E)의 크기는 오차의 제곱에 비례하여 변하는 것을 볼 수 있음
• 그만큼 미분값이 일정하지 않고 오차가 커질수록 미분값 역시 커지는 것을 알 수 있음
• MSE와는 다르게, 평균절대오차(MAE)는 오차가 커질수록 손실 함수가 선형적으로 증가함
• MAE와 비교했을 때, MSE가 비교적 오차의 변화량에 따라 손실 함수 값이 크게 변한다는 것을 알 수 있음
• MSE는 회귀(Regression) 문제에 자주 활용 오차를 줄여가면서 업데이트

MAE(Mean Absolute Error) - 평균 절대 오차

MAE에 간단 개념

• 오차(error)를 절댓값을 계산한 뒤 평균한 값임
• 오차란 알고리즘이 예측한 값과 실제 정답과의 차이를 의미함
• 알고리즘이 정답을 잘 맞출수록 MAE 값은 작고, MAE 값이 작을수록 알고리즘의 성능이 좋다고 볼 수 있음
• MSE와 달리 오차를 제곱하지 않기 때문에 큰 오차에 상대적으로 덜 민감함

RMSE(Root Mean Squared Error) - 평균 제곱근 오차

• 오차를 제곱하여 평균한 뒤 다시 제곱근을 취한 값임
• 오차란 알고리즘이 예측한 값과 실제 정답과의 차이를 의미함
• 알고리즘이 정답을 잘 맞출수록 RMSE 값은 작고, RMSE 값이 작을수록 알고리즘의 성능이 좋다고 볼 수 있음
• 오차를 제곱하기 때문에 큰 오차에 더 큰 페널티를 부여하는 특징이 있음
• 마지막에 제곱근을 취하기 때문에 실제 데이터와 동일한 단위로 해석할 수 있음

Step 2 경로 검출과 Step 2-1 정밀 보정 알고리즘 정리

핵심 키워드 Point Cloud, PCD, Top-envelope, 경계 검출, Gaussian Filter, Median Filter, Savitzky-Golay Filter, MAD, Percentile, Arc-length Parameterization, Tangent Vector

1. 들어가며

이번 글에서는 안경 프레임의 PCD(Point Cloud Data)에서 얇은 본딩 면을 검출하고, 로봇이 접착제를 도포할 수 있는 3차원 중앙 경로를 만드는 과정을 정리한다.

전체 알고리즘은 크게 두 단계로 구성된다.

• Step 2: 원본 PCD에서 본딩 면의 Outer/Inner 경계를 검출하고 기본 중앙 경로 생성
• Step 2-1: 기본 경로의 짧은 Wave와 이상점을 제거하고 실제 PCD 단면을 이용해 정밀 보정

Step 2의 구현 순서는 PCD의 XY 격자 투영, Outer/Inner 경계 검출, 중앙 경로 계산, 필터링, 일정 간격 재샘플링 및 결과 저장으로 구성된다.

Step 2-1은 안경 프레임의 큰 형상은 유지하면서 국부적인 경계 돌출, 중앙선 진동, 면 폭의 급격한 변화를 제거한다. 실제 로봇의 안전 높이, 즉 World (+Z) 방향 Offset은 Step 2나 Step 2-1이 아니라 Step 3에서만 적용한다.

2. 전체 데이터 흐름

AI_Glass_Front_0.010mm.pcd
        │
        ▼
Step 2: generate_global_path.py
        │
        ├─ XY Top-envelope 생성
        ├─ Outer/Inner edge 검출
        ├─ 얇은 본딩 면 추출
        ├─ 기본 중앙 경로 생성
        └─ 0.5 mm 간격 재샘플링
        │
        ├─ step2_thin_bonding_face.pcd
        ├─ step2_global_path.csv
        ├─ step2_global_path.pcd
        └─ step2_global_path.npz
        │
        ▼
Step 2-1: smooth_global_path.py
        │
        ├─ 이상점 제거
        ├─ Y/Z 경로 평활화
        ├─ 실제 PCD 단면 재측정
        ├─ 중앙 경로 재보정
        ├─ 면 폭 및 방향 재구성
        └─ 최종 접선 재계산
        │
        ├─ step2_1_accurate_global_path.csv
        ├─ step2_1_accurate_global_path.pcd
        ├─ step2_1_accurate_global_path.npz
        └─ step2_1_accuracy_metrics.json
        │
        ▼
Step 3: Quaternion trajectory 및 IK

수학적으로는 다음과 같이 표현할 수 있다.

$$ \mathcal{P} \xrightarrow{\text{Rasterization}} (A,Z_{\text{top}}) \xrightarrow{\text{Edge Detection}} (\mathbf O,\mathbf I) \xrightarrow{\text{Centerline}} \mathbf C \xrightarrow{\text{Regularization}} \hat{\mathbf C} $$

여기서 각 기호는 다음을 의미한다.

3. 기본 수학 표현

원본 PCD는 다음과 같은 3차원 점들의 집합이다.

$$ \mathcal P ==========

\left{ \mathbf p_n ===========

\begin{bmatrix} x_n
y_n
z_n \end{bmatrix} \right}_{n=1}^{N} $$

최종적으로 생성하고 싶은 경로는 경로 거리 (s)에 따른 3차원 곡선이다.

$$ \mathbf C(s) ============

\begin{bmatrix} x(s)
y(s)
z(s) \end{bmatrix} $$

본딩 면의 양쪽 경계를 각각 다음과 같이 정의한다.

$$ \mathbf O(s) ============

\begin{bmatrix} O_x(s)
O_y(s)
O_z(s) \end{bmatrix} $$

$$ \mathbf I(s) ============

\begin{bmatrix} I_x(s)
I_y(s)
I_z(s) \end{bmatrix} $$

양 경계의 중앙, 폭, 방향은 다음과 같이 계산할 수 있다.

중앙 경로

$$ \mathbf C(s) ============

\frac{\mathbf O(s)+\mathbf I(s)}{2} $$

본딩 면의 폭

$$ w(s) ====

\left| \mathbf O(s)-\mathbf I(s) \right|_2 $$

Outer 방향 단위벡터

$$ \mathbf d(s) ============

\frac{ \mathbf O(s)-\mathbf I(s) }{ \left| \mathbf O(s)-\mathbf I(s) \right|_2 } $$

경로 단위 접선

$$ \mathbf t(s) ============

\frac{ d\mathbf C(s)/ds }{ \left| d\mathbf C(s)/ds \right|_2 } $$

이 정보는 이후 Step 3에서 노즐의 위치와 회전 자세를 계산할 때 사용된다.

4. Step 2: PCD에서 기본 경로 생성

4.1 PCD를 XY Raster로 변환하는 이유

PCD는 점들이 불규칙한 간격으로 존재하는 비정형 데이터이다.

이 상태에서 바로 경계 검출이나 미분을 수행하면 점 밀도와 분포에 따라 결과가 크게 달라질 수 있다. 따라서 XY 평면을 일정한 크기의 격자로 나누고, 각 셀에 대표 높이를 저장한다.

현재 Raster 해상도는 다음과 같다.

$$ \Delta=0.02\text{ mm} $$

점 ((x_n,y_n))이 속하는 격자 인덱스는 다음과 같이 계산한다.

$$ u_n ===

\left\lfloor \frac{x_n-x_{\min}}{\Delta} \right\rfloor $$

$$ v_n ===

\left\lfloor \frac{y_n-y_{\min}}{\Delta} \right\rfloor $$

Raster 해상도가 (0.02\text{ mm})이므로 셀 중심 기준 좌표 양자화 오차는 이론적으로 약 다음 범위에 존재한다.

$$ \epsilon_x,\epsilon_y \approx \pm\frac{0.02}{2} =================

\pm0.01\text{ mm} $$

4.2 Occupancy Map과 Top-envelope

각 XY 셀에 점이 존재하는지를 다음과 같이 정의한다.

$$ A(v,u) ======

\begin{cases} 1, & \text{셀 내부에 PCD 점이 존재}
0, & \text{셀 내부에 PCD 점이 없음} \end{cases} $$

그리고 각 셀에서 물리적으로 가장 위쪽에 있는 점을 대표 높이로 저장한다.

현재 Isaac 좌표 변환에서는 Local Z 방향이 물리적 높이 방향과 반대로 정의되어 있기 때문에, Local Z가 가장 작은 점이 실제 윗면에 해당한다.

$$ Z_{\text{top}}(v,u) ===================

\min_{\mathbf p_n\in\text{cell}(v,u)}z_n $$

코드에서는 PCD를 Chunk 단위로 읽고, 각 셀의 점 존재 여부와 최소 Local Z를 저장한다.

실제 Raster 인덱스 계산과 최소 Z 저장은 다음 처리에 대응한다.

px = floor((x - x_min) / raster)
py = floor((y - y_min) / raster)

occupied[py, px] = True
min_z[py, px] = min(min_z[py, px], z)

구현에서는 np.minimum.at()을 이용해 셀별 최소 Z를 계산한다.

이 결과는 완전한 3차원 모델이라기보다 다음 형태의 2.5D Height Map이다.

$$ z=f(x,y) $$

즉, 하나의 XY 위치에 하나의 대표 높이를 저장하는 방식이다.

4.3 비어 있는 셀의 높이 보완

중앙 경로의 XY 위치에서 PCD 셀이 비어 있을 수 있다.

이 경우 현재 셀 주변의 (5\times5) 영역을 확인하고, 유효 높이들의 중앙값을 사용한다.

$$ \hat Z_{\text{top}}(u,v) ========================

\operatorname{median} \left{ Z_{\text{top}}(u+i,v+j) \right} $$

$$ i,j\in{-2,-1,0,1,2} $$

평균이 아니라 중앙값을 사용하는 이유는 일부 이상 높이점의 영향을 줄이기 위해서이다.

코드에서도 비어 있는 위치를 주변 (5\times5) 패치의 유효 높이 중앙값으로 보완한다.

5. Outer edge 검출

각 X 열에서 Occupied 상태인 Y 좌표 중 가장 큰 값을 Outer edge로 선택한다.

$$ O_y(x_j) ========

\max \left{ y_k \mid A(y_k,x_j)=1 \right} $$

즉, 위에서 바라본 XY Occupancy Map에서 (+Y) 방향으로 가장 바깥쪽에 있는 윤곽을 찾는 방식이다.

Y 증가 방향
     ↑
     │       Outer edge
     │       ●────────●
     │       │ 본딩 면 │
     │       ●────────●
     │       Inner edge
     └──────────────────→ X

이 방식에는 다음 가정이 포함되어 있다.

안경 프레임의 바깥쪽 방향이 현재 좌표계에서 (+Y) 방향이다.

제품의 방향이 반대로 배치되면 max Y가 아니라 min Y를 사용해야 한다.

6. Inner edge 검출

6.1 검색 범위 설정

Inner edge는 Outer edge에서 안쪽으로 다음 범위에서 탐색한다.

$$ d_{\min}=0.35\text{ mm} $$

$$ d_{\max}=2.80\text{ mm} $$

따라서 검색 영역은 다음과 같다.

$$ O_y(x_j)-2.80 \le y\le O_y(x_j)-0.35 $$

이 범위는 Inner edge가 존재할 것으로 예상되는 공간적 사전정보이다.

6.2 Y 방향 Z 프로파일

특정 X 위치 (x_j)에서 Y 방향 높이 분포를 다음과 같이 정의한다.

$$ z_j(y) ======

Z_{\text{top}}(x_j,y) $$

Inner edge는 본딩 윗면과 홈 사이에서 높이가 급격히 바뀌는 지점이다.

하지만 원본 프로파일에는 PCD 노이즈와 Raster 계단이 존재하므로 미분 전에 Gaussian filter를 적용한다.

6.3 Gaussian Filter

Gaussian 함수는 다음과 같다.

$$ G_\sigma(\tau) ==============

\frac{1}{\sqrt{2\pi}\sigma} \exp \left( -\frac{\tau^2}{2\sigma^2} \right) $$

평활화된 높이 프로파일은 다음과 같다.

$$ \tilde z_j(y) =============

(G_\sigma*z_j)(y) $$

현재 사용되는 물리적 표준편차는 다음과 같다.

$$ \sigma=0.03\text{ mm} $$

Raster 간격이 (0.02\text{ mm})이므로 셀 단위 표준편차는 약 다음과 같다.

$$ \sigma_{\text{cell}} ====================

\frac{0.03}{0.02}

1.5 $$

즉, 약 1.5셀 범위의 짧은 측정 노이즈를 완화한다.

6.4 높이 미분으로 경계 찾기

Gaussian filter를 적용한 높이를 Y 방향으로 미분한다.

$$ g_j(y) ======

\frac{d\tilde z_j(y)}{dy} $$

이산 데이터에서는 다음 중앙 차분과 유사한 방식으로 계산할 수 있다.

$$ g_j(y_k) \approx \frac{ \tilde z_j(y_{k+1})

\tilde z_j(y_{k-1}) }{ 2\Delta } $$

현재 Local Z가 물리 높이와 반대이기 때문에 가장 음의 방향으로 강하게 변화하는 위치를 선택한다.

$$ k^* ===

\arg\min_k g_j(y_k) $$

$$ I_y(x_j) ========

y_{k^*} $$

경계 강도는 다음과 같이 정의된다.

$$ E_j ===

-g_j(y_{k^*}) $$

실제 구현에서도 Gaussian filter 이후 np.gradient()로 미분하고, argmin() 위치를 Inner edge로 선택한다.

6.5 유효 경계 판정

Outer와 Inner 사이의 폭은 다음과 같다.

$$ w_j ===

O_y(x_j)-I_y(x_j) $$

검출된 경계는 다음 조건을 만족해야 한다.

$$ 0.35 \le w_j \le 2.80 $$

$$ E_j \ge 0.15 $$

폭이나 경계 강도 조건을 만족하지 않는 X 열은 무효 처리한 뒤, 인접한 유효 열을 이용해 보간한다.

또한 전체 X 열 중 유효 경계쌍이 80% 미만이면 경로 생성에 실패한 것으로 판단한다.

7. 경계 평활화

검출된 Outer/Inner edge에는 Raster 계단과 국부적인 돌출점이 포함될 수 있다.

따라서 다음 순서로 평활화한다.

검출 경계
   │
   ▼
Median Filter
   │
   ▼
Savitzky-Golay Filter
   │
   ▼
평활화된 경계

7.1 Median Filter

길이 (2K+1)의 Median filter는 다음과 같다.

$$ \hat y_i ========

\operatorname{median} \left( y_{i-K}, \ldots, y_i, \ldots, y_{i+K} \right) $$

예를 들어 다음과 같은 데이터가 있다고 가정하자.

1.01, 1.00, 1.02, 1.85, 1.01, 1.00

여기서 1.85는 국부적인 이상점이다.

평균 필터는 1.85의 영향을 받지만 Median filter는 주변의 정상값을 기준으로 이상점을 제거할 수 있다.

7.2 Savitzky-Golay Filter

Savitzky-Golay filter는 주변 데이터를 단순 평균하지 않고 저차 다항식으로 근사한다.

3차 다항식을 사용하면 다음과 같다.

$$ p_i(\tau) =========

a_0+a_1\tau+a_2\tau^2+a_3\tau^3 $$

각 중심점 주변에서 다음 최소제곱 문제를 해결한다.

$$ \min_{a_0,a_1,a_2,a_3} \sum_{k=-K}^{K} \left[ y_{i+k}

p_i(k\Delta) \right]^2 $$

평활화된 중심값은 다음과 같다.

$$ \hat y_i ========

p_i(0)

a_0 $$

이 방식은 이동평균보다 곡선의 경사와 곡률을 잘 유지한다.

코드에서는 Median filter 이후 3차 Savitzky-Golay filter를 적용한다.

7.3 Step 2 필터 파라미터

경계와 높이에 서로 다른 필터 창이 설정되어 있다.

XY 경계에는 비교적 긴 창을 사용해 Raster wave를 충분히 제거한다.

반면 Z에 긴 창을 적용하면 실제 급경사 형상이 평탄해질 수 있으므로 더 짧은 창을 사용한다.

8. 중앙 경로 계산

평활화된 Outer와 Inner의 Y 좌표를 이용해 중앙 Y를 계산한다.

$$ C_x(x_j)=x_j $$

$$ C_y(x_j) ========

\frac{ O_y(x_j)+I_y(x_j) }{2} $$

중앙 Z는 Outer와 Inner의 Z를 단순 평균하지 않는다.

중앙 XY 위치에서 Top-envelope 높이를 다시 측정한다.

$$ C_z(x_j) ========

Z_{\text{top}} \left( x_j,C_y(x_j) \right) $$

따라서 중앙점은 다음과 같다.

$$ \mathbf C_j ===========

\begin{bmatrix} x_j
\dfrac{O_y(x_j)+I_y(x_j)}{2}
Z_{\text{top}}\left(x_j,C_y(x_j)\right) \end{bmatrix} $$

코드에서도 center_y=(outer_y+inner_y)/2를 계산한 후 해당 중앙 위치의 Top-envelope Z를 읽어 사용한다.

이 방식의 핵심은 다음과 같다.

XY는 양쪽 경계의 중앙을 사용하고, Z는 그 중앙 위치에서 측정한 실제 윗면 높이를 사용한다.

9. 얇은 본딩 면 PCD 추출

모든 Top-envelope 점을 사용하는 것이 아니라, 양쪽 경계 사이의 실제 얇은 윗면만 별도의 PCD로 추출한다.

첫 번째 조건은 점이 Inner와 Outer 사이에 존재하는 것이다.

$$ I_y(x) \le y \le O_y(x) $$

두 번째 조건은 점의 높이가 중앙 높이와 (0.15\text{ mm}) 이내에 존재하는 것이다.

$$ \left| z-C_z(x) \right| \le 0.15\text{ mm} $$

따라서 얇은 면 점군은 다음과 같다.

$$ \mathcal F ==========

\left{ (x,y,z) \in \mathcal P_{\text{top}} ;\middle|; I_y(x)\le y\le O_y(x), \left|z-C_z(x)\right|\le0.15 \right} $$

코드에서도 경계 사이에 존재하고 중앙 Z에서 (\pm0.15\text{ mm}) 이내인 점만 얇은 본딩 면 PCD로 저장한다.

이 조건은 홈 내부나 옆면처럼 높이가 다른 점을 제거하는 역할을 한다.

10. 양 끝 직각 전환부 제거

안경 프레임 양 끝에는 본딩 경로가 아닌 수평 탭이나 급격한 직각 전환부가 존재할 수 있다.

이를 제거하기 위해 인접 경로점의 XY 이동량과 Z 변화량을 계산한다.

$$ \Delta r_{xy,i} ===============

\sqrt{ (\Delta x_i)^2+ (\Delta y_i)^2 } $$

$$ \Delta z_i ==========

z_{i+1}-z_i $$

XY 평면 기준 경사각은 다음과 같다.

$$ \theta_i ========

\operatorname{atan2} \left( |\Delta z_i|, \sqrt{ (\Delta x_i)^2+ (\Delta y_i)^2 } \right) $$

각도를 Degree로 변환하면 다음과 같다.

$$ \theta_{i,\deg} ===============

\theta_i \frac{180}{\pi} $$

기본적으로 다음 조건을 만족하는 첫 구간과 마지막 구간을 탐색한다.

$$ \theta_{i,\deg} \ge 55^\circ $$

이 (55^\circ)는 안경의 설계각이 아니다.

로봇 자세가 갑자기 변하는 양 끝 전환부를 검출하기 위한 임계값이다.

CLI 실행에서는 --no-endpoint-trim을 사용하지 않는 한 양 끝 전환부 제거가 활성화된다.

11. 일정 간격 경로 재샘플링

경계에서 계산한 중앙점들은 X Raster 간격으로 생성되었기 때문에 3차원 실제 거리 간격은 일정하지 않다.

따라서 먼저 3차원 누적 거리를 계산한다.

인접 경로점 사이의 거리는 다음과 같다.

$$ \ell_i ======

\left| \mathbf C_i-\mathbf C_{i-1} \right|_2 $$

누적 거리는 다음과 같다.

$$ s_0=0 $$

$$ s_i ===

\sum_{k=1}^{i}\ell_k $$

최종 경로 길이는 다음과 같다.

$$ L=s_N $$

목표 경로 간격은 다음과 같다.

$$ \Delta s ========

0.5\text{ mm} $$

목표 Station은 다음과 같이 생성한다.

$$ s_j^* =====

j\Delta s $$

$$ j =

0,1,\ldots, \left\lfloor \frac{L}{\Delta s} \right\rfloor $$

11.1 선형 보간

목표 거리 (s_j^*)가 다음 범위에 존재한다고 가정한다.

$$ s_i \le s_j^* \le s_{i+1} $$

보간 비율은 다음과 같다.

$$ \alpha ======

\frac{ s_j^*-s_i }{ s_{i+1}-s_i } $$

보간된 경로점은 다음과 같다.

$$ \mathbf C(s_j^*) ================

(1-\alpha)\mathbf C_i + \alpha\mathbf C_{i+1} $$

코드에서는 중앙선의 3차원 누적 거리를 기준으로 X, Y, Z를 각각 선형 보간하여 기본 (0.5\text{ mm}) 간격의 경로를 만든다.

12. 접선 벡터 계산

연속적인 곡선의 접선은 다음과 같다.

$$ \frac{d\mathbf C}{ds} $$

이산 경로에서는 중앙 차분으로 근사할 수 있다.

$$ \mathbf v_i \approx \frac{ \mathbf C_{i+1}-\mathbf C_{i-1} }{ s_{i+1}-s_{i-1} } $$

접선의 크기를 1로 만들기 위해 정규화한다.

$$ \mathbf t_i ===========

\frac{ \mathbf v_i }{ |\mathbf v_i|_2 } $$

따라서 다음 조건을 만족한다.

$$ |\mathbf t_i|_2=1 $$

코드에서는 누적 거리 기준으로 np.gradient()를 적용하고, 각 미분 벡터를 정규화한다.

이 접선은 Step 3에서 로봇 Tool의 진행 방향을 구성할 때 사용된다.

13. KD-tree를 이용한 경로 검증

생성된 중앙 경로가 실제 얇은 면 PCD 위에 위치하는지를 검증한다.

각 중앙점 (\mathbf C_i)에서 얇은 면 PCD까지의 최근접 거리를 다음과 같이 계산한다.

$$ d_i ===

\min_{\mathbf q\in\mathcal F} \left| \mathbf C_i-\mathbf q \right|_2 $$

모든 PCD 점과 직접 거리를 계산하면 연산량이 크기 때문에 KD-tree를 사용한다.

코드에서도 cKDTree를 이용해 각 중앙점에서 얇은 면 PCD까지의 최근접 거리를 계산한다.

해석 방법은 다음과 같다.

• (d_i)가 작다: 경로가 실제 추출 면 위에 잘 위치함
• (d_i)가 크다: 경로가 표면에서 이탈했거나 PCD가 희박함

평균값만 보는 것보다 평균, P95, 최댓값을 함께 확인하는 것이 좋다.

14. Step 2-1: 정밀 보정

Step 2에서 생성된 경로에는 다음 오차가 남을 수 있다.

• Raster 격자에 의한 짧은 계단
• Inner edge 순간 오검출
• PCD 이상점에 의한 중앙선 돌출
• Y 방향의 짧은 Wave
• Z 방향의 국부적인 측정 진동
• 본딩 면 폭의 급격한 변화

Step 2-1은 전체 안경 형상을 바꾸지 않고 이러한 국부적인 문제만 제거하는 단계이다.

15. 필터 길이를 샘플 수로 변환

Step 2-1의 필터 크기는 샘플 개수가 아니라 mm 단위로 설정된다.

평균 경로 간격을 (\Delta s), 원하는 물리적 필터 길이를 (W)라고 하면 필요한 샘플 수는 다음과 같다.

$$ N =

\operatorname{round} \left( \frac{W}{\Delta s} \right) $$

Savitzky-Golay filter는 중심 대칭 창을 사용하므로 (N)은 홀수여야 한다.

따라서 (N)이 짝수이면 다음과 같이 보정한다.

$$ N\leftarrow N+1 $$

코드에서는 실제 경로의 중앙 간격을 계산한 뒤 mm 단위 창을 홀수 샘플 창으로 변환한다.

경로 간격을 약 (0.5\text{ mm})라고 가정하면 다음과 같다.

실제 샘플 수는 경로의 실제 간격과 전체 점 개수에 따라 달라질 수 있다.

16. Robust Low-pass Filter

Step 2-1의 핵심 평활화 과정은 다음과 같다.

원본 신호
   │
   ▼
1.5 mm Median 기준선
   │
   ▼
Residual 계산
   │
   ▼
MAD 기반 이상치 제한
   │
   ▼
Savitzky-Golay Low-pass

16.1 Median 기준선

입력 신호를 (v_i)라고 하면 Median 기준선은 다음과 같다.

$$ m_i ===

\operatorname{median} \left{ v_{i-K},\ldots,v_{i+K} \right} $$

16.2 Residual 계산

원본 신호와 기준선의 차이를 계산한다.

$$ r_i ===

v_i-m_i $$

짧은 돌출점은 큰 Residual을 만든다.

16.3 MAD 기반 Robust Sigma

Residual의 중앙값은 다음과 같다.

$$ r_c ===

\operatorname{median}(r_i) $$

Median Absolute Deviation은 다음과 같다.

$$ \operatorname{MAD} ==================

\operatorname{median} \left( |r_i-r_c| \right) $$

정규분포의 표준편차와 유사한 척도로 변환하기 위해 다음 계수를 사용한다.

$$ \hat\sigma ==========

1.4826 \cdot \operatorname{MAD} $$

일반적인 표준편차는 큰 이상치의 제곱에 영향을 많이 받는다.

반면 MAD는 Median 기반이므로 소수의 큰 PCD 이상점에 강하다.

16.4 (3.5\sigma) 이상치 제한

Residual의 허용 범위는 다음과 같다.

$$ r_c-3.5\hat\sigma \le r_i \le r_c+3.5\hat\sigma $$

범위를 벗어난 Residual은 다음과 같이 제한한다.

$$ r_i^{\text{clip}} =================

\operatorname{clip} \left( r_i, r_c-3.5\hat\sigma, r_c+3.5\hat\sigma \right) $$

이상치가 제거된 신호는 다음과 같다.

$$ v_i^{\text{despike}} ====================

m_i+r_i^{\text{clip}} $$

마지막으로 Savitzky-Golay filter를 적용한다.

$$ \hat v_i ========

\operatorname{SG} \left( v_i^{\text{despike}} \right) $$

코드에서는 Median 기준선, Residual, MAD 기반 Sigma, (3.5\sigma) Clipping, SG filter 순서로 구현되어 있다.

17. Y와 Z에 서로 다른 필터 적용

경로의 Y와 Z는 서로 다른 특성을 가진다.

Y에는 Raster 및 경계 검출에 의한 짧은 좌우 Wave가 주로 존재한다.

Z에는 실제 안경 형상의 높이 변화와 급경사가 포함된다.

따라서 다음과 같이 서로 다른 창을 사용한다.

$$ \hat C_y(s) ===========

\operatorname{RobustLP}_{7.0} \left( C_y(s) \right) $$

$$ \hat C_z(s) ===========

\operatorname{RobustLP}_{3.5} \left( C_z(s) \right) $$

Step 2-1의 주요 파라미터는 다음과 같다.

이 값들은 AccuracyConfig에 정의되어 있다.

Z의 창을 Y보다 짧게 설정한 이유는 실제 급경사 형상을 최대한 유지하기 위해서이다.

18. 원본 경로 대비 보정량 제한

평활화를 과도하게 적용하면 실제 안경 형상이 바뀔 수 있다.

따라서 원본 경로에서 최종 보정 경로까지의 이동량을 다음 범위로 제한한다.

$$ M=0.30\text{ mm} $$

원본 경로와 보정 후보 경로의 차이를 다음과 같이 정의한다.

$$ \Delta\mathbf C_i =================

\mathbf C_i^{\text{candidate}}

\mathbf C_i^{\text{raw}} $$

Scale은 다음과 같다.

$$ \alpha_i ========

\min \left( 1, \frac{M}{ |\Delta\mathbf C_i|_2 } \right) $$

최종 제한 경로는 다음과 같다.

$$ \mathbf C_i^{\text{limited}} ============================

\mathbf C_i^{\text{raw}} + \alpha_i \Delta\mathbf C_i $$

따라서 항상 다음 조건을 만족한다.

$$ \left| \mathbf C_i^{\text{limited}}

\mathbf C_i^{\text{raw}} \right|_2 \le 0.30\text{ mm} $$

코드에서도 보정 방향은 유지하면서 보정 벡터의 길이만 최대 (0.30\text{ mm})로 제한한다.

19. 실제 PCD 단면 재측정

Step 2-1에서는 Step 2가 계산한 경계만 믿지 않고, 각 경로점 주변의 얇은 면 PCD를 다시 측정한다.

경로점 (\mathbf C_i) 주변에서 다음 조건을 만족하는 PCD 점을 선택한다.

$$ |x_n-C_{x,i}| \le 0.08\text{ mm} $$

$$ |z_n-C_{z,i}| \le 0.08\text{ mm} $$

$$ |y_n-C_{y,i}| \le 2.00\text{ mm} $$

선택된 점들의 Y 좌표 집합을 다음과 같이 정의한다.

$$ \mathcal Y_i ============

\left{ y_n ;\middle|; \begin{aligned} &|x_n-C_{x,i}|\le0.08
&|z_n-C_{z,i}|\le0.08
&|y_n-C_{y,i}|\le2.00 \end{aligned} \right} $$

이 단면은 경로 접선에 수직인 회전 단면이 아니라, X·Y·Z 좌표축에 정렬된 직육면체 영역이다.

즉, 현재 알고리즘은 다음을 가정한다.

• 경로의 주 진행 방향은 대체로 X 방향
• 본딩 면의 폭 방향은 대체로 Y 방향

19.1 Percentile을 사용하는 이유

선택된 Y 값의 최솟값과 최댓값을 사용하면 노이즈 점 하나가 전체 면 폭을 크게 왜곡할 수 있다.

따라서 다음 두 Percentile을 사용한다.

$$ q_{0.02,i} ==========

Q_{2%}(\mathcal Y_i) $$

$$ q_{0.98,i} ==========

Q_{98%}(\mathcal Y_i) $$

측정된 면 중앙은 다음과 같다.

$$ C_{y,i}^{\text{PCD}} ====================

\frac{ q_{0.02,i} + q_{0.98,i} }{2} $$

측정된 면 폭은 다음과 같다.

$$ w_i^{\text{PCD}} ================

q_{0.98,i}

q_{0.02,i} $$

코드에서는 단면에 최소 10개 이상의 점이 있어야 해당 측정을 사용한다. 또한 전체 경로점 중 최소 80%에서 유효한 단면이 확보되어야 한다.

유효하지 않은 일부 구간은 인접한 유효 측정값으로 보간한다.

20. PCD 기반 중앙 경로 재보정

현재 평활화 경로와 실제 PCD 단면 중앙의 Y 차이를 계산한다.

$$ e_i ===

C_{y,i}^{\text{PCD}}

\hat C_{y,i} $$

이 오차에 다시 Robust low-pass를 적용한다.

$$ \bar e_i ========

\operatorname{RobustLP}_{7.0}(e_i) $$

단일 재중앙화량은 다음 범위로 제한한다.

$$ -0.35 \le \bar e_i \le 0.35 $$

즉,

$$ \bar e_i^{\text{clip}} ======================

\operatorname{clip} \left( \bar e_i, -0.35, 0.35 \right) $$

경로 Y는 다음과 같이 이동한다.

$$ \hat C_{y,i} \leftarrow \hat C_{y,i} + \bar e_i^{\text{clip}} $$

이후 원본 경로 대비 최종 3차원 이동량을 다시 (0.30\text{ mm})로 제한한다.

여기서 두 제한값의 역할은 다르다.

따라서 최종 결과는 항상 원본 경로에서 3차원 거리 기준 (0.30\text{ mm}) 이내에 존재한다.

21. 면 폭과 방향 재구성

원본 Outer와 Inner의 차이를 폭 벡터로 정의한다.

$$ \mathbf r_i ===========

\mathbf O_i-\mathbf I_i $$

원본 폭은 다음과 같다.

$$ w_i^{\text{raw}} ================

|\mathbf r_i|_2 $$

원본 폭 방향 단위벡터는 다음과 같다.

$$ \mathbf d_i^{\text{raw}} ========================

\frac{ \mathbf r_i }{ |\mathbf r_i|_2 } $$

21.1 폭 평활화

Percentile 단면에서 측정한 폭에 (9.0\text{ mm}) Robust low-pass를 적용한다.

$$ \hat w_i ========

\operatorname{RobustLP}_{9.0} \left( w_i^{\text{PCD}} \right) $$

폭이 0 또는 음수가 되지 않도록 최소 폭을 설정한다.

$$ \hat w_i \ge 0.05\text{ mm} $$

21.2 폭 방향 평활화

폭 방향 벡터의 X, Y, Z 성분을 각각 평활화한다.

$$ \tilde{\mathbf d}_i ===================

\begin{bmatrix} \operatorname{LP}(d_{x,i})
\operatorname{LP}(d_{y,i})
\operatorname{LP}(d_{z,i}) \end{bmatrix} $$

성분별 필터링 이후에는 벡터의 크기가 1이 아닐 수 있으므로 다시 정규화한다.

$$ \hat{\mathbf d}_i =================

\frac{ \tilde{\mathbf d}_i }{ |\tilde{\mathbf d}_i|_2 } $$

21.3 Outer와 Inner 재구성

최종 중앙 경로를 기준으로 폭의 절반만큼 양쪽으로 이동한다.

$$ \hat{\mathbf O}_i =================

\hat{\mathbf C}_i + \frac{\hat w_i}{2} \hat{\mathbf d}_i $$

$$ \hat{\mathbf I}_i =================

\hat{\mathbf C}_i

\frac{\hat w_i}{2} \hat{\mathbf d}_i $$

이 구조에서는 항상 다음 관계가 성립한다.

$$ \frac{ \hat{\mathbf O}_i + \hat{\mathbf I}_i }{2} ====

\hat{\mathbf C}_i $$

그리고 재구성된 경계 사이의 거리는 다음과 같다.

$$ \left| \hat{\mathbf O}_i

\hat{\mathbf I}_i \right|_2 =========

\hat w_i $$

코드에서도 PCD 단면 폭과 평활화된 원본 폭 방향을 이용해 Outer와 Inner를 중앙 경로 기준으로 대칭 재구성한다.

22. 최종 접선 재계산

경로의 Y와 Z가 변경되었으므로 Step 2의 접선을 그대로 사용할 수 없다.

먼저 보정된 경로의 누적 거리를 다시 계산한다.

$$ \hat s_0=0 $$

$$ \hat s_i ========

\sum_{k=1}^{i} \left| \hat{\mathbf C}_k

\hat{\mathbf C}_{k-1} \right|_2 $$

이 거리 기준으로 경로를 미분한다.

$$ \hat{\mathbf v}_i =================

\frac{ d\hat{\mathbf C} }{ d\hat s } $$

단위 접선은 다음과 같다.

$$ \hat{\mathbf t}_i =================

\frac{ \hat{\mathbf v}_i }{ |\hat{\mathbf v}_i|_2 } $$

코드에서도 보정된 경로의 누적 거리와 접선을 다시 계산한 뒤 정규화한다.

이 접선이 Step 3의 Quaternion trajectory 계산에 전달된다.

23. Accuracy Metric 해석

Step 2-1은 단순히 경로를 저장하는 것뿐 아니라 보정 효과를 수치로 평가한다.

23.1 중앙 경로 보정량

각 점의 보정 크기는 다음과 같다.

$$ c_i ===

\left| \hat{\mathbf C}_i

\mathbf C_i^{\text{raw}} \right|_2 $$

확인할 값은 다음과 같다.

• Mean
• P95
• Maximum

Maximum은 설정상 (0.30\text{ mm})를 초과하지 않아야 한다.

23.2 PCD 면 중앙 오차

보정 전 중앙 오차는 다음과 같다.

$$ e_i^{\text{before}} ===================

C_{y,i}^{\text{PCD}}

C_{y,i}^{\text{raw}} $$

보정 후 중앙 오차는 다음과 같다.

$$ e_i^{\text{after}} ==================

C_{y,i}^{\text{PCD}}

\hat C_{y,i} $$

Signed mean은 전체 경로가 어느 방향으로 치우쳐 있는지를 나타낸다.

$$ \bar e ======

\frac1N \sum_i e_i $$

절댓값 P95는 전체 경로점 중 95%의 중앙 오차가 어느 범위 안에 있는지를 나타낸다.

$$ P_{95} \left( |e_i| \right) $$

23.3 고주파 RMS

경로 신호에서 긴 SG 추세선을 제거한다.

$$ h_i ===

y_i-\bar y_i $$

고주파 RMS는 다음과 같다.

$$ \operatorname{RMS}_{HF} =======================

\sqrt{ \frac1N \sum_i h_i^2 } $$

보정 후 RMS가 감소하면 짧은 Y 방향 Wave가 줄었다는 의미이다.

코드에서도 신호와 Savitzky-Golay 추세의 차이에 대한 RMS를 계산한다.

23.4 XY Heading Total Variation

각 경로 구간의 XY 진행각은 다음과 같다.

$$ \psi_i ======

\operatorname{atan2} \left( y_{i+1}-y_i, x_{i+1}-x_i \right) $$

각도를 Unwrap한 뒤 총 변화량을 계산한다.

$$ TV_\psi =======

\sum_i \left| \psi_{i+1}-\psi_i \right| $$

이 값이 감소하면 로봇 진행 방향의 좌우 흔들림이 줄었다는 의미이다.

23.5 본딩 면 폭 통계

면 폭 평균은 다음과 같다.

$$ \bar w ======

\frac1N \sum_iw_i $$

면 폭 표준편차는 다음과 같다.

$$ \sigma_w ========

\sqrt{ \frac1N \sum_i (w_i-\bar w)^2 } $$

보정 후 표준편차가 줄어들면 순간적인 폭 변화가 제거되었다는 의미이다.

다만 실제 제품의 폭이 위치에 따라 변하는 구조라면 표준편차가 지나치게 작아지는 것도 과평활화일 수 있다.

코드에서는 보정량, PCD 중앙 오차, 고주파 RMS, Heading 변화량 및 폭 통계를 JSON으로 저장한다.

24. 간단한 계산 예제

어떤 X 위치에서 Outer와 Inner가 다음과 같이 검출되었다고 가정한다.

$$ \mathbf O_i ===========

\begin{bmatrix} 10.0
20.8
-3.25 \end{bmatrix} \text{ mm} $$

$$ \mathbf I_i ===========

\begin{bmatrix} 10.0
19.4
-3.25 \end{bmatrix} \text{ mm} $$

중앙점은 다음과 같다.

$$ \mathbf C_i ===========

\frac{ \mathbf O_i+\mathbf I_i }{2} ====

\begin{bmatrix} 10.0
20.1
-3.25 \end{bmatrix} \text{ mm} $$

폭은 다음과 같다.

$$ w_i ===

|\mathbf O_i-\mathbf I_i|_2

1.4\text{ mm} $$

다음 경로점이 다음과 같다고 가정한다.

$$ \mathbf C_{i+1} ===============

\begin{bmatrix} 10.5
20.12
-2.95 \end{bmatrix} $$

변화량은 다음과 같다.

$$ \Delta x=0.5,\qquad \Delta y=0.02,\qquad \Delta z=0.30 $$

XY 이동량은 다음과 같다.

$$ \Delta r_{xy} =============

\sqrt{ 0.5^2+0.02^2 } \approx 0.5004\text{ mm} $$

경사각은 다음과 같다.

$$ \theta ======

\operatorname{atan2} \left( 0.30, 0.5004 \right) \approx 30.94^\circ $$

따라서 (55^\circ)보다 작으므로 양 끝 직각 전환부로 판정되지 않는다.

24.1 Percentile 단면 예제

PCD 단면 측정 결과가 다음과 같다고 가정한다.

$$ Y_{2%} ======

19.45\text{ mm} $$

$$ Y_{98%} =======

20.75\text{ mm} $$

측정 중앙은 다음과 같다.

$$ C_y^{\text{PCD}} ================

\frac{ 19.45+20.75 }{2} ====

20.10\text{ mm} $$

측정 폭은 다음과 같다.

$$ w^{\text{PCD}} ==============

20.75-19.45

1.30\text{ mm} $$

현재 평활화된 경로 Y가 (20.18\text{ mm})라면 중앙 오차는 다음과 같다.

$$ e =

20.10-20.18

-0.08\text{ mm} $$

따라서 경로는 Y 음의 방향으로 약 (0.08\text{ mm}) 이동하게 된다.

25. 결과 그림 해석

25.1 XY Top View

위에서 본 그림에서는 다음 요소를 확인한다.

• 높이에 따라 색상이 지정된 얇은 본딩 면 PCD
• 보정된 Outer edge
• 보정된 Inner edge
• 최종 중앙 경로
• Robust 경계 밖에 존재하는 원본 PCD 점

2%와 98% Percentile을 사용하므로 소수의 원본 점이 보정 경계 밖에 남는 것은 정상이다.

최종 시각화 코드에서도 Robust 경계 내부의 점은 높이 색상으로 표시하고, 경계 밖의 점은 회색으로 분리한다.

25.2 XZ Side View

XZ 그림에서는 경로 높이와 구간별 경사각을 확인한다.

각 구간의 경사각은 다음과 같다.

$$ \theta_i ========

\operatorname{atan2} \left( |\Delta Z_i|, \sqrt{ (\Delta X_i)^2+ (\Delta Y_i)^2 } \right) $$

경로 선분의 색상이 경사각을 나타내므로 다음을 확인할 수 있다.

• 급경사 구간의 위치
• 좌우 끝단 전환부
• 평활화 이후 실제 높이 형상이 유지되었는지
• 경로 중간에 비정상적인 경사 급변이 존재하는지

최종 시각화에서도 XZ 경로의 선분 색상을 XY 평면 기준 경사각으로 표시한다.

26. 주요 파라미터 튜닝 가이드

27. 알고리즘의 주요 가정과 한계

27.1 하나의 XY 위치에 하나의 표면만 존재

Top-envelope는 하나의 XY 위치에 하나의 Z만 저장한다.

$$ z=f(x,y) $$

따라서 Overhang처럼 하나의 XY 위치에 여러 층의 표면이 존재하는 구조는 정확하게 표현하기 어렵다.

27.2 최소 Local Z가 실제 윗면이라는 가정

현재 Isaac 좌표 변환에서는 최소 Local Z를 윗면으로 사용한다.

좌표 변환이 바뀌어 Local Z 방향이 물리 높이 방향과 같아지면 다음과 같이 변경해야 할 수 있다.

$$ Z_{\text{top}} ==============

\max z $$

27.3 Outer edge가 (+Y) 방향이라는 가정

현재 Outer edge는 각 X 열의 최대 Y이다.

$$ O_y(x) ======

\max Y $$

제품이 회전하거나 반대로 놓이면 올바른 경계를 검출하지 못할 수 있다.

27.4 Inner edge 미분 부호 의존성

현재는 다음 위치를 Inner edge로 선택한다.

$$ \arg\min \frac{dZ}{dY} $$

좌표계가 반전되면 다음 방식이 필요할 수 있다.

$$ \arg\max \frac{dZ}{dY} $$

또는

$$ \arg\max \left| \frac{dZ}{dY} \right| $$

27.5 축 정렬 단면 사용

Step 2-1의 PCD 단면은 경로 접선에 수직인 단면이 아니다.

현재는 다음과 같은 고정 좌표축 기준 단면이다.

X = ±0.08 mm
Z = ±0.08 mm
Y = ±2.00 mm

경로 방향이 X축에서 크게 회전하는 형상이라면 접선 기반 회전 단면을 사용하는 것이 더 일반적이다.

폭 방향 (\mathbf d_i)를 접선 (\mathbf t_i)에 직교화하면 다음과 같다.

$$ \mathbf b_i ===========

\frac{ \mathbf d_i

(\mathbf d_i\cdot\mathbf t_i)\mathbf t_i }{ \left| \mathbf d_i

(\mathbf d_i\cdot\mathbf t_i)\mathbf t_i \right|_2 } $$

이 (\mathbf b_i) 방향으로 PCD를 투영하면 경로 방향이 바뀌더라도 일관된 폭을 측정할 수 있다.

현재 코드에는 이 방식이 직접 적용되어 있지 않다.

27.6 Step 2-1에서 Z를 Percentile로 재측정하지 않음

Step 2-1의 단면 재측정으로 얻는 값은 다음 두 가지이다.

• Y 방향 실제 면 중앙
• Y 방향 실제 면 폭

Z는 PCD Percentile로 다시 계산하지 않고, Step 2의 Z 경로를 Robust low-pass로 평활화한다.

따라서 Step 2에서 Z가 구조적으로 잘못 검출된 경우 Step 2-1만으로 완전히 수정하기는 어렵다.

28. Step 3과의 연결

Step 2-1은 최종 위치와 접선을 제공한다.

$$ \hat{\mathbf C}_i $$

$$ \hat{\mathbf t}_i $$

하지만 접선 하나만으로는 3차원 회전 자세를 완전히 결정할 수 없다.

접선에 수직인 회전 방향이 무한히 존재하기 때문이다.

따라서 Step 3에서는 폭 방향 또는 표면 Normal과 같은 추가 방향이 필요하다.

폭 방향을 접선에 직교화하면 다음과 같다.

$$ \mathbf b_i ===========

\frac{ \hat{\mathbf d}_i

(\hat{\mathbf d}_i\cdot\hat{\mathbf t}_i) \hat{\mathbf t}_i }{ \left| \hat{\mathbf d}_i

(\hat{\mathbf d}_i\cdot\hat{\mathbf t}_i) \hat{\mathbf t}_i \right|_2 } $$

표면 Normal은 외적으로 계산할 수 있다.

$$ \mathbf n_i ===========

\hat{\mathbf t}_i \times \mathbf b_i $$

이 세 축으로 회전행렬을 만들 수 있다.

$$ R_i ===

\begin{bmatrix} \hat{\mathbf t}_i& \mathbf b_i& \mathbf n_i \end{bmatrix} $$

이후 회전행렬을 Quaternion으로 변환하고, 로봇의 연속 IK를 수행한다.

Step 2에서는 Local Z Offset을 기본적으로 0으로 유지하며, 실제 위쪽 안전 높이는 Step 3의 surface_offset_mm에서 World (+Z) 방향으로 적용한다.

최종 로봇 위치는 개념적으로 다음과 같다.

$$ \mathbf P_i^{\text{robot}} ==========================

T_{\text{world}\leftarrow\text{local}} \left( \hat{\mathbf C}i \right) + h{\text{safe}} \begin{bmatrix} 0
0
1 \end{bmatrix}_{\text{world}} $$

여기서 (h_{\text{safe}})가 Step 3의 surface_offset_mm이다.

29. 실행 방법

전체 파이프라인 실행

cd /home/happy/modelsoultion

./lee_ws/step2_pcd_path/run_step2_pipeline.sh

저장된 결과를 이용해 PNG만 다시 생성

python3 lee_ws/step2_pcd_path/make_step2_result_figures.py

단계별 개별 실행

python3 lee_ws/step2_pcd_path/generate_global_path.py

python3 lee_ws/step2_pcd_path/smooth_global_path.py

python3 lee_ws/step2_pcd_path/make_step2_result_figures.py

30. 출력 파일 정리

Step 2 출력

step2_global_path.csv
step2_global_path.pcd
step2_global_path.npz
step2_thin_bonding_face.pcd
step2_global_path_metadata.json

Step 2 코드에는 기본 경로 CSV, PCD, NPZ, 얇은 면 PCD 및 Metadata 출력 파일이 정의되어 있다.

Step 2-1 출력

step2_1_accurate_global_path.csv
step2_1_accurate_global_path.pcd
step2_1_accurate_global_path.npz
step2_1_accuracy_metrics.json

Step 2-1 코드에서도 보정 경로와 Accuracy metric 출력 파일이 별도로 정의되어 있다.

31. 공부해야 할 핵심 이론

이번 알고리즘은 단순한 경로 생성 코드가 아니라 여러 분야의 개념이 함께 사용된 구조이다.

Point Cloud Processing

Point Cloud
    ↓
ROI
    ↓
Rasterization
    ↓
Occupancy Map
    ↓
Top-envelope

관련 개념은 다음과 같다.

• PCD 데이터 구조
• ROI
• Rasterization
• Height Map
• Occupancy Map
• KD-tree 최근접 탐색

Digital Signal Processing

다음 데이터들은 1차원 신호로 볼 수 있다.

$$ z(y),\qquad y(s),\qquad z(s),\qquad w(s) $$

관련 개념은 다음과 같다.

• Gaussian Low-pass Filter
• Median Filter
• Savitzky-Golay Filter
• 수치 미분
• 고주파와 저주파
• 필터 창 길이
• 위상 지연

Robust Statistics

이번 알고리즘에서는 평균과 표준편차만 사용하는 대신 다음 개념을 사용한다.

$$ \operatorname{Median} $$

$$ \operatorname{MAD} $$

$$ Q_{2%},\quad Q_{98%} $$

$$ P_{95} $$

이러한 통계량은 소수의 큰 PCD 이상점에 강하다.

Differential Geometry

경로를 3차원 곡선으로 바라보면 다음 개념이 중요하다.

$$ \mathbf C(s) $$

$$ \mathbf t(s) ============

\frac{ d\mathbf C/ds }{ |d\mathbf C/ds|_2 } $$

$$ \theta ======

\operatorname{atan2} \left( |dZ|, \sqrt{dX^2+dY^2} \right) $$

Step 3에서는 접선, 폭 방향, Normal을 사용해 로봇의 3차원 자세를 계산한다.

32. 마무리

이번 Step 2와 Step 2-1 파이프라인의 핵심은 다음과 같이 정리할 수 있다.

Step 2

$$ \boxed{ \text{원본 PCD에서 본딩 면의 기본 중앙 경로를 검출} } $$

핵심 수식은 다음과 같다.

$$ Z_{\text{top}}(x,y) ===================

\min z $$

$$ O_y(x) ======

\max \left{ y \mid occupied(x,y) \right} $$

$$ I_y(x) ======

\arg\min_y \frac{ d\tilde z(x,y) }{ dy } $$

$$ C_y(x) ======

\frac{ O_y(x)+I_y(x) }{2} $$

$$ C_z(x) ======

Z_{\text{top}} \left( x,C_y(x) \right) $$

Step 2-1

$$ \boxed{ \text{경로의 국부 진동을 제거하고 실제 PCD 면 중앙으로 제한 보정} } $$

핵심 수식은 다음과 같다.

$$ \hat\sigma ==========

1.4826 \operatorname{median} \left( |r_i-\operatorname{median}(r)| \right) $$

$$ C_y^{\text{PCD}} ================

\frac{ Q_{2%}(Y)+Q_{98%}(Y) }{2} $$

$$ w^{\text{PCD}} ==============

Q_{98%}(Y)-Q_{2%}(Y) $$

$$ \left| \hat{\mathbf C}_i

\mathbf C_i^{\text{raw}} \right|_2 \le 0.30\text{ mm} $$

$$ \hat{\mathbf O} ===============

\hat{\mathbf C} + \frac{\hat w}{2} \hat{\mathbf d} $$

$$ \hat{\mathbf I} ===============

\hat{\mathbf C}

\frac{\hat w}{2} \hat{\mathbf d} $$

결론적으로 이 알고리즘은 다음 기술이 결합된 경로 생성 파이프라인이다.

Point Cloud Processing
        +
Edge Detection
        +
Digital Signal Processing
        +
Robust Statistics
        +
3D Curve Geometry
        +
Robot Path Planning

Step 2는 PCD에서 기하학적인 초기 경로를 생성하고, Step 2-1은 실제 PCD 단면을 이용해 해당 경로를 강건하게 보정한다.

이후 Step 3에서는 최종 중앙 경로와 접선을 이용해 Quaternion trajectory와 연속 IK를 계산하고, 실제 로봇이 본딩 면을 따라 이동할 수 있는 자세 궤적을 생성한다.

#PointCloud #PCD #RobotPathPlanning #Robotics #SavitzkyGolay #RobustStatistics #Quaternion #InverseKinematics

이렇게 생김

5. happy@happy-B650M-PG-Lightning:~$ mv /tmp/dump ~/ai_study_math/glim_first

6. happy@happy-B650M-PG-Lightning:/ai_study_math/glim_first$ ls 000000 000012 000024 000036 000048 000060 000072 000084 000096 000108 000120 000132 000144 000156 000168 000180 000192 000204 000216 000228 000240 000252 odom_lidar.txt 000001 000013 000025 000037 000049 000061 000073 000085 000097 000109 000121 000133 000145 000157 000169 000181 000193 000205 000217 000229 000241 000253 traj_imu.txt 000002 000014 000026 000038 000050 000062 000074 000086 000098 000110 000122 000134 000146 000158 000170 000182 000194 000206 000218 000230 000242 000254 traj_lidar.txt 000003 000015 000027 000039 000051 000063 000075 000087 000099 000111 000123 000135 000147 000159 000171 000183 000195 000207 000219 000231 000243 000255 values.bin 000004 000016 000028 000040 000052 000064 000076 000088 000100 000112 000124 000136 000148 000160 000172 000184 000196 000208 000220 000232 000244 000256 000005 000017 000029 000041 000053 000065 000077 000089 000101 000113 000125 000137 000149 000161 000173 000185 000197 000209 000221 000233 000245 000257 000006 000018 000030 000042 000054 000066 000078 000090 000102 000114 000126 000138 000150 000162 000174 000186 000198 000210 000222 000234 000246 000258 000007 000019 000031 000043 000055 000067 000079 000091 000103 000115 000127 000139 000151 000163 000175 000187 000199 000211 000223 000235 000247 000259 000008 000020 000032 000044 000056 000068 000080 000092 000104 000116 000128 000140 000152 000164 000176 000188 000200 000212 000224 000236 000248 config 000009 000021 000033 000045 000057 000069 000081 000093 000105 000117 000129 000141 000153 000165 000177 000189 000201 000213 000225 000237 000249 graph.bin 000010 000022 000034 000046 000058 000070 000082 000094 000106 000118 000130 000142 000154 000166 000178 000190 000202 000214 000226 000238 000250 graph.txt 000011 000023 000035 000047 000059 000071 000083 000095 000107 000119 000131 000143 000155 000167 000179 000191 000203 000215 000227 000239 000251 odom_imu.txt happy@happy-B650M-PG-Lightning:/ai_study_math/glim_first$

하나 끝

happy@happy-B650M-PG-Lightning:~/glim_ws$ ros2 run glim_ros offline_viewer

이거 viewer 라이더 값을 저장해서 합치는 것임

그거 좌측 눌려서 starte -> end 해서 합칠수 있음

2. lsusb

• 10c4:ea60(CP2102)

• 1a86:7523(1a86:7523)

ex) unicon@unicon-desktop:~/nav_ws$ lsusb Bus 002 Device 002: ID 0bda:0489 Realtek Semiconductor Corp. 4-Port USB 3.0 Hub Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub Bus 001 Device 003: ID 13d3:3549 IMC Networks Bluetooth Radio Bus 001 Device 005: ID 10c4:ea60 Silicon Labs CP210x UART Bridge Bus 001 Device 002: ID 0bda:5489 Realtek Semiconductor Corp. 4-Port USB 2.0 Hub Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

3. udevadm info -a /dev/ttyUSB0 | grep "{serial}"

unicon@unicon-desktop:~/nav_ws$ udevadm info -a /dev/ttyUSB0 | grep "{serial}" ATTRS{serial}=="0001" ATTRS{serial}=="3610000.usb"

4. cd /etc/udev/rules.d

5. sudo gedit 99_usb.rules

SUBSYSTEM=="tty", \
ATTRS{idVendor}=="10c4", \
ATTRS{idProduct}=="ea60", \
ATTRS{serial}=="0001", \
SYMLINK+="imu"

6. sudo service udev restart

7. port를 빼고 꼽음

→ 화재감시자 (Fire Watcher)

용접·용단 등 화기 작업 시 화재 발생 여부를 감시

잔불 및 불꽃 비산 여부 확인

2. 야광봉을 들고 흔들면서 길 안내하는 사람

→ 신호수 (Flagman / Traffic Controller)

차량 및 장비 이동 시 신호를 통해 안전 유도

야간에는 야광봉(라이트 배턴) 사용

3. 사람을 보고 따라오라고 안내하는 사람

→ 유도원 (Guide / Banksman)

작업자 또는 장비를 특정 위치까지 안전하게 유도

협소 공간, 후진 작업 등에서 필수 역할

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

4 - 1. 이 세상은 객체로 이루어져 있다

객체란

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

• 전에 작성한 Animal 구조체를 정의한 후, animal 변수를 만들어서 이를 필요로 하는 함수를 작성함

• 이 때 객체가 현실 세계에서의 존재하는 것들을 나타내기 위해서는 추상화(abstraction)라는 과정이 필요

• animal.food += 100; 자체는 외부에서 animal 이라는 '객체' 의 '인스턴스 변수' 에 '직접' 접근하는 것이기 때문에 불가능

• animal.increase_food(100); 의 경우 animal 객체의 '인스턴스 함수' 를 통해서 값을 수정하는 것이기 때문에가능한 것이지요. 이와 같이 외부에서 직접 인스턴스 변수의 값을 바꿀 수 없고 항상 인스턴스 메소드를 통해서 간접적으로 조절하는 것을 캡슐화(Encapsulation)라고 함

클래스란

class Animal {
 private:
  int food;
  int weight;

 public:
  void set_animal(int _food, int _weight) {
    food = _food;
    weight = _weight;
  }
  void increase_food(int inc) {
    food += inc;
    weight += (inc / 3);
  }
  void view_stat() {
    std::cout << "이 동물의 food   : " << food << std::endl;
    std::cout << "이 동물의 weight : " << weight << std::endl;
  }
};

• Animal 클래스 상에서 이들을 지칭할 때 각각 멤버 변수(member variable) 과 멤버 함수(member function) 라고 부름

private:
int food;
int weight;

• 아래에 쓰여진 것들은 모두 객체 내에서 보호되고 있다 라는 의미
• 모든 것들은 자기 객체 안에서만 접근할 수 있을 뿐 객체 외부에서는 접근할 수 없게 됨

public:
void set_animal(int _food, int _weight) {
  food = _food;
  weight = _weight;
}
void increase_food(int inc) {
  food += inc;
  weight += (inc / 3);
}
void view_stat() {
  std::cout << "이 동물의 food   : " << food << std::endl;
  std::cout << "이 동물의 weight : " << weight << std::endl;
}

• public 이라는 것은 말 그대로 공개된 것으로 외부에서 마음껏 이용할 수 있게 됨

  animal.set_animal(100, 50);
  animal.increase_food(30);
  animal.view_stat();

• 이런식으로 다 지원하게 됨
• 만일 멤버 함수들을 private 로 설정해버렸다면 어떨까요. public 키워드를 지워봄

  'Animal::set_animal' : cannot access private member declared in class 'Animal'

이런 에러가 발생

class Animal {
  int food;
  int weight;
  // ... 생략

• 이런식으로 작성하면 다 private으로 작성하게됨

4 - 2. 클래스의 세계로 오신 것을 환영합니다. (함수의 오버로딩, 생성자)

함수의 오버로딩 (Overloading)

1. 과적하다

2. sb (with sth) 너무 많이 주다[부과하다]

3. (컴퓨터・전기 시스템 등에) 과부하가 걸리게 하다

이런뜻으로 들어감

/* 함수의 오버로딩 */
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(char x) { std::cout << "char : " << x << std::endl; }
void print(double x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

• 해당 코드에서 신기한 점은 함수의 이름이 동일하다는것임
• 하지만 해당것은 오류가 안나오고 코드가 compile 됨

하지만

/* 함수의 오버로딩 */
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(double x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

이는 지금 print로 int와 double로 두개의 함수를 작성하지만 main함수에서는 char가 있음 이에 결과는

int : 1 int : 99 double : 3.2

이상하게 결과가 나옴

오버로딩의 과정 같은 경우

• 1 단계 자신과 타입이 정확히 일치하는 함수를 찾음

• 2 단계 정확히 일치하는 타입이 없는 경우 아래와 같은 형변환을 통해서 일치하는 함수를 찾아봄

  Char, unsigned char, short 는 int 로 변한왐

  Unsigned short 는 int 의 크기에 따라 int 혹은 unsigned int 로 변환됨

  Float 은 double 로 변환됨

  Enum 은 int 로 변환됨

• 3 단계 위와 같이 변환해도 일치하는 것이 없다면 아래의 좀더 포괄적인 형변환을 통해 일치하는 함수를 찾음

  임의의 숫자(numeric) 타입은 다른 숫자 타입으로 변환됨 ex) float -> int

  Enum 도 임의의 숫자 타입으로 변환ehla ex) Enum -> double

  0 은 포인터 타입이나 숫자 타입으로 변환된 0 은 포인터 타입이나 숫자 타입으로 변환됨

  포인터는 void 포인터로 변환됨

• 4 단계 유저 정의된 타입 변환으로 일치하는 것을 찾음

(만약에 컴파일러가 위 과정을 통하더라도 일치하는 함수를 찾을 수 없거나 같은 단계에서 두 개 이상이 일치하는 경우에 모호하다 (ambiguous) 라고 판단해서 오류를 발생하게 됨)

// 모호한 오버로딩
#include <iostream>

void print(int x) { std::cout << "int : " << x << std::endl; }
void print(char x) { std::cout << "double : " << x << std::endl; }

int main() {
  int a = 1;
  char b = 'c';
  double c = 3.2f;

  print(a);
  print(b);
  print(c);

  return 0;
}

error C2668: 'print' : ambiguous call to overloaded function could be 'void print(char)' or 'void print(int)' while trying to match the argument list '(double)'

• 일단 위 소스에서는 함수가 print (int x) 와 print (char x) 밖에 없으므로 관건은 print(c); 를 했을 때 어떠한 함수가 호출되어야 하는지 결정하는 것인데요, print(c) 를 했을 때 1 단계에서는 명백하게 일치하는 것이 없음
• 그래서 아무것도 없어서 오류가 나옴

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

힙

• 동적으로 할당된 변수가 할당되는 영역(Dynamic Memory Allocation)
• 프로그래머가 직접 공간을 할당, 해제하는 메모리 공간

스택

• 프로그램이 자동으로 사용하는 임시 메모리 영역

• 함수 호출 시 생성되는 지역 변수와 매개 변수가 저장되는 영역으로, 함수 호출이 완료되면 저장된 메모리도 해제됨

• C 언어에서는 malloc 과 free 함수를 지원하여 힙 상에서의 메모리 할당을 지원함

• C++ 에서도 마찬가지로 malloc 과 free 함수를 사용할 수 있는데 그것은 언어 차원에서 지원하는 것으로 바로 new 와 delete 라고 할 수 있음

new(동적 메모리 할당)

• 프로그램 실행 중에 heap 영역에 메모리를 할당
• 할당된 메모리의 주소(pointer)를 반환

delete (동적 메모리 해제)

• new로 할당한 메모리를 반드시 해제
• 해제하지 않으면 → 메모리 누수(memory leak) 발생

/* new 와 delete 의 사용 */
#include <iostream>

int main() {
  int* p = new int;
  *p = 10;

  std::cout << *p << std::endl;

  delete p;
  return 0;
}

사용방법

int* p = new int; 로 p 에 집어 넣었음을 알 수 있음 T* pointer = new T; 에 T 에는 임의의 타입이 들어가고 *p = 10; 를 통해서 값을 집어넣었고 이를 출력함

위와 같이 delete p 를 하게 되면 p 에 할당된 공간이 해제 가능

delete 로 해제할 수 있는 메모리 공간은 사용자가 new 를 통해서 할당한 공간만 가능

/* 지역 변수 delete 하기 */
#include <iostream>

int main() {
  int a = 5;

  delete &a;

  return 0;
}

이런경우 delete 로 해제해버리려 한다면 Heap 이 아닌 공간을 해제하려고 한다는 경고 메세지가 나타나게 됨

/* new 로 배열 할당하기 */

#include <iostream>

int main() {
  int arr_size;
  std::cout << "array size : ";
  std::cin >> arr_size;
  int *list = new int[arr_size];
  for (int i = 0; i < arr_size; i++) {
    std::cin >> list[i];
  }
  for (int i = 0; i < arr_size; i++) {
    std::cout << i << "th element of list : " << list[i] << std::endl;
  }
  delete[] list;
  return 0;
}

• *list = new int[arr_size]; 해당것은 이걸로 new로 힙에 메모리를 할당한것을 주소로 반환한것을 포인터에 저장한것

#include <iostream>

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

void create_animal(Animal *animal) {
  std::cout << "동물의 이름? ";
  std::cin >> animal->name;

  std::cout << "동물의 나이? ";
  std::cin >> animal->age;

  animal->health = 100;
  animal->food = 100;
  animal->clean = 100;
}

void play(Animal *animal) {
  animal->health += 10;
  animal->food -= 20;
  animal->clean -= 30;
}
void one_day_pass(Animal *animal) {
  // 하루가 지나면
  animal->health -= 10;
  animal->food -= 30;
  animal->clean -= 20;
}
void show_stat(Animal *animal) {
  std::cout << animal->name << "의 상태" << std::endl;
  std::cout << "체력    : " << animal->health << std::endl;
  std::cout << "배부름 : " << animal->food << std::endl;
  std::cout << "청결    : " << animal->clean << std::endl;
}
int main() {
  Animal *list[10];
  int animal_num = 0;

  for (;;) {
    std::cout << "1. 동물 추가하기" << std::endl;
    std::cout << "2. 놀기 " << std::endl;
    std::cout << "3. 상태 보기 " << std::endl;

    int input;
    std::cin >> input;

    switch (input) {
      int play_with;
      case 1:
        list[animal_num] = new Animal;
        create_animal(list[animal_num]);

        animal_num++;
        break;
      case 2:
        std::cout << "누구랑 놀게? : ";
        std::cin >> play_with;

        if (play_with < animal_num) play(list[play_with]);

        break;

      case 3:
        std::cout << "누구껄 보게? : ";
        std::cin >> play_with;
        if (play_with < animal_num) show_stat(list[play_with]);
        break;
    }

    for (int i = 0; i != animal_num; i++) {
      one_day_pass(list[i]);
    }
  }
  for (int i = 0; i != animal_num; i++) {
    delete list[i];
  }
}

• 해당것은 동물 관련으로 진행하는 미니게임 형식임

typedef struct Animal {
  char name[30];  // 이름
  int age;        // 나이

  int health;  // 체력
  int food;    // 배부른 정도
  int clean;   // 깨끗한 정도
} Animal;

• 이부분은 구조체로 서로 다른 타입의 데이터를 하나로 묶으로 지정하는 사용자 정의 자료형임

• void one_day_pass, play etc, 이것들은 함수로 지정하여 switch 로 지정했을때 그것을 할당하는것을 의미하는것임

• 키 포인트는 동물을 포인터로 만들어 그것을 선택하면 동물값을 입력하는 구조로 만듬

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

레퍼런스의 개념

int x = 10; int& r = x;

• r과 x는 완전히 동일한 객체

• r을 바꾸면 x가 바뀜

• 선언과 동시에 반드시 초기화 필요

• 한 번 바인딩되면 다른 변수로 변경 불가

• 포인터: 주소를 저장 (int* p)

• 래퍼런스: 변수의 별명 (int& r)

래퍼런스 = “복사가 아닌 원본 자체를 직접 다루는 별명”

#include <iostream>

int change_val(int *p) {
  *p = 3;

  return 0;
}
int main() {
  int number = 5;

  std::cout << number << std::endl;
  change_val(&number);
  std::cout << number << std::endl;
}

change_val 함수의 인자 p 에 number 의 주소값을 전달하여, *p 를 통해 number 를 참조하여 number 의 값을 3 으로 바꿈

int& another_a = a;

그 후에 우리는 a 의 참조자 another_a 를 정의하였습니다. 이 때 참조자를 정하는 방법은, 가리키고자 하는 타입 뒤에 & 를 붙이면 됨

int a = 10;
int* p = &a; // p 는 a 를 가리킨다.

int b = 3;
p = &b // 이제 p 는 a 를 버리고 b 를 가리킨다

• p는 a를 가리키는것 즉 a가 현재 주소값을 보여 그것을 가리킴
• b는 3의 주소값을 가리킴

#include <iostream>

int main() {
  int &ref = 4;

  std::cout << ref << std::endl;
}

• 오류가나옴
• 위 상수 값 자체는 리터럴 이기 때문에
• 프로그래밍 언어에서 리터럴(literal)이란, 소스 코드 상에서 고정된 값을 가지는 것을 일컫습니다

int a, b;
int& arr[2] = {a, b};

• 주소값이 존재한다라는 의미는 해당 원소가 메모리 상에서 존재한다 라는 의미와 같습니다. 하지만 레퍼런스는 특별한 경우가 아닌 이상 메모리 상에서 공간을 차지 하지 않습니다. 따라서 이러한 모순 때문에 레퍼런스들의 배열을 정의하는 것은 언어 차원에서 금지가 됨

int& function() {
  int a = 2;
  return a;
}

int main() {
  int b = function();
  b = 3;
  return 0;
}

-> [1] 7170 segmentation fault (core dumped) ./test 이런 오류가 나옴

int& ref = a;

// 근데 a 가 사라짐
int b = ref;  // !!!

• 레퍼런스가 필요한데 사라지게됨 이래서 문제임
• 따라서 위 처럼 레퍼런스를 리턴하는 함수에서 지역 변수의 레퍼런스를 리턴하지 않도록 조심해야함

int& function(int& a) {
  a = 5;
  return a;
}

int main() {
  int b = 2;
  int c = function(b);
  return 0;
}

• 이경우는 래퍼런스 값이 b로 연결이 되어 그대로 레퍼런스와 연결이 됨 그래서 오류가 안나옴

  #include <iostream>
  

int function() { int a = 5; return a; }

int main() { const int& c = function(); std::cout << "c : " << c << std::endl; return 0; }

이런 경우 const로 예외 상수로 받아 상수 레퍼런스로 리턴값을 받게 되면 해당 리턴값의 생명이 연장됨

| 함수 반환              | 받는 방식                | 가능 여부  | 동작 설명                         | 주의사항            |
| ------------------ | -------------------- | ------ | ----------------------------- | --------------- |
| `int f()` (값 반환)   | `int a = f()`        | 가능     | 값 복사됨                         | 없음              |
| `int f()` (값 반환)   | `int& a = f()`       | 컴파일 오류 | rvalue를 non-const 참조로 받을 수 없음 | -               |
| `int f()` (값 반환)   | `const int& a = f()` | 가능     | 임시 객체를 const 참조로 바인딩          | lifetime 연장     |
| `int& f()` (참조 반환) | `int a = f()`        | 가능     | 값 복사됨                         | 참조 의미 사라짐       |
| `int& f()` (참조 반환) | `int& a = f()`       | 가능     | 원본 변수 참조                      | **지역 변수 반환 금지** |
| `int& f()` (참조 반환) | `const int& a = f()` | 가능     | const 참조로 바인딩                 | **지역 변수 반환 금지** |




---
### 참고
https://modoocode.com/141

해당 내용은 씹어먹는 C++ 책을 기반으로 하단 블로그의 내용을 공부하기위해 적성한 글임을 알립니다.

씹어먹는 C++ - <1 - 2. 첫 C++ 프로그램 분석하기>

#include <iostream>

int main() {
  std::cout << "Hello, World!!" << std::endl;
  return 0;
}

#include

• 해당 부분은 C++ 에서 표준 입출력에 대한 필요한것을 포함함

int main()

• C 와 마찬가지로 C++ 에서의 main 함수는 프로그램이 실행될 때 가장 먼저 실행되는 함수

std::cout << "Hello, World!!" << std::endl; return 0;

• std::cout 은 화면에 무언가 출력시켜주는 것 같은데, printf 와 다르게 사용된 것을 보니 함수 같지는 않네요. 그리고 화면에 출력된 것을 대충 보면 "계속하려면 아무 키나 누르세요" 가 한 줄 개행되어서 나온 것을 보니 std::endl 은 한 줄 엔터를 쳐서 나타내라는 표시

  • main 함수에서도 return

std::cout

• std 는 C++ 표준 라이브러리의 모든 함수, 객체 등이 정의된 이름 공간(namespace)
• std 라는 이름 공간에 정의되어 있는 cout 을 의미 합니다. 만약에 std:: 없이 그냥 cout 이라고 한다면 컴파일러가 cout 을 찾지 못합니다. 서울에 사는 철수인지 부산에 사는 철수 인지 알 길이 없기 때문

#include "header1.h"
#include "header2.h"

namespace header1 {
int func() {
  foo();           // 알아서 header1::foo() 가 실행된다.
  header2::foo();  // header2::foo() 가 실행된다.
}
}  // namespace header1

• 소속을 밝히면 이게 이거를 불러오게 됨

  #include "header1.h"
  #include "header2.h"
  using namespace header1;
  

int main() { header2::foo(); // header2 에 있는 함수를 호출 foo(); // header1 에 있는 함수를 호출 }

어쩃든 호출하는것임

---

  다시 돌아가서

int main() { std::cout << "Hello, World!!" << std::endl; return 0; }

두 iostream 헤더파일의 std 라는 이름 공간에 정의되어 있는 것을 불러옴

#include using namespace std;

int main() { cout << "Hello, World!!" << endl; return 0; }

귀찮은면 이렇게 함

---
## 씹어먹는 C++ - <1 - 3. C++ 은 C 친구 - C 와 공통점>

// 변수의 정의 #include

int main() { int i; char c; double d; float f;

return 0; }

변수 정의

int arr[10]; int *parr = arr;

int i; int *pi = &i;

- 포인터로 arr[10]이라는 배열이 있음
- int *parr = arr; parr 포인터로 받는 변수를 정해 arr 값의 &arr[0] 주소 값을 저장
 - parr = 1000(&arr[0]의 주소값)
  - *parr = arr[0] 즉 1000이 가리키는 값이 되어 arr[0] 이됨

  - i라는값이 있음
  - i의 주소값을 출력해서 pi포인터에 저장

// C++ 의 for 문 #include

int main() { int i;

for (i = 0; i < 10; i++) { std::cout << i << std::endl; } return 0; }

반복문(for, while)

// switch 문 이용하기 #include

using std::cout; using std::endl; using std::cin;

int main() { int user_input; cout << "저의 정보를 표시해줍니다" << endl; cout << "1. 이름 " << endl; cout << "2. 나이 " << endl; cout << "3. 성별 " << endl; cin >> user_input;

switch (user_input) { case 1: cout << "Psi ! " << endl; break;

case 2:
  cout << "99 살" << endl;
  break;

case 3:
  cout << "남자" << endl;
  break;

default:
  cout << "궁금한게 없군요~" << endl;
  break;

} return 0; }

``` switch 문

출처 https://modoocode.com/136

예제 입력 1 5 0 -7 -3 -2 5 8

예제 출력 1 1

study part

• 항상 보는 백트래킹으로 문제를 풀이함

    if(arrange_count==input_count)
    {
        return 0;
    }

    if(sum_value+arrange_value[arrange_count]==input_sum)
    {
        output_count+=1;
    }

• 이부분에서는 먼저 기입한 값과 동일하면 끝 그리고 input_sum이 같으면 output_count+1 형식으로 결과를 도출하고 자함

    check_num(sum_value,arrange_count+1);
  
    check_num(sum_value+arrange_value[arrange_count],arrange_count+1);
  
    return 0;

• 이부분에서는 진행정도와 값이 계속 누적되는것을 추가하는것으로 합해지는것 이렇게 해서 check_num을 만드는것

code

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;

int input_count;

int input_sum;

int output_count = 0;

vector <int> arrange_value;

int check_num(int sum_value,int arrange_count)
{
    if(arrange_count==input_count)
    {
        return 0;
    }

    if(sum_value+arrange_value[arrange_count]==input_sum)
    {
        output_count+=1;
    }

    check_num(sum_value,arrange_count+1);

    check_num(sum_value+arrange_value[arrange_count],arrange_count+1);

    return 0;
}

int main()
{
    cin>>input_count>>input_sum;
    arrange_value.resize(input_count);

    for(int i = 0 ; i<input_count;i++)
    {
        cin>>arrange_value[i];
    }

    check_num(0,0);

    cout<<output_count;

}

해당 글은 개인적으로 공부하기 위한 글로 알아주시면 감사하겠습니다.

1.시스템 구조

개루프 시스템

• 개루프 시스템은 입력 명령을 제어하기에 적합한 형태로 변환하는 입력변환기(input transducer)라는 보조 시스템으로 시작함
• 입력은 기준입력(reference)로 칭하며 출력은 피제어 변수(controlled variable)라고 칭함
• 외란과 같은 신호는 입력되는 신호들을 대수적으로 합하는 접합점(summing junction)에서 제어기나 공정의 출력과 합해짐
• 질량이 움직일때 일정한 힘을 소모하는 제동기(damper)와 질량 및 스프링으로 구성되는 기계 시스템은 또 다른 개루프 시스템의 한 예임
• 개루프는 외란에 민감하여 외란을 제거하지 못하는 것이 단점

폐루프 시스템(feedback system)

• 입력 변환기는 입력 명령을 제어기에 적합한 형태로 변환시키며 출력변환기(output transducer) 또는 센서(sensor)로 출력을 측정하여 제어기에 적합한 형태로 변환
• 접합점으로 피드백 경로(feedback path)을 통하여 도달하는 출력 신호와 입력 신호를 대수적으로 합함
• 출력 신호의 부호가 반전되어 신호가 합해지는데 이를 구동신호(actuating signal)이라고 함
• 실제 입력과 출력의 차가 구동 신호가 되는데이를 오차(error) 라고 함
• 간단한 이득 조정을 하거나 제어기를 재설계함으로 써 과도 응답과 정상 상태 오차를 개선시키는것을 보상(compensating)이라고 함 재설계된 하드웨어를 보상기(compensator)라고 함

2. 해석과 설계 목적

과도 응답

• 과도 응답이 너무 빠르면 복구하지 못할 물리적 손상을 시스템에 입힐수 있음

  정상상태 응답

  안정도

• 과도 응답과 정상 상태 오차에 대한 해석과 설계는 시스템이 안정하지 않는 경우에는 의미가 없음
• 고유응답(natural response)과 강제응답(foreced responser)의 합으로 표시됨
• 이런 응답을 각각 동차해(homogeneous solution), 특이해(particular solution)이라함
• 선형시스템은 전체 응답의 다음과 같이 표현됨 $$ 전체 응답 = 고유 응답 + 강제응답 $$

  사례연구

• 이런 진동하거나 정상 상태에서는 고유응답이 0으로 되어 강제응답만 남는 경우 불안정(instability)라고 함
• 감쇠진동(daped oscillation) : 시간에 따라 크기가 줄어드는 정현파 응답하는 과도 상태를 갖게 되는것

  3. 설계 절차

  1단계 : 요구조건에 맞는 실제 시스템 선정

• 요구 조건에 맞는 실제 시스템(physical system)을 선정함

  2단계 : 기능별 블럭선도 작성

• 정상적으로 표현된 시스템의 각 부분을 기능별 블록선도로 나타내고 이를 블록들을 상호 연결하여 전체 블록선도를 완성함

  3단계 : 구조 개요도 도안

• 예로 직류전동기(dc motor) 구동 시키기 위해 차동 증폭기(differential amplifier)와 전력 증폭기는 각각 이득이나 전력 증폭을 하는 제어기로 사용됨
• 부하(load)의 경우 회전하는 질량과 베어링 마찰을 가지므로 부하 모델은 자동차의 충격 흡수 장치나 스크린 문 제동기(screen door damper)와 같이 속도와 증가함에 따라 역회전 토크(torque)가 증가되는 관성(inertia)와 점성마찰(viscous damping)으로 표현됨

4단계 : 수학적 모델의 개발

• 시스템 구조에 대한 개요도가 완성되면 전기 회로에 kirchhoff의 법칙과 실제 시스템에 대해 적용되는 Newton의 법칙과 같은 물리적 법칙과 가정을 이용하여 시스템을 모델링함
• kirchhoff의 전압 / 전류 법칙, newton의 법칙을 이용하면서 동적 시스템의 입력과 출력 사이의 관계를 나타내는 수학적 모델링을 얻을수 있음
• 선형 시불변 미분방정식(linear time-invariant differential equation)으로 표시됨
• 시스템 모델은 차수가 높아지거나 비선형 시변(nonlinear time varying) 또는 편미분 방정식(partial differential equation)으로 표현됨
• 전달함수(transfer function)은 시스템을 수학적으로 모델링하는 방법으로 전달함수를 laplace변환을 이용하여 선형 시불변 미분방정식으로 유도됨
• 상태공간(state space)에서도 시스템 모델이 표현될수 있음 이는 모델을 상태 공간에서 표현하려는 이유는 선형 미분 방정식으로 나타낼수 없는 시스템에서도 적용할수 있을 뿐만 아니라 시뮬레이션하기 편한 형태로 나타낼수 있기 때문

  5단계 : 블럭선도 단순화

  6단계 : 해석과 설계

  
• 계단 함수 : 위치 속도나 가속도가 일정한 크기를 가질때 입력 명령을 표시하는데 사용됨
• 램프 함수 입력 : 선형으로 증가하는 명령을 나타냄
• 정현파 입력 : 시스템에 대한 수학적 모델을 유도하기 위하여 실제 시스템을 시험하는데 이용됨

감도(sensitivity) : 시스템 파라미터 변동에 대한 성능 변동을 퍼센트로

english version

1. System Architecture

1.1 Open-Loop Systems

An open-loop control system operates without feedback.

• The system begins with an input transducer, which converts the command into a form suitable for the controller/plant.
• The input signal is called the reference input.
• The output is referred to as the controlled variable.
• Disturbances may enter at a summing junction, where signals are algebraically combined.

Example: A mechanical system composed of a mass, spring, and damper.

• A damper dissipates energy (typically proportional to velocity).

Limitation:
Open-loop systems are sensitive to disturbances and cannot automatically correct for unexpected variations, leading to degraded accuracy and robustness.

1.2 Closed-Loop Systems (Feedback Systems)

A closed-loop system uses feedback to reduce error and improve robustness.

• The input transducer converts the reference command for the controller.
• A sensor (output transducer) measures the output and converts it into a comparable signal form.
• The measured output returns through the feedback path to the summing junction.

The error (actuating signal) is:

$$ e(t) = r(t) - y(t) $$

where:

• $r(t)$: reference input
• $y(t)$: output
• $e(t)$: error (actuating signal)

Compensation

Improving transient response or steady-state error by gain adjustment or controller redesign is called compensation. The redesigned element is called a compensator.

2. Objectives of Analysis and Design

Control design typically focuses on:

• Transient response
• Steady-state response
• Stability

2.1 Transient Response

Transient response describes system behavior before reaching steady state.

Key measures include:

• rise time
• peak time
• overshoot
• settling time

Engineering note: An excessively fast transient can cause actuator saturation or physical damage in real systems.

2.2 Steady-State Response

Steady-state response describes long-term behavior after transients decay.

A key metric is the steady-state error, which depends on:

• system type
• input class (step, ramp, etc.)

2.3 Stability

If the system is unstable, transient and steady-state specifications are meaningless.

For an LTI system:

$$ \text{Total Response} = \text{Natural Response} + \text{Forced Response} $$

• Natural response = homogeneous solution
• Forced response = particular solution

For a stable system:

$$ \lim_{t \to \infty} \text{Natural Response} = 0 $$

Damped Oscillation

A damped oscillation is a transient sinusoidal response whose amplitude decreases over time due to dissipation.

3. Design Procedure

Step 1: Select the Physical System

Select a physical system that satisfies the given performance requirements, constraints, and operating conditions.

Step 2: Build the Functional Block Diagram

Represent each subsystem as a functional block and interconnect them to describe overall signal flow.

Step 3: Draw the Structural Schematic

Example: DC motor drive system

• differential amplifier: gain control
• power amplifier: power amplification
• load: inertia + viscous damping

A common load model:

$$ T = J\dot{\omega} + B\omega $$

where:

• $J$: inertia
• $B$: viscous damping
• $\omega$: angular velocity

Step 4: Develop the Mathematical Model

Use physical laws:

• Kirchhoff’s Voltage/Current Laws (electrical)
• Newton’s Second Law (mechanical)

Typical result: an LTI differential equation relating input and output.

Transfer Function

Applying Laplace transform:

$$ G(s) = \frac{Y(s)}{R(s)} $$

State-Space Model

State equation:

$$ \dot{x} = Ax + Bu $$

Output equation:

$$ y = Cx + Du $$

Why state-space?

• supports MIMO
• handles nonlinear extensions
• convenient for simulation
• foundation of modern control

Step 5: Block Diagram Reduction

Simplify interconnected blocks using algebraic reduction rules to obtain the overall system form.

Step 6: Analysis and Controller Design

Design the controller to satisfy:

• stability
• transient performance
• steady-state accuracy
• robustness

4. Standard Test Inputs

• Step input: represents a sudden command (often used in position control evaluation)
• Ramp input: represents a linearly increasing command (useful for tracking analysis)
• Sinusoidal input: used for frequency-response testing and system identification

5. Sensitivity

Sensitivity measures performance variation due to parameter changes:

$$ S = \frac{% \text{ change in output}}{% \text{ change in parameter}} $$

Low sensitivity implies strong robustness to modeling uncertainty and component tolerances.

6. Core Design Balance

Control design fundamentally balances:

1. Stability
2. Performance
3. Robustness

감속비 : 감속기어를통해 모터의엔진의 입력 회전 속도를 얼마나 줄여서 출력하는지를 나타내는 비율 즉 이거를 하면 기본 모터 단독 스펙에 rpm 자체가 1/14로 줄어들게 됨

허용 부화 : kg/cm 인데 이게 작동하고 나서 유지하는 힘을 기입

순시허용 토크 : 처음 시작할때 확 올라가는 토크임 이것도 최대 토크는 처음 시작하는 힘 그리고 최대 출력으로는 그냥 유지 될수 있는힘

1 2 3 5 8 13 1 2 3 5 8 21 1 2 3 5 8 34 1 2 3 5 13 21 1 2 3 5 13 34 1 2 3 5 21 34 1 2 3 8 13 21 1 2 3 8 13 34 1 2 3 8 21 34 1 2 3 13 21 34 1 2 5 8 13 21 1 2 5 8 13 34 1 2 5 8 21 34 1 2 5 13 21 34 1 2 8 13 21 34 1 3 5 8 13 21 1 3 5 8 13 34 1 3 5 8 21 34 1 3 5 13 21 34 1 3 8 13 21 34 1 5 8 13 21 34 2 3 5 8 13 21 2 3 5 8 13 34 2 3 5 8 21 34 2 3 5 13 21 34 2 3 8 13 21 34 2 5 8 13 21 34 3 5 8 13 21 34

Study code

• 해당 문제를 풀면서 이제 이해헀다고 생각했는데 아직 이해를 못했다
• 결과적으로 또 반복하지만 내 위치를 파악하고 그 위치에 도착하면 결과를 출력해라 이것이 메인임
• 또 해당 결과가 함축했다가 나오는게 아니라 할때마다 계속나와도 되는 것을 파악하고 0 에 결과가 아니라 그냥 할때 마다 결과를 도출함
• 그리고 여기서 굳이 2차원을 만들필요도 없었고 그냥 1차원으로 해서 만들어도 되었음
• 그래서 필요없는 clear를 쓰고 이런거임
• 결론적으로 도착하면 결과 그리고 layer 자체가 내가 input 한거 보다 이상 넘어갈수 있어서 그게 아니면 return임
• 추가적으로 void 라서 return 0 이 아니라 return임
• 백트래킹으로 계혹 들어가는 것과 재귀를 활용함
• 그래서 값을 계속 저장하고 for은 현재 layer로 이동한것이니 시작은 layer로 잡음
• 그리고 재귀는 result_function에 i를 넣으면서 해당 루프에 전체를 다 수색하게 함

추가적인것 2차원 resize하는거 ㄱemind

int n
cin >>n;

vector <vector<int>> new;

new.reszie(n);

for(int = 0 ; i < n;i++)
{
    new[i].resize(n);
}

or

vector <vector<int>> new(n, vector<int>(n));

Code

#include <iostream>
#include <string>
#include <vector>

using namespace std;

vector<vector<int>> input_list;

int input_value;

int value_result[6];

void result_function(int layer,int count)
{
    if(count==6)
    {
        for(int i=0 ; i<6 ; i++)
        {
            cout<<value_result[i]<<" ";
        }
        cout<<"\n";
        return;
    }

    if(layer>=input_value) return;

    for(int i=layer ; i<input_value ; i++)
    {
        value_result[count]=input_list[0][i];
        result_function(i+1,count+1);
    }
}

int main()
{
    while(1)
    {
        cin>>input_value;

        if(input_value == 0)
        {
            return 0;
        }

        vector <int> row_value(input_value);

        for(int i = 0; i<input_value ; i++)
        {
            cin>>row_value[i];
        }

        input_list.clear();
        input_list.push_back(row_value);
        result_function(0,0);
        cout<<"\n";
    }


}

예제 출력 1 35

Study code

Part1

• 2차원 배열을 만들어야 하는데 vector와 포인터 중에 뭐를 쓸지 고민했음
• 그래서 오래간만에 포인터를 활용하여 2차원 배열을 만들고자 했음
• 하지만 gpt나 현업에서는 vector를 사용하는것이 일반적이라고 함
• 포인터를 쓰게 되면 이렇게 메모리를 만들어줘야함 a │ ├─ a[0] ──▶ int int int int ├─ a[1] ──▶ int int int int ├─ a[2] ──▶ int int int int └─ a[3] ──▶ int int int int

int** a;

    a = new int*[input_num];

    for(int j = 0 ; j < input_num;j++)
    {
        a[j] = new int[input_num];
    }   

그래서 이렇게 진행해야 함

• 이렇게 한다음 그냥 2차원 배열 사용하듯이 평법하게 사용하면 됨
• 다 사용하고 나서 하단같이 메모리를 delete를 해야함
• 안그러면 메모리 누수 또는 런타임 오류가 나올수 있음

    for (int i = 0; i < input_num; i++)
    {
    delete[] a[i];
    }
    delete[] a;

• 각 행마다의 delete와
• 모든 행의 delete를 진행하는것

Part2

• 이번 문제를 풀면서 코드를 전체를 이해하기 보다는 흐름을 이해해야하는것으로 초점을 두었음
• 해당 문제에 대한 개념은 결과적으로 백트래킹으로 계속돌아가고 브루트포스로 숫자를 넣어서 비교하는 것으로 진행되어야 했음
• 그래서 내가 보았을때는 결론적으로 이렇다.

1. 해당 계산 함수의 시작은 처음 목표값까지 도달으면 그 결과를 나오게 하는것 1-1. 하지만 결과가 나오게 되는 것까지 특정 부분에서 예외가 있는경우가 있으니 return을 하거나 loop 구분이 있을시 continue로 넘어가는것

2. 다음것은 결과적으로 모든 것의 코드 그리고 index가 있을것이다. 그것을 빠르게 봐야하는 것, 그리고 방문을 했는지 안했는지 판단하는것이 가장 중요하고 계속해서 반복해야하는 부분은 check() 이부분을 반복해야한다. 2-1. 그래서 일단 그 index가 방문했는지 안했는지 판단하여 loop에 if을 해서 있으면 continue로 해서 넘어가고 아니면 그 다음 스텝을 가는것으로 진행 2-2. 그렇게 다음으로 가는것은 앞서 말한대로 check을 불러오는것을 시작으로 그 값에 추가를 하고 계속 자기자신을 불러옴 그리고 그 밑에는 방문을 했으니 flase로 방문을 끝냄

-> 여기서 중요한게 check를 하기전에는 true인지 false인지 check을 하고 false면 true로 만들어주고 끝나면 false로 만들어줌

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

using namespace std;

int input_num;

bool ch[11] = {false,};

int** a;

int output_result = 1e9;

void check(int start,int index,int cnt,int sum_num)
{
    if (sum_num >= output_result) return; 

    if(cnt==input_num)
    {
    if(a[index][start]==0) return;

    output_result = min(output_result, sum_num + a[index][start]);
    return;
    }

    for(int i = 0;i<input_num;i++)
    {
        if(a[index][i]==0||ch[i]) continue;
        ch[i]=true;
        check(start,i,cnt+1,sum_num+a[index][i]);
        ch[i]=false;
    }
}

int main()
{
    cin>>input_num;
    a = new int*[input_num];

    for(int j = 0 ; j < input_num;j++)
    {
        a[j] = new int[input_num];
    }   

    for(int i = 0 ; i< input_num;i++)
    {
        for(int j = 0 ; j < input_num;j++)
        {
            cin>>a[i][j];
        }   
    }

    for (int i = 0; i < input_num; i++)
    {
        ch[i] = true;
        check(i,i,1,0);
        ch[i] = false;
    }

    cout<<output_result;

    for (int i = 0; i < input_num; i++)
    {
    delete[] a[i];
    }
    delete[] a;

    /*
    메모리 누수 또는 런타임 오류
    */

    return 0;
}

예제 입력 1 6 20 1 15 8 4 10

예제 출력 1 62

code study

• 저기 절대값이 있다는것을 순간적으로 몰라서 멍때리다가 절대값이라길래 아하 하고 풀었음
• next_permutation을 활용하였고 저번과 같이 배열을 sort를 하여 순서대로 하고 수식을 넣어 하나하나 비교하면서 풀었음
• sort(input_value.begin(),input_value.end()); 이방향으로 진행함
• 절댓값ㄷ이 abs라는것을 한번더 상기

•   for(int i = 0; i<input_count-1;i++)
    {
       check_result+=abs(input_value[i]-input_value[i+1]);
    }

  이부분에서 어디까지라는것을 먼저 확인하고 들어감

code

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;

int input_count;

vector <int> input_value;

int output_result = 0;

int check_result;


void check_num()
{
    do
    {
    for(int i = 0; i<input_count-1;i++)
    {
       check_result+=abs(input_value[i]-input_value[i+1]);
    }
    if(output_result < check_result)
    {
        output_result=check_result;
    }
    check_result=0;
    }while(next_permutation(input_value.begin(),input_value.end()));

    cout<<output_result;
}

int main()
{
    cin>>input_count;

    input_value.resize(input_count);

    for(int i = 0; i<input_count;i++)
    {
        cin>>input_value[i];
    }    

    sort(input_value.begin(),input_value.end());

    check_num();
}

예제 입력 1 4 1 2 3 4 예제 출력 1 1 2 4 3

예제 입력 2 5 5 4 3 2 1 예제 출력 2 -1

공부내용

• next_permutation를 배웠는데 이는 순열의 다음것을 출력해주는것임
• 이는 algorithm을 활용하면 #include가 있어야함
• prev_permutation를 활용하면 전꺼가 되니까 기억해라

    if(next_permutation(get_num.begin(),get_num.end()))
    {
        for(int i = 0;i<in_num;i++)
        {
            cout<<get_num[i]<<' ';
        }
    }

  이렇게 하면 다음께 출력이 되고

    do{ 
    for(int i = 0;i<in_num;i++) 
    {
        cout<<get_num[i]<<' ';
    }
    }while(next_permutation(get_num.begin(),get_num.end()));```

이렇게 하면 모든 순열이 출력이 된다

code

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;

int in_num;

vector <int> get_num; 


int main()
{
    cin>>in_num;

    get_num.resize(in_num);

    for(int i = 0;i<in_num;i++)
    {
        cin>>get_num[i];
    }


    if(next_permutation(get_num.begin(),get_num.end()))
    {
        for(int i = 0;i<in_num;i++)
        {
            cout<<get_num[i]<<' ';
        }
    }
    else
    {
        cout<<-1;
    }

    return 0;
}

예제 입력 1 4 -+0++++--+ 예제 출력 1 -2 5 -3 1

예제 입력 2 2 +++ 예제 출력 2 3 4

예제 입력 3 5 ++0+-+-+--+-+-- 예제 출력 3 1 2 -3 4 -5

공부

• 해당 코드를 공부하면서 시간을 많이 쓴것 같음
• 허나재귀 파트의 마지막 문제라서 조금더 집중을 한것같음
• 해당부분에서 중요한것은 이 세가지라고 생각함

1. 함수시작에 원하는 개수가 내가 input한 개수와 일치할 경우 그 최종결과를 출력하는것
2. return과 continue를 활용하여 넘어갈 것은 if을 통해 확인하고 바로 넘어가기 그리고 줄 넘버는 바로 주기
3. return을 수치를 return 하는것이 아닌 bool을 return함으로써 현재 그 수치가 이 안에 들어와도 되는지 확인하기

이렇게 되는것 같은데

즉 브루토포스로 수치를 다때려 박으면서 재귀를 통해 계속 자기자신을 반복하는것임 그리고 앞서 말할것 처럼 이 방법이 맞는지 확인하고 아니면 바로 돌아가는 것으로 다시 돌아가서 확인하는 백트래킹으로 진행하는것임

코드

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>

using namespace std;

char input_num_index[10][10];

int count_num;

int result[10];

bool check_num(int count_void)
{
    int sum = 0;
    for(int i = count_void;i>=0;i--)
    {
        sum = sum+result[i];
        if(input_num_index[i][count_void]=='+'&&sum<=0)
        return false;
        if(input_num_index[i][count_void]=='-'&&sum>=0)
        return false;
        if(input_num_index[i][count_void]=='0'&&sum!=0)
        return false;
    }
    return true;
}

void bfs(int count_void)
{
    if(count_void == count_num)
    {
        for(int i = 0 ; i<count_void;i++)
        {
            cout<<result[i]<<" ";
        }
        exit(0);
    }

    for(int i = -10;i<=10;i++)
    {
        if(input_num_index[count_void][count_void]=='+' && i<=0) continue;
        if(input_num_index[count_void][count_void]=='-'&& i>=0) continue;
        if(input_num_index[count_void][count_void]=='0'&& i!=0) continue;

        result[count_void] = i; 

        if(check_num(count_void)==true)
        {
            bfs(count_void+1);
        }
    }
}

int main()
{
    int input_bo_index = 0;

    string input_bo;

    cin>>count_num;

    cin>>input_bo;

    for(int i = 0;i<count_num;i++)
    {
        for(int j = i; j<count_num;j++)
        {
            input_num_index[i][j]=input_bo[input_bo_index++];
        }
    }

    bfs(0);
}

예제 입력 1 2 < >

예제 출력 1 897 021

예제 입력 2 9

< < < > > > < <

예제 출력 2 9567843012 1023765489

공부노트

• bool check(char big_small,int f_num,int sec_num)
  처음에는 해당 부분에서 bool check 하는 부분이 어떻게 체크를 해야하는지 몰랐음 그래서 보니까 bool로 return을 해야하는것으로 bool로 바꾸고 진짜 이 기호가 이 숫자가 들어가도 된다 안된다를 true false로 한다는 것에서 신선하게 이해개 되었음

• results.push_back(num); 처음에 전체 코드가 완성되면 해당 답에 push를 하여 답을 넣어서 출력하는 식이었음

• 코드의 핵심 알고리즘

    if(visit[i]) continue;
  
    else if(depth==0)
    {
        visit[i]=true;
        check_num(depth+1,num+to_string(i));
        visit[i]=false;
    }
    else
    {
        int change_int = num[depth-1]-'0';
        if(check(equality[depth-1],change_int,i))
        {
        visit[i]=true;
        check_num(depth+1,num+to_string(i));
        visit[i]=false;
        }
    }

  이부분에서

코드

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int input_value;

char equality[10];

bool visit[10];

vector<string> results;

bool check(char big_small,int f_num,int sec_num)
{
    if(big_small=='<')
    {
        return f_num < sec_num;
    }
        if(big_small=='>')
    {
        return f_num > sec_num;
    }
    return false;
} 

void check_num(int depth, string num)
{
    if(depth==input_value+1)
    {
        results.push_back(num);
        return;
    }

    for(int i = 0;i<=9;i++)
    {
        if(visit[i]) continue;

        else if(depth==0)
        {
            visit[i]=true;
            check_num(depth+1,num+to_string(i));
            visit[i]=false;
        }
        else
        {
            int change_int = num[depth-1]-'0';
            if(check(equality[depth-1],change_int,i))
            {
            visit[i]=true;
            check_num(depth+1,num+to_string(i));
            visit[i]=false;
            }
        }
    }
}

int main()
{   
    cin>>input_value;

    for(int i=0 ;i<input_value;i++)
    {
        cin>>equality[i];
    }

    check_num(0,"");

    sort(results.begin(),results.end());
    cout<<results.back()<<"\n";

    cout<<results.front()<<"\n";    

}

공부노트

• 해당 개념에서 백트래킹을 배우면서 우리가 원하는 값이 안나오면 돌아간다라는 개념을 공부하게 되었음
• 14889의 문제 같은경우 상대팀과 내 팀의 인원이 같은경우를 생각해야 되어서 n/2를 하며 진행함
• 그렇게 나누어진 부분을 벡터에 init하고 다음 score값에다가 배열을 하나하나 넣는 방식으로 진행함
• 그리고 team 부분에 continue 즉 방문을 한 것 우리팀인 것일 경우 continue를 진행하여 다음 for로 가게 만들어 진행함

14889코드

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int line;

int layer[20][20];

int lower_value = 500;

bool team[20];

void teamset(int mem, int fight_mem)
{
    vector<int> start;
    vector<int> link;

    int start_score = 0;

    int link_score = 0;

    if (fight_mem == line/2)
    {
        for(int i = 0 ; i < line ; i++)
        {
            if(team[i]==true)
            {
                start.push_back(i);
            }
            else
            {
                link.push_back(i);
            }
        }

        for(int i = 0 ; i<line/2 ; i++)
        {
            for(int j = 0 ; j<line/2 ; j++)
            {
               start_score+=layer[start[i]][start[j]];
               link_score+=layer[link[i]][link[j]];
            }
        }

        lower_value = min(lower_value,(abs(start_score-link_score)));
        return;
    }

    for(int i = mem ; i < line ; i++)
    {
        if(team[i])
        {
        continue;
        }
        else
        {
            team[i]=true;
            teamset(i,fight_mem+1);
            team[i]=false;
        }
    }
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(NULL);

    cin>>line;

    for(int i = 0 ; i<line;i++)
    {
        for(int j = 0 ; j<line;j++)
        {
            cin>>layer[i][j];
        }
    }
    teamset(0,0);
    cout<<lower_value;
}

예제 입력 1 4 0 1 2 3 4 0 5 6 7 1 0 2 3 4 5 0 예제 출력 1 0 예제 입력 2 6 0 1 2 3 4 5 1 0 2 3 4 5 1 2 0 3 4 5 1 2 3 0 4 5 1 2 3 4 0 5 1 2 3 4 5 0 예제 출력 2 2 예제 입력 3 8 0 5 4 5 4 5 4 5 4 0 5 1 2 3 4 5 9 8 0 1 2 3 1 2 9 9 9 0 9 9 9 9 1 1 1 1 0 1 1 1 8 7 6 5 4 0 3 2 9 1 9 1 9 1 0 9 6 5 4 3 2 1 9 0 예제 출력 3 1

공부노트

• 이번 문제는 전문제와 다르게 팀수가 제한이 없었음
• 그래서 일단 모든팀을 true로 만든다음(우리팀으로 만든다음) 내부에 한팀이라도 size가 0이면 return을 하여 다음 함수로 가게 만듬
• 그리고 link와 start팀은 수가 각각 다르다고 판단하여 size도 나누어 score 값을 추출하고자 함

15661코드

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int input_value[20][20];

int input_count;

int output_answer=50;

bool are_you[20];

void teamset(int count)
{
    vector<int> link;
    vector<int> start;

    int link_score = 0;

    int start_score = 0;


    if(count==input_count)
    {
        for(int i=0;i<input_count;i++)
        {
            if(are_you[i]==true)
                link.push_back(i);
            else
                start.push_back(i);
        }

        if(link.size()==0 || start.size()==0)
        {
            return;
        }

        for(int i = 0;i<link.size();i++)
            for(int j = 0;j<link.size();j++)
            {
                link_score+=input_value[link[i]][link[j]];
            }

        for(int i = 0;i<start.size();i++)
            for(int j = 0;j<start.size();j++)
            {
                start_score+=input_value[start[i]][start[j]];
            }
            output_answer = min(output_answer,abs(link_score-start_score));
            return;
    }

    are_you[count]=true;

    teamset(count+1);

    are_you[count]=false;

    teamset(count+1);

}

int main()
{
    cin>>input_count;

    for(int i=0;i<input_count;i++)
    {
        for(int j=0;j<input_count;j++)
        {
            cin>>input_value[i][j];
        }
    }

    teamset(0);

    cout<<output_answer;

}