1. 애플리케이션 테스트 케이스 설계

01. 애플리케이션 테스트 케이스 작성 ⭐⭐⭐

1) 소프트웨어 테스트의 이해

① 소프트웨어 테스트

• 개발된 응용 애플리케이션이나 시스템이 사용자가 요구하는 기능과 성능, 사용성, 안정성 등을 만족하는지 확인하고, 노출되지 않은 숨어있는 소프트웨어의 결함을 찾아내는 활동

② 소프트웨어 테스트 필요성

• 오류 발견 관점 : 프로그램에 잠재된 오류를 발견하고 이를 수정
• 오류 예방 관점 : 프로그램 실행 전 동료 검토, 워크 스루, 인스펙션 등을 통해 오류 사전 발견
• 품질 향상 관점 : 사용자의 요구사항 및 기대 수준 만족을 위해 반복적인 테스트를 거쳐 신뢰도 향상

③ 소프트웨어 테스트의 기본 원칙 ⭐

1. 소프트웨어 테스트 원리

   원리	설명
   결함 존재 증명	- 결함은 없을 수 없기에 존재함을 밝히고 줄이는 방향
   완벽한 테스팅은 불가능	- 무한 경로, 무한 입력값
   초기 집중	- 조기 테스트 설계 장점 : 테스팅 결과를 단시간에 알 수 있고, 재작업을 줄여 개발 기간 단축 및 결함 예방 - 요르돈의 법칙(Snowball Effect, 눈덩이 법칙)
   결함 집중	- 적은 수의 모듈에서 대다수 결함 발견 - 파레토 법칙(Pareto Principle) : 오류 80%는 전체 모듈 20% 내에서 발견
   살충제 패러독스	- 동일한 테스트 케이스에 의한 반복적 테스트는 새로운 버그 찾지 못함 - 테스트 케이스의 정기적 리뷰와 개선 필요
   정황 의존성	- 소프트웨어의 성격에 맞게 테스트 실시 - 정황과 비즈니스 도메인에 따라 테스트를 다르게 수행
   오류-부재의 궤변	- 요구사항을 충족시켜주지 못하면, 결함이 없어도 품질이 높지 않음

2. 소프트웨어 테스트 프로세스

   • 테스트 계획 → 테스트 분석 및 디자인 → 테스트 케이스 및 시나리오 작성 → 테스트 수행 → 테스트 결과 평가 및 리포팅

3. 소프트웨어 테스트 산출물

   산출물	설명
   테스트 계획서 (Test Plan)	테스트 목적과 범위, 대상 시스템 구조, 테스트 수행 절차, 테스트 일정, 조직의 역할 및 책임, 종료 조건 등 테스트 수행 계획 문서
   테스트 베이시스 (Test Basis)	분석, 설계 단계의 논리적인 Case로 테스트 설계를 위한 기준이 되는 문서 (요구사항 명세서, 관련 기준 또는 표준 등)
   테스트 케이스 (Test Case)	테스트를 위한 설계 산출물, SW가 요구사항을 준수하는지 확인하기 위해 설계된 입력값, 실행 조건, 기대 결과로 구성된 테스트 항목의 명세서
   테스트 슈트 (Test Suites)	- 테스트 케이스를 실행환경에 따라 구분해 놓은 테스트 케이스 집합 - 시나리오가 포함되지 않은 단순 테스트 케이스 모음
   테스트 시나리오 (Test Scenario)	- 테스트 되어야 할 기능 및 특징, 테스트 필요 상황 작성 문서 - 하나의 단일 테스트 시나리오가 하나/여러 케이스들 포함 가능 - 예 : Test Scenario 1. 로그인 > 상품검색 > 장바구니 담기 > 주문 >결제
   테스트 스크립트 (Test Script)	- 테스트 케이스의 실행 순서(절차) 작성 문서 - Test Step, Test Procedure라고도 함 - 예 : Test Procedure 1. 로그인, Test Procedure 2. 상품검색, Test Procedure 3. 장바구니 담기, ...
   테스트 결과서 (Test Results)	테스트 결과를 정리한 문서, 테스트 프로세스 리뷰, 테스트 결과 평가를 리포팅

2) 소프트웨어 테스트 유형 ⭐⭐

① 프로그램 실행 여부에 따른 분류

• 정적 테스트 : 테스트 대상 실행 X, 구조 분석
  • 리뷰, 정적 분석
• 동적 테스트 : 소프트웨어를 실행
  • 블랙박스 테스트(명세 기반 테스트)
  • 화이트박스 테스트(구조 기반 테스트)
  • 경험기반 테스트

② 테스트 기법에 따른 분류 ⭐

• 화이트박스 테스트 : 코드 분석, 프로그램 구조
  • 구분=문장(Statement Coverage)
  • 결정=선택(Decision Coverage)=분기 커버리지(Branch Coverage)
  • 조건(Condition Coverage)
  • 조건/결정(Condition/Decision Coverage)
  • 변경 조건/결정(Modified Condition/Decision Coverage)
  • 다중 조건(Multiple Condition Coverage)
  • 기본 경로=경로(Base Path Coverage)
  • 제어 흐름(Control Flow Coverage)
  • 데이터 흐름(Data Flow Coverage)
  • 루프(Loop Coverage)
• 블랙박스 테스트 : 요구사항 명세 수행
  • 동등분할=동치 분할, 균등 분할=동치 클래스 분해(Equivalence Partitioning Testing)
  • 경곗값 분석(Boundary Value Analysis Testing)
  • 결정 테이블(Decision Table Testing)
  • 상태 전이(State Transition Testing)
  • 유스케이스(Use Case Testing)
  • 분류 트리(Classification Tree Testing)
  • 페어와이즈(Pairwise Testing)
  • 원인-결과 그래프(Cause-Effect Testing)
  • 비교(Comparison Testing)
  • 오류 추정(Error Guessing Testing)

1. 화이트박스 테스트(White-Box Test)

   • 응용 프로그램의 내부 구조와 동작을 검사
   • 구조 기반 테스트, 코드 기반 테스트, 로직 기반 테스트, 글래스(Glass) 박스 테스트라고 불림

2. 블랙박스 테스트(Black-Box Test)

   • 기능 및 동작 위주의 테스트

   유형	설명
   동등분할= 동치 분할, 균등 분할= 동치 클래스 분해 (Equivalence Partitioning)	입력 데이터 영역을 유사한 도메인 별로 유효값/무효값 그룹핑, 대푯값 테스트 케이스 도출
   경곗값 분석 (Boundary Value Analysis)	경곗값 포함하여 테스트 케이스 설계
   결정 테이블 (Decision Table)	요구사항의 논리와 발생 조건을 테이블 형태로 나열, 조건과 행위를 모두 조합하여 테스트
   상태 전이 (State Transition)	테스트 대상, 시스템, 객체의 상태를 구분, 이벤트에 의해 상태가 전이되는 경우의 수 수행
   유스케이스 (Use Case)	유스케이스가 모델링 되어 있을 때 프로세스 흐름을 기반으로 테스트 케이스 명세화 수행
   분류 트리 (Classification Tree)	SW의 일부 또는 전체를 트리 구조로 분석 및 표현
   페어와이즈 (Pairwise)	테스트 데이터 값들을 최소 한 번씩 조합, 테스트 범위를 줄임
   원인-결과 그래프 (Cause-Effect)	그래프로 입력 데이터 간의 관계 및 출력에 미치는 영향 분석, 효용성 높은 테스트 케이스 선정
   비교 (Comparison)	여러 버전 프로그램에 같은 입력값을 넣어 동일한 결과가 나오는지 비교
   오류 추정 (Error Guessing)	개발자 실수 추정, 다른 블랙박스 테스트 기법 보완

③ 테스트 시작에 따른 분류

• 검증(Verification)
• 확인(Validation)

④ 테스트 목적에 따른 분류

• 회복(Recovery)
• 안전(Security)
• 성능(Performance)
  • 부하(Load) : 부하 증가, 시스템 임계점 찾고, 병목 현상 제거
  • 강도(Stress) : 처리 능력 이상 부하에서 시스템 동작 상태 확인
  • 스파이크(Spike) : 짧은 시간에 사용자가 몰릴 때 시스템의 반응 측정
  • 내구성(Endurance) : 오랜 시간 동안 높은 부하를 가하여 시스템 반응 확인
• 구조(Structure)
• 회귀(Regression)
• 병행(Parallel)

⑤ 테스트 종류에 따른 분류

• 명세 기반 테스트(블랙박스 테스트)
• 구조 기반 테스트(화이트박스 테스트)
• 경험 기반 테스트(블랙박스 테스트) : 유사 소프트웨어나 유사 기술 평가에서 테스터의 경험을 토대로 수행
  • 탐색적 테스트(Exploratory Test) : 문서 X, 휴리스틱한 능력, 구성요소(테스트 차터, 시간 제한, 노트, 회고)
  • 오류 추정(Error Geussing) : 개발자 실수 추정

3) 정적 테스트

① 리뷰(Review)

1. 동료 검토(Peer Review)

   • 2~3 명이 진행하는 리뷰 형태로, 요구사항 명세서 작성자가 요구사항 명세서를 설명하고, 이해관계자들이 설명을 들으면서 결함 발견

2. 인스펙션(Inspection)

   • 저작자 외의 다른 전문가 팀이 검사하여 문제 식별 및 해결
   • 개발 초기에 검사해야만 개발 초기 작업물에서 문제 발견
   • 관리자 직책 담당은 멤버 참여 금지

3. 워크 스루(Walk Throughts)

   • 검토 자료를 회의 전 배포하여 사전 검토 후, 짧은 시간 동안 회의 진행
   • 결함 검출 및 참가자 교육, 지식 공유
   • 작성자 본인이 회의를 주재하며, 관리자 직책 담당은 멤버 참여 금지

② 정적 분석(Static Analysis)

• 도구의 지원을 받음
• 자동화된 도구를 이용하여 산출물의 결함 검출, 복잡도 측정
• 코딩 표준 부합, 코드 복잡도 계산, 자료 흐름 분석

4) 테스트 오라클

• 테스트의 결과가 참인지 거짓인지 판단하기 위해 사전 정의된 참값을 입력하여 비교하는 기법

  유형	설명
  참(True) 오라클	모든 입력값에 대해 기대 결과를 생성, 발생된 오류 모두 검출
  샘플링(Sampling) 오라클	특정한 몇 개 입력값에 대해 기대하는 결과를 제공
  휴리스틱(Heuristic) 오라클	샘플링 오라클 개선, 특정 입력값에 올바른 결과 제공, 나머지 값은 휴리스틱(추정)으로 처리
  일관성 검사(Consistent) 오라클	APP 변경 시, 수행 전과 후 결괏값이 동일한지 확인

02. 애플리케이션 테스트 시나리오 작성 ⭐⭐

1) 테스트 레벨

① 테스트 레벨(Test Level)

• 함께 편성되고 관리되는 테스트 활동 그룹
• 프로젝트에서 책임과 연관
• 각각의 테스트 레벨은 서로 독립적

② 테스트 레벨 종류

• 단위 테스트
  • 정적 테스트
  • 동적 테스트
• 통합 테스트
  • 하향식 테스트
  • 상향식 테스트
  • 빅뱅 테스트
  • 샌드위치 테스트
• 시스템 테스트
  • 기능적 테스트
  • 비기능적 테스트
• 인수 테스트
  • 알파 테스트 : 사용자가 개발자 환경에서 함께 수행
  • 베타 테스트 : 실제 환경에서 사용자가 사용

[qwerty] [NCS학습모듈/지필] 애플리케이션 테스트 관리

2. 애플리케이션 통합 테스트

01. 애플리케이션 테스트 수행

1) 단위 테스트

① 단위 테스트(Unit Test)

• 개별적인 모듈(또는 컴포넌트) 테스트
• 구현 단계에서 각 모듈을 구현한 후 수행
• 개별적인 모듈에 대해 컴포넌트 테스트를 수행하려면 모듈을 단독으로 실행할 수 있는 테스트 배드 환경 필요

② 단위 테스트 수행 도구

• 테스트 드라이버(Test Driver)
  • 모듈 테스트 수행 후 결과를 도출하는 시험용 모듈
  • 필요 테스트를 인자로 넘겨주고, 테스트 완료 후 그 결괏값을 받는 역할을 하는 가상 모듈
  • 하위 모듈을 호출하는 상위 모듈
• 테스트 스텁(Test Stub)
  • 일시적으로 필요한 조건만 가지고 임시로 제공되는 시험용 모듈
  • 상위 모듈에 의해 호출되는 하위 모듈

2) 통합 테스트

① 통합 테스트(Integration Test)

• 소프트웨어 각 모듈 간의 인터페이스 관련 오류 및 결함을 찾아내기 위함
• 단위 테스트가 끝난 모듈 또는 컴포넌트 단위의 프로그램이 설계 단계에서 제시한 애플리케이션과 동일한 구조와 기능으로 구현된 것인지 확인

② 하향식 통합

• 메인 제어 모듈로부터 아래 방향으로 이동하면서 통합하면서 테스트 진행
• '깊이-우선' 또는 '너비-우선' 방식으로 통합

[해솔] 정보처리기사 실기 : 19강 애플리케이션 테스트 관리 (애플리케이션 통합 테스트하기)

③ 상향식 통합

• 최하위 레벨 모듈 또는 컴포넌트로부터 위쪽 방향으로 구축 및 테스트

[해솔] 정보처리기사 실기 : 19강 애플리케이션 테스트 관리 (애플리케이션 통합 테스트하기)

④ 샌드위치 통합

• 상향식 + 하향식 통합 테스트 결합
• 하위 프로젝트가 있는 큰 규모의 통합 테스트에서 사용
• 병렬 테스트 가능, 시간 절약, 기용 소모

⑤ 통합 테스트 수행 방법 간 비교

3) 테스트 자동화 도구

• 테스트 도구를 활용하여 반복적인 테스트 작업을 스크립트 형태로 구현함으로써, 테스트 시간 단축, 인력 투입 비용 최소화

① 정적 분석 도구(Static Analysis Tools)

• 만들어진 APP을 실행하지 않고 분석하는 도구
• 소스 코드에 대한 코딩 표준, 코딩 스타일, 코드 복잡도 및 남은 결함 발견을 위해 사용
• 테스트를 수행하는 사람이 작성된 소스 코드에 대한 이해를 바탕으로 도구를 이용하여 분석

② 테스트 실행 도구(Test Execution Tools)

• 테스트를 위해 작성된 스크립트 실행, 각 스크립트 마다 특정 데이터와 테스트 수행 방법 포함
• 데이터 주도 접근 방식 : 테스트 데이터
• 키워드 주도 접근 방식 : 테스트 수행 동작 키워드

③ 성능 테스트 도구(Performance Test Tools)

• APP의 처리량, 응답 시간, 경과 시간, 자원 사용률에 대해 가상의 사용자를 생성하고 테스트를 수행

④ 테스트 통제 도구(Test Control Tools)

• 테스트 계획 및 관리를 위한 테스트 관리 도구
• 테스트 수행에 필요한 데이터와 도구를 관리하는 형상 관리 도구
• 테스트에서 발생한 결함에 대해 관리하거나 협업을 지원하기 위한 결함 추적/관리 도구

⑤ 테스트 하네스

• APP 컴포넌트 및 모듈을 테스트하는 환경의 일부분, 테스트 지원 코드 및 데이터, 단위 또는 모듈 테스트에 사용하기 위해 코드 개발자가 작성

  구성요소	설명
  테스트 드라이버 (Test Driver)	테스트 대상 하위 모듈 호출, 파라미터 전달, 테스트 수행 후 결과 도출 등 상향식 테스트에 필요
  테스트 스텁 (Test Stub)	제어 모듈이 호출하는 타 모듈의 기능을 단순히 수행하는 도구로 하향식 테스트에 필요
  테스트 슈트 (Test Suites)	테스트 대상 컴포넌트나 모듈, 시스템에 사용되는 테스트 케이스 집합
  테스트 케이스 (Test Case)	입력값, 실행 조건, 기대 결과 등의 집합
  테스트 시나리오 (Test Scenario)	테스트 되어야 할 기능 및 특징, 테스트가 필요한 상황 작성 문서, 여러 개 테스트 케이스 포함 가능
  테스트 스크립트 (Test Script)	자동화된 테스트 실행 절차에 대한 명세
  목 오브젝트 (Mock Object)	사용자의 행위를 조건부로 사전에 입력해 두면, 그 상황에 예정된 행위를 수행하는 객체

01. 데이터 모델

1) 데이터 모델(Data Model)

• 현실 세계의 정보를 인간과 컴퓨터가 이해할 수 있도록 추상화하여 표현한 모델
• 데이터 모델 표시요소

2) 데이터 모델링 절차

① 개념적 설계(개념적 데이터 모델)

• 사용자의 요구에 대한 트랜잭션을 모델링
• 현실 세계에 대한 인식을 추상적, 개념적으로 표현하여 개념적 구조를 도출

  • 트랜잭션 모델링, View 통합방법 및 Attribute 합성 고려
  • 개념적 데이터 모델은 DB 종류와 관계 없음
  • 주요 산출물은 개체관계 다이어그램(ERD)이 있음

[MangKyu's Diary:티스토리] [Database] 6. 데이터 모델링(Data Modeling)

② 논리적 설계(논리적 데이터 모델)

• 트랜잭션의 인터페이스를 설계하는 단계
• DBMS에 맞는 논리적 스키마를 설계하는 단계
• 업무의 모습을 모델링 표기법으로 형상화하여 사람이 이해하기 쉽게 표현한 데이터 모델

  • 정규화 수행
  • 논리적 데이터베이스 구조로 매핑
  • 스키마의 평가 및 정제
  • 논리적 데이터 모델링 중 하나에 맞게 설계
  • 관계형 데이터베이스에서는 테이블을 설계하는 단계

[MangKyu's Diary:티스토리] [Database] 6. 데이터 모델링(Data Modeling)

③ 물리적 설계(물리적 데이터 모델)

• 논리 데이터 모델을 특정 DBMS의 특성 및 성능을 고려하여 물리적인 스키마를 만드는 단계
• 데이터베이스 저장 구조(물리 데이터 모델)로 변환

  • Table, Index, View, Partition 등 객체를 생성
  • 응답시간, 저장 공간의 효율화, 트랜잭션 처리를 고려하여 설계
  • 성능 측면에서 반 정규화를 수행
  • 레코드 집중의 분석 및 설계
  • 저장 레코드 양식 설계
  • 접근 경로(Access Path) 설계

[MangKyu's Diary:티스토리] [Database] 6. 데이터 모델링(Data Modeling)

02. 논리 데이터 모델 검증

1) 정규화(Normalization)

• 관계형 데이터 모델에서 데이터의 중복성을 제거하여 이상 현상을 방지하고, 데이터의 일관성과 정확성을 유지하기 위해 무손실 분해하는

① 이상현상(Anomaly) ⭐

• 데이터의 중복성으로 인해 릴레이션을 조작할 때 발생하는 비합리적 현상

[이상 현상 설명 테이블]

[삽입 이상]

[삭제 이상]

[갱신 이상]

→ '홍길동'의 지도교수가 '박교수'로 바뀌면 '김교수'의 정보가 사라짐

③ 함수 종속

• 릴레이션에서 속성의 의미와 속성 간 상호 관계로부터 발생하는 제약조건

1. 결정자/종속자

   • X → Y 관계일 때 X는 결정자(Determinant), Y는 종속자(Dependent)

2. 함수 종속 종류

   종류	설명
   부분 함수 종속 (Partial Functional Dependency)	릴레이션에서 기본 키가 복합 키일 경우 기본 키를 구성하는 속성 중 일부에게 종속
   완전 함수 종속 (Full Functional Dependency)	릴레이션에서 X → Y 관계가 있을 때, Y는 X의 전체 속성에 대해 종속하고, 부분 집합 속성에 종속하지 않는 경우
   이행 함수 종속 (Transitive Functional Dependency)	릴레이션에서 X → Y, Y → Z 종속 관계가 있을 때,** X → Z** 가 성립되는 경우

④ 정규화 단계

1. 1차 정규화(1NF)

   

   [MangKyu's Diary:티스토리] [Database] 정규화(Normalization) 쉽게 이해하기

   → 취미가 속성에 2개 이상 가지고 있는 경우 원자값이 아니기 때문에 속성 1개만 가지도록 저장

2. 2차 정규화(2NF)

   

   [MangKyu's Diary:티스토리] [Database] 정규화(Normalization) 쉽게 이해하기

   → <학생번호, 강좌이름>이 <성적>에 영향을 주고, <강좌이름>이 <강의실>에 영향을 주는 관계를 '부분함수 종속 관계' → 부분 관계인 <강좌이름, 강의실> 관계를 별도의 테이블로 둠

3. 3차 정규화(3NF)

   

   [MangKyu's Diary:티스토리] [Database] 정규화(Normalization) 쉽게 이해하기

   → <학생번호>가 <강좌이름>에 영향을 주고, <강좌이름>이 <수강료>에 영향을 주는 관계를 '이행함수 종속 관계' → <학생번호>는 <수강료>에 직접 영향을 주는 관계가 아니기에 <학생번호, 강좌이름> <강좌이름, 수강료> 테이블로 분리

4. 보이스-코드 정규화(BCNF)

   

   [MangKyu's Diary:티스토리] [Database] 정규화(Normalization) 쉽게 이해하기

   → <학생번호, 특강이름>이 <교수>에 영향을 주고, <교수>가 <특강이름>에 영향을 주는 관계로서, <교수>는 키가 아닌 상황이므로 결정자인 <교수>가 후보키가 아님 → <교수, 특강이름> 테이블로 분리하여 교수가 후보키 역할을 하도록 함

2) 반 정규화(De-Normalization)

• 정규화된 엔터티, 속성, 관계에 대해 성능 향상과 개발 운영의 단순화를 위해 중복, 통합, 분리 등을 수행
• 비정규화 역정규화라고도 불림
• 장점
  • 반 정규화된 데이터 구조는 성능 향상과 관리의 효율성 증가
• 단점
  • 데이터의 일관성 및 정합성 저하
  • 유지를 위한 비용이 별도로 발생하여 성능에 나쁜 영향

① 반 정규화 기법

• 테이블
  • 테이블 병합
  • 데이블 분할
  • 중복 테이블 추가
• 컬럼
  • 컬럼 중복화
• 관계
  • 중복관계 추가

01. 트랜잭션 ⭐⭐⭐

1) 트랜잭션

① 트랜잭션

• 인가받지 않은 사용자로부터 데이터를 보장하기 위해 DBMS가 가져야 하는 특성이자, 데이터베이스 시스템에서 하나의 논리적 기능을 정상적으로 수행하기 위한 작업의 기본 단위

② 트랜잭션의 특성 ⭐ ACID

③ 트랜잭션의 상태 변화

[모두의 SQL] 트랜잭션의 상태 변화와 트랜잭션 제어어

• 실행(active) : 트랜잭션이 실행 중
• 부분 완료(partially committed) : DML 등 트랜잭션의 마지막 명령을 실행한 후
• 완료(committed) : 트랜잭션이 성공적으로 완료
• 실패(failed) : 더 이상 정상적으로 실행될 수 없음을 발견
• 철회(aborted) : 트랜잭션이 복원되어 트랜잭션 수행 이전 상태로 돌아감

④ 트랜잭션 제어

• 트랜잭션 제어언어는 TCL(Transaction Control Language)이라고 하며, 트랜잭션의 결과를 허용하거나 취소하는 목적으로 사용되는 언어를 지칭

⑤ 병행 제어(일관성 주요 기법)

1. 병행 제어의 목적

   • 데이터베이스의 공유를 최대화
   • 시스템의 활용도를 최대화
   • 데이터베이스의 일관성 유지
   • 사용자에 대한 응답시간 회소화

2. 병행 제어 미보장 시 문제점

   • 갱신 손실(Lost Update) ** : 먼저 실행된 트랜잭션의 결과를 나중에 실행된 트랜잭션이 **덮어 쓸 때 발생하는 오류
   • 현황 파악오류(Dirty Read) ** : 트랜잭션의 **중간 수행 결과를 다른 트랜잭션이 참조하여 발생하는 오류
   • 모순성(Inconsistency) ** : 두 트랜잭션이 **동시에 실행되어 데이터베이스의 일관성이 결여되는 오류
   • 연쇄복귀(Cascading Rollback) ** : 복수의 트랜잭션이 데이터 공유 시 특정 트랜잭션이 처리를 취소할 경우 트랜잭션이 처리한 곳의 **부분을 취소하지 못하는 오류

3. 병행 제어 기법 종류

   기법	설명
   로킹 (Locking)	하나의 트랜잭션을 실행하는 동안 특정 데이터 항목에 대해서 다른 트랜잭션이 동시에 접근하지 못하도록 상호배제 기능을 제공하는 기법
   낙관적 검증 (Optimistic Validation)	트랜잭션이 어떠한 검증도 수행하지 않고 일단 트랜잭션을 수행하고, 트랜잭션 종료 시 검증을 수행하여 데이터베이스에 반영하는 기법
   타임 스탬프 순서 (Time Stamp Ordering)	트랜잭션과 트랜잭션이 읽거나 갱신한 데이터에 대해 트랜잭션이 실행을 시작하기 전에 타임 스탬프를 부여하여 부여된 시간에 따라 트랜잭션 작업을 수행하는 기법
   다중버전 동시성 제어 (MVCC; Multi Version Concurrency Control)	트랜잭션의 타임스탬프와 접근하려는 데이터의 타임스탭프를 비교하여 직렬가능성이 보장되는 적절한 버전을 선택하여 접근하도록 하는 기법
   #### ⑥ 데이터베이스 고립화 수준(격리성 주요 기법)

• 다른 트랜잭션이 현재의 데이터에 대한 무결성을 해치지 않기 위해 잠금을 설정하는 정도
  • Read Uncommitted : 한 트랜잭션에서 연산(갱신) 중인(아직 커밋되지 않은) 데이터를 다른 트랜잭션이 읽는 것을 허용, 연산은 불허
  • Read Committed : 한 트랜잭션에서 연산(갱신)을 수행할 때, 연산이 완료될 때까지 연산 대상 데이터에 대한 읽기를 제한, 연산이 완료되어 커밋된 데이터는 다른 트랜잭션이 읽는 것을 허용
  • Repeatable Read : 선행 트랜잭션이 특정 데이터를 읽을 때, 트랜잭션 종료 시까지 해당 데이터에 대한 갱신/삭제를 제한
  • Serializable Read : 선행 트랜잭션이 특정 데이터 영역을 순차적으로 읽을 때, 해당 데이터 영역 전체에 대한 접근을 제한

⑦ 회복 기법(영속성 주요 기법) ⭐

• 트랜잭션을 수행하는 도중 장애로 인해 속상된 데이터베이스를 손상되기 이전의 정상적인 상태로 복구시키는 작업

• REDO

  • 데이터베이스가 비정상적으로 종료되었을 때 디스크에 저장된 로그를 분석하여 트랜잭션의 시작과 완료에 대한 기록이 있는 트랜잭션들의 작업을 재작업하는 기법
  • 데이터베이스 내용 자체가 손상된 경우, 가장 최근의 복제본을 적재한 후 일어난 변경만을 로그를 이용하여 재실행함으로써 데이터베이스 복원

• UNDO

  • 데이터베이스가 비정상적으로 종료되었을 때 디스크에 저장된 로그를 분석하여 트랜잭션의 시작은 있지만, 완료에 대한 기록이 없는 트랜잭션들이 작업한 변경 내용들을 모두 취소하는 기법
  • 데이터베이스 내용 자체는 손상되지 않았지만, 변경 중이거나 변경된 내용에 대한 신뢰성을 잃어버린 경우, 모든 변경 내용을 취소하여 복원하는 기법

• 회복 기법 종류

  • 로그 기반 회복 기법
    • 지연 갱신 회복 기법(Deffered Update) : 트랜잭션이 완료되기 전까지 데이터베이스에 기록하지 않는 기법
    • 즉각 갱신 회복 기법(Immediate Update) : 트랜잭션 수행 중 갱신 결과를 바로 DB에 반영하는 기법
  • 체크 포인트 회복 기법(Checkpoint Recovery) : 장애 발생 시 검사점 이후에 처리된 트랜잭션에 대해서만 장애 발생 이전의 상태로 복원시키는 회복 기법
  • 그림자 페이징 회복 기법(Shadow Paging Recovery) : 데이터베이스 트랜잭션 수행 시 복제본을 생성하여 데이터베이스 장애 시 이를 이용해 복구하는 방법

출처 : https://artist-developer.tistory.com/39

2) DDL

① 데이터 정의어(DDL; Data Definition Language)

• 데이터를 담는 그릇을 정의하는 언어
• 테이블과 같은 데이터 구조를 정의

② DDL의 대상

1. 스키마(Schema)

   ⓐ 스키마의 구성

   계층	설명
   외부 스키마 (External Schema)	- 사용자나 개발자의 관점에서 필요로 하는 데이터베이스의 논리적 구조 - 사용자 뷰를 나타냄 - 서브 스키마로 불림
   개념 스키마 (Conceptual Schema)	- 데이터베이스의 전체적인 논리적 구조 - 전체적인 뷰를 나타냄 - 개체 간의 관계, 제약조건, 접근 권한, 무결성, 보안에 대해 정의
   내부 스키마 (Internal Schema)	- 물리적 저장 장치의 관점에서 보는 데이터베이스 구조 - 실제로 데이터베이스에 저장될 레코드의 형식을 정의하고 저장 데이터 항목의 표현 방법, 내부 레코드의 물리적 순서 등을 표현

   

   출처 : [정보통신용어사전] 데이터베이스 스키마, database schema

2. 테이블(Table)

   ⓐ 테이블의 개념

   • 테이블은 데이터를 저장하는 항목인 필드(Field)들로 구성된 데이터의 집합체
   • 하나의 DB 내에 여러 개의 테이블로 구성될 수 있고, 릴레이션(Relation) 혹은 엔터티(Entity)라고도 불림

   ⓑ 테이블의 용어

   

   출처 : [Inpa Dev] [DB] 📚 테이블 용어 🕵️ 정리

3. 뷰(View)

   ⓐ 뷰의 개념

   • 뷰는 논리 테이블로서 사용자에게(생성 관점 아닌 사용 관점에서) 테이블과 동일
   • 뷰와 같은 결과를 만들기 위해 조인 기능을 활용할 수 있으나, 뷰가 만들어져 있다면 사용자는 조인 없이 하나의 테이블을 대상으로 하는 단순한 질의어를 사용할 수 있음
   • 아래 그림에서 왼쪽 'Theater', 'Opera', 'Cinema'는 물리 테이블을 의미하고, 'Executed View'는 세 개의 테이블을 이용하여 생성한 뷰를 의미 출처 : [Learn Sql] What is an SQL View?

   ⓑ 뷰의 특징

   특징	설명
   논리적 데이터 독립성 제공	데이터베이스에 영향을 주지 않고 애플리케이션이 원하는 형태로 데이터에 접근 가능
   데이터 조작 연산 간소화	애플리케이션이 원하는 형태의 논리적 구조를 형성하여 데이터 조작 연산을 간소화 예) 회원 테이블에서 우수 회원을 뷰로 생성하여 활용
   보안 기능(접근제어) 제공	특정 필드만을 선택해 뷰를 생성할 경우 애플리케이션은 선택되지 않은 필드의 조회 및 접근 불가
   뷰 변경 불가	뷰 정의는 ALTER 문을 이용하여 변경할 수 없음 (뷰는 CREATE 문을 사용하여 정의, 뷰를 제거할 때에는 DROP 문을 사용)

   ⓒ 뷰의 목적

   • 뷰를 사용하는 주된 이유는 단순 질의어를 사용할 수 있기 때문
   • FROM 절에 있는 하나의 뷰를 통해 뷰를 구성하는 복수의 테이블을 대체하는 단순성에 의의
   • 장점
     • 논리적 독립성 제공
     • 사용자 데이터 관리 용이
     • 데이터 보안의 용이
   • 단점
     • 뷰 자체 인덱스 불가
     • 뷰 정의 변경 불가
     • 데이터 변경 제약 존재

4. 인덱스(Index)

   ⓐ 인덱스의 개념

   • 검색 연산의 최적화를 위해 데이터베이스 내 값에 대한 주소 정보로 구성된 데이터 구조
   • 인덱스는 데이터를 빠르게 찾을 수 있는 수단으로서, 테이블에 대한 조회 속도를 높여 주는 자료 구조
   • 테이블의 특정 레코드 위치를 알려주는 용도로 사용

   ⓑ 인덱스의 특징

   • 기본 키(PK; Primary Key) 컬럼은 자동으로 인덱스가 생성
   • 연월일이나 이름을 기준으로 하는 인덱스는 자동으로 생성되지 않음
   • 테이블의 컬럼에 인덱스가 없는 경우, 테이블의 전체 내용을 검색(테이블 전체 스캔; Table Full Scan)
   • 인덱스가 생성되어 있을 때 데이터를 빠르게 찾을 수 있음(인덱스 범위 스캔; Index Range Scan)
   • 조건절에 '='로 비교되는 컬럼을 대상으로 인덱스를 생성하면 검색 속도를 높일 수 있음

   ⓒ 인덱스의 종류

   유형	설명
   순서 인덱스 (Ordered Index)	- 데이터가 정렬된 순서로 생성되는 인덱스 - B-Tree 알고리즘 활용(오름차순/내림차순 지정가능)
   해시 인덱스 (Hash Index)	- 해시 함수에 의해 직접 데이터에 키 값으로 접근하는 인덱스 - 데이터 접근 비용이 균일, 튜플(Row) 양에 무관
   비트맵 인덱스 (Bitmap Index)	- 각 컬럼에 적은 개수 값이 저장된 경우 선택하는 인덱스 - 수정 변경이 적을 경우 유용(생년월일, 상품번호 등)
   함수기반 인덱스 (Functional Index)	- 수식이나 함수를 적용하여 만든 인덱스
   단일 인덱스 (Singled Index)	- 하나의 컬럼으로만 구성한 인덱스 - 주 사용 컬럼이 하나일 경우 사용
   결합 인덱스 (Concatenated Index)	- 두 개 이상의 컬럼으로 구성한 인덱스 - WHERE 조건으로 사용하는 빈도가 높은 경우 사용
   클러스터드 인덱스 (Clustered Index)	- 기본 키(PK) 기준으로 레코드를 묶어서 저장하는 인덱스 - 저장 데이터의 물리적 순서에 따라 인덱스가 생성 - 특정 범위 검색 시 유리함

③ DDL 명령어

④ TABLE 관련 DDL

1. CREATE TABLE ⓐ CREATE TABLE 기본문법

     CREATE TABLE 테이블명
     (
       컬럼명 데이터타입 [제약조건],
     ···
     );

   ⓑ CREATE TABLE 상세문법

     CREATE TABLE 테이블명
     (
       컬럼명 데이터타입 PRIMARY KEY, -- 기본키 설정,
       컬럼명 데이터타입 FOREIGN KEY REFERENCES 참조테이블(기본키), --외래키 설정 
       컬럼명 데이터타입 UNIQUE, 
       컬럼명 데이터타입 NOT NULL, 
       컬럼명 데이터타입 CHECH(조건식), --제약조건 설정 
       컬럼명 데이터타입 DEFAULT 값 
     );

   ⓒ CREATE TABLE 예시

     CREATE TABLE 사원
     (
       사번 VARCHAR(10) PRIMARY KEY,
       업무 VARCHAR(20) FOREIGN KEY REFERENCES 부서(부서코드),
       이름 VARCHAR(10) UNIQUE,
       생년월일 CHAR(8) NOT NULL, 
       성별 CHAR(1) CHECK (성별 = 'M' OR 성별 = 'F'),
       입사일 DATE DEFAULT SYSDATE -- SYSDATE는 현재시간/날짜
     );

   ⓓ CREATE TABLE 제약조건

   제약조건	설명
   PRIMARY KEY	- 테이블의 기본 키를 정의 - 유일하게 테이블의 각 행을 식별
   FOREIGN KEY	- 외래 키를 정의 - 참조 대상을 테이블(컬럼명)로 명시 - 열과 참조된 테이블의 열 사이의 외래 키 관계를 적용하고 설정
   UNIQUE	- 테이블 내에서 얻은 유일한 값을 갖도록 하는 제약조건
   NOT NULL	- 해당 컬럼은 NULL 값을 포함하지 않도록 하는 제약조건
   CHECK	- 개발자가 정의하는 제약조건 - 참이어야 하는 조건을 지정
   DEFAULT	- 데이터를 INSERT 할 때 해당 컬럼의 값을 넣지 않는 경우 기본값으로 설정해주는 제약조건

2. ALTER TABLE ⓐ ALTER TABLE 컬럼 추가

   • CREATE TABLE의 컬럼에 사용되는 제약조건 사용 가능

    ALTER TABLE 테이블명 ADD 컬럼명 데이터타입 [제약조건];

   • 예시

     ALTER TABLE 사원 ADD 전화번호 VARCHAR(11) UNIQUE;

     → 사원 테이블의 전화번호라는 컬럼에 대해 타입이 VARCHAR(11)이면서 UNIQUE 제약 조건을 걸도록 추가

   ⓑ ALTER TABLE 컬럼 수정

   • CREATE 문에 제약조건을 명시 후에 ALTER를 통해 테이블 제약조건 변경 가능

    ALTER TABLE 테이블명 MODIFY 컬럼명 데이터타입 [제약조건];

   • 예시

     ALTER TABLE 사원 MODIFY 이름 VARCHAR(30) NOT NULL;

     → 사원 테이블의 이름이라는 컬럼에 대해 타입이 VARCHAR(30)이면서 NOT NULL 제약 조건을 걸도록 수정

   ⓒ ALTER TABLE 컬럼 삭제

    ALTER TABLE 테이블명 DROP COLUMN 컬럼명;

   • 예시

     ALTER TABLE 사원 DROP COLUMN 생년월일;

     → 사원 테이블에 생년월일이라는 컬럼 삭제

3. DROP TABLE

    DROP TABLE 테이블명 [CASCADE | RESTRICT];

   • 예시

     DROP TABLE 사원;

     → 사원 테이블 삭제

   • CASCADE와 RESTRICT의 경우 외래 키(FOREIGN KEY)가 걸려 있을 때 해당

     옵션	설명
     CASCADE	참조하는 테이블까지 연쇄적으로 제거하는 옵션
     RESTRICT	다른 테이블이 삭제할 테이블을 참조 중이면 제거하지 않는 옵션

4. TRUNCATE TABLE

    TRUNCATE TABLE 테이블명;

   • 예시

     TRUNCATE TABLE 사원;

     → 사원 테이블 내의 모든 데이터를 삭제

⑤ VIEW 관련 DDL

1. CREATE VIEW

    CREATE VIEW 뷰이름 AS
    조회쿼리;

   • 예시

     CREATE VIEW 사원뷰 AS
     SELECT 사번, 이름
     FROM 사원
     WHERE 성별 = 'M';

     → 사원 테이블에서 성별 값이 'M'을 가진 사번, 이름으로 생성된 사원뷰라는 이름의 뷰 생성
     • VIEW 테이블의 SELECT 문에는 UNION 이나 ORDER BY 절을 사용할 수 없음
     • UNION : 집합연산자로 중복 행이 제거된 쿼리 결과 집합
     • ORDER BY : 속성값을 정렬하고자 할 때 사용
     • 컬럼명을 기술하지 않으면 SELECT 문의 컬럼명이 자동으로 사용

2. CREATE OR REPLACE VIEW

   • 뷰를 교체

    CREATE OR REPLACE VIEW 뷰이름 AS
    조회쿼리;

3. DROP VIEW

   • 뷰를 삭제

     DROP VIEW 뷰이름;

⑥ INDEX 관련 DDL

1. CREATE INDEX

   • UNIQUE 는 생략 가능하고, 인덱스 걸린 컬럼에 중복 값을 허용하지 않음
   • 복수 컬럼을 인덱스로 걸 수 있음

    CREATE [UNIQUE] INDEX 인덱스명 ON 테이블명(컬럼명1, 컬럼명2);

   • 예시

     CREATE INDEX 사번인덱스 ON 사원(사번);

     → 사원 테이블의 사번 컬럼에 대해 사번인덱스라는 인덱스 명으로 인덱스 생성

2. ALTER INDEX

   • 일부 DBMS는 ALTER INDEX를 제공하지 않음
   • 기존 인덱스를 삭제하고 신규 인덱스를 생성하는 방식으로 사용 권고

    ALTER [UNIQUE] INDEX 인덱스명 ON 테이블명(컬럼명1, 컬럼명2);

   • 예시

     ALTER INDEX 사번인덱스 ON 사원(사번);

     → 사원 테이블의 사번 컬럼에 대해 사번인덱스라는 인덱스 명으로 인덱스 수정

3. DROP INDEX

    DROP INDEX 인덱스명;

3) DML ⭐⭐⭐

① 데이터 조작어(DML; Data Manipulation Language)

• 데이터베이스에 저장된 자료들을 입력, 수정, 삭제, 조회하는 언어

② DML 명령어

③ SELECT

1. SELECT 명령어

   • 속성명 별칭은 AS를 사용
   • DISTINCT : 중복된 속성 중 하나만
   • HAVING : GROUP BY에 의해 분류한 후 그룹에 대한 조건 지정

     SELECT [ALL | DISTICT] 속성명1, 속성명2, ...
     FROM 테이블명1, ...
     [WHERE 조건]
     [GROUP BY 속성명 1, ...]
     [HAVING 그룹조건]
     [ORDER BY 속성 [ASC | DESC] ];

   ⓐ SELECT 절

   [성적 테이블]

   이름	과목	학점
   김철수	C언어	A
   한유리	자료구조	A
   신짱구	자료구조	A
   이훈이	알고리즘	B

   SELECT DISTINCT 과목
   FROM 성적
   WHERE 학점 = 'A'

   과목
   C언어
   자료구조

 SELECT COUNT(DISTINCT 과목)
   FROM 성적;

ⓑ WHERE 절

• 비교

  • = : 값이 같은 경우 조회
  • <>, != : 값이 다른 경우 조회
  • <, <=, >, >= : 비교 연산에 해당하는 데이터 조회

• 범위

  SELECT *
    FROM PRODUCT
   WHERE PRICE BETWEEN 50000 AND 80000;
  -- = WHERE PRICE >=50000 AND PRICE <= 80000; 

• 집합

  • IN, NOT IN

    SELECT *
    FROM PRODUCT
    WHERE PRICE IN (40000, 50000, 80000);

• 패턴

  • % : 0개 이상의 문자열과 일치
  • [ ] : 1개 문자와 일치
  • [^] : 1개 문자와 불일치
  • _ : 특정 위치의 1개의 문자와 일치

    SELECT *
    FROM PRODUCT
    WHERE PRICE IN (40000, 50000, 80000);

• NULL

  • IS NULL, IS NOT NULL

    SELECT *
    FROM PRODUCT
    WHERE PRICE IS NULL;

• 복합조건

  • AND, OR, NOT

  ⓒ GROUP BY

  [급여 테이블]

  이름	직책	부서	급여
  김철수	차장	마케팅	5000
  한유리	차장	전산	4800
  신짱구	사원	마케팅	2500
  이훈이	사원	마케팅	2700

  SELECT 직책, 부서, SUM(급여) AS 급여합계
  FROM 급요
  GROUP BY 직책, 부서

  직책	부서	급여합계
  차장	마케팅	5000
  차장	전산	4800
  사원	마케팅	5200

 SELECT COUNT(*)
   FROM 급여;

ⓓ HAVING 절

 SELECT 직책, 부서, SUM(급여) AS 급여합계
   FROM 급요
  GROUP BY 직책, 부서
 HAVING 급여합계 >= 5000;

2. JOIN

   • 두 개 이상의 테이블을 결합하여 하나의 튜플로 만드는 연결 방법
   • 조인 예시 [도서]&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp[도서가격]

   책번호	책명		책번호	가격
   111	운영체제		111	20000
   222	자료구조		222	25000
   555	컴퓨터구조		333	10000
   			444	15000

   ⓐ 내부 조인(Inner Join) : 공통 존재 컬럼의 값이 같은 경우 추출

   SELECT A.컬럼1, A.컬럼2, ...,
        B.컬럼1, B.컬럼2, ...
   FROM 테이블1 A [INNER] JOIN 테이블2 B
     ON 조인조건
   [WHERE 검색조건];

   SELECT A.책번호, A.책명, B.가격
   FROM 도서 A JOIN 도서가격 B
     ON A.책번호 = B.책번호

   책번호	책명	가격
   111	운영체제	20000
   222	자료구조	25000

   ⓑ 외부 조인(Outer Join) 1) 왼쪽 외부 조인 : 왼쪽 테이블의 모든 데이터와 오른쪽 테이블의 동일 데이터 추출

   SELECT A.컬럼1, A.컬럼2, ...,
         B.컬럼1, B.컬럼2, ...
   FROM 테이블1 A LEFT [OUTER] JOIN 테이블2 B
     ON 조인조건
   [WHERE 검색조건];

   SELECT A.책번호, A.책명, B.책번호, B.가격
   FROM 도서 A LEFT JOIN 도서가격 B
     ON A.책번호 = B.책번호;

   책번호	책명	책번호	가격
   111	운영체제	111	20000
   222	자료구조	222	25000
   555	컴퓨터구조	NULL	NULL

   2) 오른쪽 외부 조인 : 오른쪽 테이블의 모든 데이터와 왼쪽 테이블의 동일 데이터 추출

   SELECT A.컬럼1, A.컬럼2, ...,
         B.컬럼1, B.컬럼2, ...
   FROM 테이블1 A RIGHT [OUTER] JOIN 테이블2 B
     ON 조인조건
   [WHERE 검색조건];

   SELECT A.책번호, A.책명, B.책번호, B.가격
   FROM 도서 A RIGHT JOIN 도서가격 B
     ON A.책번호 = B.책번호;

   책번호	책명	책번호	가격
   111	운영체제	111	20000
   222	자료구조	222	25000
   NULL	NULL	333	10000
   NULL	NULL	444	15000

3) 완전 외부 조인 : 양쪽의 모든 데이터를 추출

 SELECT A.컬럼1, A.컬럼2, ...,
         B.컬럼1, B.컬럼2, ...
   FROM 테이블1 A FULL [OUTER] JOIN 테이블2 B
     ON 조인조건
 [WHERE 검색조건];

 SELECT A.책번호, A.책명, B.책번호, B.가격
   FROM 도서 A FULL JOIN 도서가격 B
     ON A.책번호 = B.책번호;

ⓒ 교차 조인(Cross Join) : 조인 조건이 없는 모든 데이터 조합을 추출 ⭐

 SELECT 컬럼1, 컬럼2, ...,
   FROM 테이블1 A CROSS JOIN 테이블2 B

 SELECT A.책번호, A.책명, B.책번호, B.가격
   FROM 도서 A CROSS JOIN 도서가격 B;

ⓓ 셀프 조인(Self Join) : 자기 자신에게 별칭을 지정한 후 다시 조인

 SELECT A.컬럼1, A.컬럼2, ...,
         B.컬럼1, B.컬럼2, ...
   FROM 테이블1 A [INNER] JOIN 테이블1 B
     ON 조인조건
 [WHERE 검색조건];

[도서]

 SELECT A.책번호, A.책명, B.책번호, B.책명
   FROM 도서 A FULL JOIN 도서 B
     ON A.선수과목_책번호 = B.책번호;

3. 서브쿼리(Sub-query)

   • SQL 문 안에 포함된 또 다른 SQL 문
   • 용도는 알려지지 않은 기준을 위한 검색을 위해 사용
   • 메인쿼리와 서브쿼리는 주종 관계로서, 서브쿼리에 사용되는 컬럼 정보는 메인 쿼리의 컬럼 정보를 사용할 수 있으나, 역으로는 성립 X

   ⓐ FROM 절 서브쿼리

   • 서브쿼리가 FROM 절 안에 들어있는 형태
   • 인라인 뷰라고 불림
   • 뷰처럼 결과가 동적으로 생성된 테이블 형태로 사용 가능

   SELECT MAX(가격) AS 가격
   FROM 도서가격 A, 
          (SELECT 책번호
             FROM 도서
            WHERE 책명='자료구조') B
   WHERE A.책번호 = B.책번호;

   가격
   25000

   ⓑ WHERE 절 서브쿼리

   • 서브쿼리가 WHERE 절 안에 들어있는 형태
   • 중첩 서브쿼리(Nested Sub-Query)라도고 불림

   SELECT MAX(가격) AS 가격
   FROM 도서가격 A, 
   WHERE 책번호 IN (SELECT 책번호
                    FROM 도서
                   WHERE 책명='자료구조');

   가격
   25000

④ INSERT(데이터 삽입)

• 속성과 데이터 개수, 데이터 타입이 일치해야 함
• 속성명은 생략 가능
• 속성의 타입이 숫자인 경우 따옴표를 붙이지 않아도 되며, 문자열인 경우 붙여야 함

  INSERT INTO 테이블명(속성명1, ...)
  VALUES (데이터1, ...);

• 예시

  INSERT INTO 학생(학번, 성명, 학년, 수강과목)
  VALUES (6677, '장길산', 3, '수학');

⑤ UPDATE(데이터 갱신)

• WHERE 절을 통해 어떤 조건이 만족할 경우에만 특정 컬럼의 값을 수정하는 용도로 자주 사용됨

  UPDATE 테이블명
     SET 속성명 = 데이터, ...
   WHERE 조건;

• 예시

  UPDATE 학생
     SET 주소='인천'
   WHERE 이름='장길산';

⑥ DELETE(데이터 삭제)

• 모든 레코드를 삭제할 때는 WHERE 절 없이 DELETE만 사용
• ⭐ 레코드를 삭제해도 테이블 구조는 남아 있어서 디스크에서 테이블을 완전히 삭제하는 DROP 명령과는 다름

  DELETE FROM 테이블명
   WHERE 조건;

• 예시

  DELETE FROM 학생
   WHERE 이름='장길산';

4) DCL

① 데이터 제어어(DCL; Data Control Language)

• 데이터베이스 관리자가 데이터 보안, 무결성 유지, 병행 제어, 회복을 위해 관리자(DBA)가 사용하는 제어용 언어

1. GRANT(권한 부여) 명령어

   • 데이터베이스 관리자(DBA; Database Administrator)가 사용자에게 데이터베이스에 대한 권한을 부여하는 명령어

    GRANT 권한 ON 테이블 TO 사용자;

   • 예시

     GRANT UPDATE ON 학생 TO 장길산;

     → 관리자가 사용자 장길산에게 '학생' 테이블에 대해 UPDATE 할 수 있는 권한 부여

2. REVOKE(권한 회수) 명령어

   • 데이터베이스 관리자(DBA)가 사용자에게 부여했던 권한을 회수하기 위한 명령어

    REVOKE 권한 ON 테이블 FROM 사용자;

   • 예시

     REVOKE UPDATE ON 학생 FROM 장길산;

     → 관리자가 사용자 장길산에게 '학생' 테이블에 대해 UPDATE 할 수 있는 권한 회수

01. 파이썬 기본 구조

• 파이썬은 사용자 정의 함수, 클래스가 먼저 정의되고, 그 다음에 실행 코드
• 가독성을 위해 들여쓰기를 함

def fn(num):
  if num % 2 == 0:
    return 'Y'

class A:
  def fn(self):
    print('A')

print('Hello') # Hello

02. 자료형 ⭐⭐⭐

1) 자료형 유형

2) 컬렉션 자료형(Collection Data Type)

• 시퀀스 자료형(순서 O)

• 비시퀀스 자료형(순서 X)

① 시퀀스 자료형 구조

1. 시퀀스 자료형 종류

   ⓐ 문자열형(String) ⭐

   print("Hello")
   print("Hello", "World") # Hello World ← (,)로 구분되면 띄어쓰기
   print("\"Hello\"") # "Hello"
   print("Hello"*3) # HelloHelloHello

   • 파이썬 문자열은 포맷스트링을 이용하여 문자열을 출력할 수 있음

     a = "Hello"
     print("%s" % a) # Hello
     b = "%s" % " world"
     print(a+b) # Hello world
     c = 123
     print("%s %d" % (a, c)) # Hello 123 

     → 컬렉션 자료형 변수를 그냥 출력했을 때는 괄호 표시 O, 문자열 변수를 출력했을 때는 괄호 표시 X

   • 문자열에서 in 연산자를 이용하여 찾고자 하는 문자열이 존재하면 True, 없으면 False

   • 문자열 관련 함수

     함수	설명
     upper()	문자열을 대문자로 변환
     lower()	문자열을 소문자로 변환
     isalnum()	문자열이 알파벳 또는 숫자로만 구성되어 있는지
     isalpha()	문자열이 알파벳으로만 구성되어 있는지
     isdecimal()	문자열이 정수인지
     isdigit()	문자열이 숫자인지
     isspace()	문자열이 공백으로만 구성되어 있는지
     split()	문자열을 매개변수로 전달된 문자(구분자)로 나누어 리스트로 변환

     str = "1,2,3".split(",")
     print(str) # ['1', '2', '3']

   ⓑ 리스트형(list) ⭐⭐

   • [,] 를 이용하여 리스트형 선언

     • 리스트명=[요소1, 요소2, ···]

   • 리스트형 메서드

     메서드	설명
     append(x)	리스트 마지막 요소 뒤에 값 x를 추가
     clear()	리스트의 모든 항목을 삭제
     copy()	리스트를 복사
     count(x)	리스트에서 x 항목의 개수를 알려줌
     extend(i)	리스트 마지막에 컬렉션 자료형 i를 추가
     index(x)	값 x와 같은 값을 가지고 있는 인덱스 번호를 알려줌
     insert(i, x)	리스트의 i 번지 위치에 값 x를 삽입
     pop()	마지막 항목을 삭제하고 값을 꺼내옴
     remove(x)	리스트에서 해당하는 값(중복이면 가장 앞) x를 제거
     reverse()	리스트의 위치를 전부 역순으로 바꿔줌
     sort()	리스트의 항목들을 정렬

   • 리스트를 2차원으로 만들 수 있음

     a = [[1, 2], [3, 4], [5, 6]]
     print(a) # [[1, 2], [3, 4], [5, 6]]
     print(a[0]) # [1, 2]
     print(a[1][0]) # 3
     b = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
     print(b[0]) # [1, 2, 3]

   ⓒ 튜플형

   • (,) 를 이용하여 리스트형 선언

     • 튜플명=(요소1, 요소2, ···)

     t = ('s', 'j', 'b')
     print(t) # ('s', 'j', 'b')

2. 시퀀스 자료형 요소 접근 방벙 - 인덱싱(Indexing)

   • 시퀀스 자료형은 여러 값으로 이루어져 있는데 인덱스를 이용해서 중간값에 접근할 수 있음

     첫 번째 요소	두 번째 요소	···	뒤에서 두 번째 요소	뒤에서 첫 번째 요소
     0	1	···	(n-2)	(n-1)
     -n	-(n-1)	···	-2	-1

     • 인덱싱은 문자열, 리스트 같은 자료구조에서 사용
     • 문자열 인덱싱은 문자열에 부여된 번호로 원하는 문자를 가리킬 때 사용
     • 문자열 앞에서부터 시작하면 인덱스는 0부터 시작하고, 뒤에서부터 시작하면 -1 부터 시작
     • 인덱싱으로 접근하면 출력 결과에 괄호가 없음

3. 시퀀스 자료형 요소 접근 방벙 - 슬라이싱(Slicing)

   • 슬라이싱은 시퀀스 자료형에서 여러 개의 데이터에 동시에 접근하는 기법

   • 시퀀스변수명[시작 : 종료 : 스텝]

     형태	설명
     시작	- 슬라이싱을 시작할 인덱스 - 생략할 경우 '시퀀스변수명[ : 종료]' 또는 '시퀀스변수명[ : 종료 : 스텝]' 형태가 됨 - 생략할 경우 처음부터 슬라이싱
     종료	- 슬라이싱을 종료할 인덱스 - 종료 인덱스에 있는 인덱스 전까지만 슬라이싱 - 생략할 경우 '시퀀스변수명[ 시작 : ]' 또는 '시퀀스변수명[ 시작 : : 스텝]' 형태가 됨 - 생략할 경우 마지막까지 슬라이싱
     스텝	- 몇 개씩 끊어서 슬라이싱을 할지 결정하는 값 - 생략할 경우 '시퀀스변수명[ 시작 : 종료 ]' 또는 '시퀀스변수명[ 시작 : 종료 : ]' 형태가 됨 - 생략할 경우 1이 기본값

   ⓐ 문자열 슬라이싱

    print("Information"[1:]) # nformation
    print("Information"[2:4]) # fo
    print("Information"[:3]) # inf

   → 문자열 슬라이싱을 제외한 다은 시퀀스 자료형은 출력 결과에 괄호가 표시됨

   ⓑ 리스트 슬라이싱

    a = [4, 2, 7, 3, 5]
    print(a[0 : 4 : 2] # [4, 7]

   ⓒ 튜플 슬라이싱

    t = ('s', 'j', 'b')
    print(t[1:]) # ('j', 'b')

② 비시퀀스 자료형 구조

1. 세트형 ⓐ 세트(Set)형 개념

   • 중복된 원소를 허용하지 않는 자료형으로 순서가 중요하지 않음
   • set라는 키워드로 세트형을 초기화하거나 {, }를 이용하여 선언

     세트명 = set([요소1, 요소2, ···])
     세트명 = {요소1, 요소2, ···}

   ⓑ 세트형 메서드

   메서드	설명
   add(값)	값을 1개 추가
   update([값1, 값2, ···])	여러 개의 값을 한꺼번에 추가
   remove(값)	특정 값을 제거하는 메서드

2. 딕셔너리(Dictionary) ⓐ 딕셔너리형 개념

   • 키와 값으로 구성된 객체를 저장하는 구조

   ⓑ 딕셔너리형 요소 생성

   • 딕셔너리명={키1:값1, 키2:값2, ···}
   • {, } 안에 콜론(:)을 이용하여 키와 값을 구분하여 선언

   ⓒ 딕셔너리형 요소 변경

   • 딕셔너리명[키]=값
   • 기존 변수에 키와 값을 추가
   • 기존 변수에 해당 키에 해당하는 값이 있었으면 값을 변경

   ⓓ 딕셔너리형 요소 삭제

   • 기존 변수에서 해당 키와 키에 해당하는 값을 삭제
   • del 딕셔너리명[키]

③

3) 자료형 함수

① type 함수

• 자료형을 확인하는 함수

• 기본 자료형(Primitive Data Type)

  세부 유형	출력
  정수형(Integer)	<class 'int'>
  실수형(Floating Point)	<class 'float'>
  논리형(Logical)	<class 'bool'>

• 컬렉션 자료형(Collction Data Type)

  세부 유형	출력
  문자열형(String)	<class 'str'>
  리스트형(List)	<class 'list'>
  튜플형(Tuple)	<class 'tuple'>
  딕셔너리형(Dictionary)	<class 'dict'>
  세트형(Set)	<class 'set'>

② len 함수

• 컬렉션 자료형의 크기를 계산하는 함수

03. 입출력 ⭐

1) 표준 출력 함수(print)

① 단순 출력 및 개행

• print(문자열) : 출력 후에 개행
• print(문자열, end='') : 출력 후에 개행을 하지 않음

② 변수 출력

• print(변수명)

2) 표준 입력 함수(input)

• 파이썬에서는 정수형이나 실수형과 같은 숫자를 입력받을 때는 문자열로 저장한 후에 eval 함수를 써서 숫자를 변환해 주어야 함
  • 문자열 입력 : 변수명 = input()
  • 숫자 입력 : 변수명 = eval(변수명)

  s = input() # 1
  s = eval(s)
  print(s) # 1

04. 연산자 ⭐⭐

• 프로그램 실행을 위해 연산을 표현하는 기호

1) 연산자 종류

① Swap 연산자

• 두 변수의 값을 교환하는 연산자
• 콤마를 기준으로 두 값을 교환

a, b = 10, 20
print(a) # 10
print(b) # 20
a, b = b, a
print(a) # 20
print(b) # 10

→ 파이썬 연산자는 C언어와 거의 동일하지만 ++, --는 지원하지 않음

② 산술 연산자

• 두 수의 수치 계산을 위한 연산자
• 사칙 연산(+, -, , /, //), 지수 연산(*), 나머지 연산(%)

print(3 / 2) # 1.5
print(3 // 2) # 1 ← 몫 계산
print(3 ** 2) # 9
print(3 % 2) # 1

③ 대입 연산자

• 변수에 값을 할당하는 연산자
• '+=', '-=', '=', '/=' 은 C나 Java와 동일하며, 파이썬에는 추가적으로 '*=', '//=' 연산자 제공

05. 조건문과 반복문

• 파이썬에서는 switch 문이 없음
• 파이썬에서는 do-while 문이 없음

1) for 문

• in 연산다 뒤에 range 함수를 사용하여 반복의 범위를 지정하거나 리스트 개수만큼 반복을 수행

① 일반 for 문

• range 함수는 범위를 지정하는 함수
• range 함수에서 시작을 생략하면 0, 스텝 값을 생략하면 1이 자동으로 들어감

for 변수 in range(시작, 종료, 스텝) : 
  명령문

② for each 문

• 시퀀스 자료형의 요소들을 차례대로 변수에 대입하면서 반복하는 명령어

for 변수 in 시퀀스자료형 : 
  명령문

• 파이썬 for each 문

  li = [1, 2, 3, 4, 5]
  for a in li : 
  print(a) # 1\n2\n3\n4\n5\n

• 파이썬 이중 for each 문

  li = [[1, 2], [3, 4, 5]]
  for a in li : 
  for b in a :
    print(b, end='') # 12345

06. 함수 ⭐⭐

1) 사용자 정의 함수

① 사용자 정의 함수(User-Defined Function)

• 사용자가 직접 새로운 함수를 정의하여 사용하는 방법
• 사용자 정의 함수에서 매개변수나 생성된 변수는 사용자 정의 함수가 종료되면 없어짐

def 함수명(변수명, ···) :
  명령어
  return 반환값

② 디폴트 매개변수

• 기본값이 정의된 매개변수
• 함수를 호출할 때, 매개변수가 명시외더 있지 않으면 디폴트 매개변수 값이 전달

def 함수명(매개변수=디폴트값) :
  명령문

2) 람다 함수

① 람다 함수

• 함수 이름 없이 동작하는 함수
• 매개변수에 값을 전달하면 표현식에서 연순을 수행

② 람다 함수 문법

1. 일반 람다 함수

   lambda 매개변수 : 표현식

• 일반 사용자 정의 함수는 def 키워드와 return 키워드를 사용하여 함수를 구현

(lambda n, m : n + m)(2, 3) # 5 (왜 출력이 되는거지?)

2. 변수를 이용한 람다 함수

• 람다 함수를 변수에 할당하여 재사용할 수 있음

sum = lambda n, m : n + m
print(sum(2, 3)) # 5

3. 사용자 정의 함수를 이용한 람다 함수

• 람다 함수는 사용자 정의 함수로 구현할 수 있음

def f(n) :
  return lambda a:a*m
k = f(3)
print(k(10)) # 30

4. 내장 함수를 이용한 람다 함수 ⭐

• 람다 함수는 파이썬 map 함수, filter 함수와 같이 사용 가능

  함수	형태	설명
  map	map(함수, 리스트)	- 첫 번째 매개변수에는 함수, 두 번째 매개변수에는 리스트를 전달 - 리스트 요소를 함수에 전달하여 반복을 수행하는 함수
  filter	filter(함수, 리스트)	- 첫 번째 매개변수에는 함수, 두 번째 매개변수에는 리스트를 전달 - 리스트 요소를 함수에 전달하여 조건이 참인 값을 리턴하는 함수

• 파이썬 map을 이용한 람다 함수

a = [1, 2, 3, 4, 5]
m = list(map(lambda num : num + 100, a))
print(m) # [101, 102, 103, 104, 105]

• 파이썬 filter를 이용한 람다 함수

a = [1, 2, 3, 4, 5]
m = list(filter(lambda num : num > 2, a))
print(m) # [3, 4, 5]

07. 예외 처리 ⭐

1) 예외 처리

① 예외 처리

• 작성한 코드가 실행하는 도중에 발생되는 에러를 처리하는 구문
• try, except, finally를 이용하여 예외 처리

try :
  명령문
except :
  예외 발생시 동작할 명령문

→ except 다음에 예외가 발생하는 경우 동작할 코드 작성

try :
  명령문
except 발생예외명:
  예외 발생시 동작할 명령문
finally : 
  명령문

→ except에서 특정 예외만 처리하기 위함 → finally는 try가 실행되고 마지막에 반드시 실행될 명령문

try :
  명령문
except 발생예외명1:
  예외 발생시 동작할 명령문1
except 발생예외명2:
  예외 발생시 동작할 명령문2
else : 
  명령문

→ else는 예외가 발생되지 않았을 경우에 실행될 명령문

a, b = 2, 0
try :
  print(a/b)
except IndexError as e :
  print('[exception]', e)
except ZeroDivisionError as e :
  print('[exception]', e) # [exception] division by zero

② raise

• 프로그램이 의도하지 안헤 동작하는 것을 방지하기 위해 의도적으로 예외를 발생시키는 명령
• try except 구분 안에서도 사용 가능

명령문
raise

명령문
raise 예외처리명

명령문
raise 예외처리명("메시지")

a, b = 2, 0
try :
  print(a/b)
  raise
except ZeroDivisionError as e :
  print('에러') # 에러

08. 클래스

1) 클래스

• 객체 지향 프로그래밍(OOP; Object-Oriented Programming)에서 특정 객체를 생성하기 위해 변수와 메서드를 정의하는 틀

2) 클래스 정의

• 클래스에서 변수는 변수 선언과 동일, 메서드는 사용자 정의 함수와 문법 동일

class 클래스명:
  def 메서드명(self, 변수명, ···):
    명령어
    return 반환값

• 파이썬에서는 함수명에 입력받을 값(매개변수) 앞에 self라는 키워드를 적어야 함

class Test:
  def fn(self):
    print(5)

3) self

• self는 현재 객체를 가리키는 키워드
• 클래스 내부의 변수와 함수를 가리킬 수 있음

self.변수명
self.함수명(매개변수)

class Test:
  def setS(self, a):
    self.a = a
  def getS(self):
    return self.a 
a = Test()
a.setS(5)
print(a.getS()) # 5

4) 생성자(Constructor) ⭐

• 해당 클래스의 객체가 생성될 때 자동으로 호출되는 특수한 종류의 메서드

• 생성자는 __init__이라는 메서드 명을 사용하고, 첫 번째 매개변수로 self를 작성하며, 반환 값이 없음

• 생성자 정의

  class 클래스명:
  def __init__(self, 매개변수): 
    명령어

• 생성자 호출 : 클래스변수=클래스(매개변수)

5) 소멸자(Destructor)

• 객체의 수명이 끝났을 때 객체를 제거하기 위한 목적으로 사용되는 메서드

• 소멸자는 __del__이라는 메서드명을 사용하고, 첫 번째 매개변수에 self를 작성하며, 반환 값이 없음

• 소멸자 정의

  class 클래스명:
  def __del__(self): 
    명령어

• 소멸자 호출 : del 클래스변수

class Test:
  def __init__(self):
    print("생성자")
  def __del__(self):
    print("소멸자")
  def fn(self):
    print("일반함수")

t = Test() # 생성자
t.fn() # 일반함수
del t # 소멸자

6) 클래스 접근 제어자

• 파이썬은 private, public 등의 접근 제어자 키워드가 존재하지 않고 작명법(Naming)으로 접근 제어를 해야 함

09. 클래스 상속

1) 클래스 상속(Inheritance)

• 상속은 어떤 객체가 있을 때 그 객체의 변수와 메서드를 다른 객체가 물려받는 기능

class 부모_클래스명:
···
class 자식_클래스명(부모_클래스명):
···

2) 메서드 오버라이딩(Overriding)

• 오버라이딩은 하위 클래스에서 상위 클래스 메서드를 재정의할 수 있는 기능
  • 오버라이드하고자 하는 메서드가 상위 클래스에 존재하여야 함
  • 메서드 이름은 같아야 함
  • 메서드 매개변수 개수, 데이터 타입이 같아야 함

class 부모_클래스명:
  def 메서드명(self, 변수명) :
    명령어
class 자식_클래스명(부모_클래스명):
  def 메서드명(self, 변수명) : # 부모 클래스와 메서드명, 매개변수가 같아야 함
    명령어

class A:
  def fn(self) :
    print('A')
class B(A):
  def fn(self) :
    print('B')
a = B()
a.fn() # B

3) 부모 클래스 접근

• 파이썬은 super 키워드를 이용하여 상위 클래스의 변수나 메서드에 접근할 수 있음

  super().메서드명()

class A:
  def fn(self) :
    print('A')
class B(A):
  def fn(self) :
    super().fn()
    print('B')
a = B()
a.fn() # A\nB\n

3. 자바

01. 자바 기본 구조

• Java에서 모든 소스 코드는 클래스 단위로 구성
• 프로그램은 public static void main부터 시작

클래스(Class) 객체 지향 관점에서 객체(Object)를 정의하는 틀로서 많은 객체 지향 프로그래밍 언어의 기본 구조로, 변수(Variable)와 메서드(Method)로 구성

public class Test {
  public static void main(String[] args){
    System.out.println("Hello"); // Hello
  }
}

02. 자료형

1) 자료형의 유형

03. 변수 ⭐⭐

1) 변수 유효범위(Variable Scope)

① 클래스 변수(Class Variable)

• 클래스 블록에 선언하는 변수
• 클래스가 시작되면 변수가 생성되고, 클래스가 종료되면 변수 소멸
• 클래스 변수는 클래스 내에서 사용할 수 있음

public class Test {
  int a = 5;
  void fn(){
    a = a + 3;
  }
  public static void main(String[] args){
    Test s = new Test();
    s.a = s.a + 5;
    s.fn();
    System.out.println(s.a); // 13
  }
}

② 지역 변수(Local Variable)

• 블록 내에서 선언하는 변수
• 블록이 시작되는 부분에 바로 선언해주어야 하고, 중괄호가 닫히는 시점에 소멸
• 지역 변수는 해당 블록 안에서만 사용할 수 있음

public class Test {
  public static void main(String[] args){
    int a = 3;
    System.out.println(a); // 3
  }
}

③ static 변수

• 프로그램이 시작되면 변수가 생성되고, 프로그램이 종료되면 변수가 소멸
• static 변수는 프로그램 전체에서 사용할 수 있음

public class Test {
  static int count = 0;
  }
  public static void main(String[] args){
    Test s = new Test();
    s.count++;
    System.out.println(s.count); // 1
    s.count++;
    System.out.println(s.count); // 2
  }
}

04. 배열 ⭐⭐⭐

1) 배열 선언

① 1차원 배열 선언

• 배열 요수 개수에 정의된 숫자만큼 같은 타입의 데이터 공간이 선언
• 배열 요소 개수를 명시하지 않고 초깃값이 정의되어 있을 경우 초깃값 개수만큼 공간이 선언
• 자바에서 배열의 크기를 구할 때는 length 속성을 사용

public class Test {
  public static void main(String[] args){
    int []a = new int[3];
    System.out.println(a.length); // 3
  }
}

② 2차원 배열 선언

public class Test {
  public static void main(String[] args){
    int[][] a = new int[3][2];
    System.out.println(a.length); // 3
    System.out.println(a[0].length); // 3
  }
}

public class Test {
  public static void main(String[] args){
    int[][] a = {{1, 2}, {3}, {4, 5, 6}};
    System.out.println(a.length); // 3
    System.out.println(a[0].length); // 2
    System.out.println(a[1].length); // 1
    System.out.println(a[2].length); // 3 
  }
}

05. 표준 입출력 함수 ⭐⭐

1) 표준 출력 함수

2) 표준 입력 함수

• readLine은 입력장치(키보드)로부터 라인 전체를 읽는 표준 입력 함수

System.in.readLine()

import java.io.BufferedReader; // BufferedReader 사용 
import java.io.InputStreamReader; // InputStreamReader 사용
import java.io.IOException; // IOException 사용

public class Test {
  public static void main(String[] args) throws IOException{ // 입력 시 예외처리
    String a = null;
    BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
    a = r.readLine(); // Hello

    System.out.println(a); // Hello
  }
}

06. 반복문 - for each 문 ⭐

1) for each 문

• 배열이나 리스트의 크기만큼 반복하는데, 반복할 때마다 배열이나 리스트의 항목을 순차적으로 변수에 대입하는 반복문

for(제어변수 : 배열) {
  문장;
}

public class Test {
  public static void main(String[] args){
    String[] name = {"MINSU", "DANBI", "YUJIN"};
    for( String nm : name ){
      System.out.println(nm); // MINSU\nDANBI\nYUJIN
  }
}

07. 메서드 ⭐⭐

1) 사용자 정의 함수(메서드)

① 사용자 정의 함수(User-Defined Function)

• 사용자가 직접 새로운 함수를 정의하여 사용하는 방법
• 사용자 정의 함수에서 매개변수나 생성된 변수는 사용자 정의 함수가 종료되면 없어짐

자료형 함수명(자료형 변수명, ···){
  명령어;
  return 반환값;
}

public class Test {
  static char fn(int num){
    if(num % 2 == 0)
      return 'Y';
    else 
      return 'N';
  }
  public static void main(String[] args){
    char a = fn(5);
    System.out.print(a); // N
  }
}

2) static 메서드

• 클래스가 메모리에 올라갈 때 자동적으로 생성되는 메서드
• ⭐ 인스턴스를 생성하지 않아도 호출이 가능

  인스턴스란 클래스로부터 만들어진 객체

class Test {
  static void print(){
    System.out.println("static method");
  }
}
public class TestMain {
  public static void main(String[] args){
    Test.print(); // static method
  }
}

→ ⭐ 자바는 클래스 이름과 파일 이름이 같아야 함. main 메서드가 포함된 클래스를 기준으로 하는데, 위 예제는 TestMain 클래스에 main 메서드가 포함되어 있으므로 TestMain.java 파일에 코드를 넣어서 실행해야 함

08. 클래스 ⭐⭐⭐

1) 클래스(class)

• 객체 지향 프로그래밍(OOP; Object-Oriented Origrannubg)에서 특정 객체를 생성하기 위해 변수와 메서드를 정의하는 틀

2) 클래스 접근 제어자

① 클래스 접근 제어자(Access Modifier)

• 지정된 클래스, 변수, 메서드를 외부(같은 패키지이거나 다른 패키지)에서 접근할 수 있도록 권한을 설정하는 기능

② 클래스 접근 제어자 종류

⭐ 3) 클래스 정의

• 클래스에서 변수는 변수 선언과 동일하고, 메서드는 사용자 정의 함수와 문법이 동일
• 일반적으로 변수는 private 접근 제어자를 사용하여 외부에서 접근하지 못하게 하며, 메서드는 외부에 공개할 것만 public 접근 제어자를, 그렇지 않으면 protected나 private 접근 제어자를 사용하여 정보은닉을 함

public class 클래스명{
  private 자료형 변수명;
  public 반환_자료형 메서드명(자료형 변수명, ···){
    명령어;
    return 반환값;
  }
}

⭐ 4) 클래스의 변수 생성

• 클래스는 객체를 생성하기 위해 변수와 메서드를 정의하는 틀이므로 실제 변수에 들어갈 인스턴스를 new 키워드로 생성해주어야 함
• 변수를 이용해 클래스의 메서드에 접근

클래스명 변수명 = new 클래스명(파라미터);
변수명.메서드명();

5) 클래스 this

• this는 현재 객체를 가리키는 키워드
• 클래스 내부의 변수와 메서드를 가리킬 수 있음

this.변수;
this.함수(매개변수);

class Test {
  private int a;
  public void setA(int a){
    this.a = a;
  }
  public int getA(){
    return a;
  }
  public static void main(String[] args){
    Test tes = new Test();
    tes.setA(5);
    System.out.print(tes.getA()); // 5
  }
}

6) 생성자(Constructor) ⭐

• 해당 클래스의 객체가 생성될 때 자동으로 호출되는 특수한 종류의 메서드
• 생성자는 일반적으로 클래스의 멤버 변수를 초기화하거나 클래스를 사용하는 데 필요한 설정이 필요한 경우 사용
• 생성자는 클래스 명과 동일한 메서드명을 가지고, 반환 값이 없음
• 생성자가 없을 경우 public 클래스명(){} 이라는 아무 일도 하지 않는 생성자가 있는 것처럼 동작

7) 소멸자(Destructor) - finalize 메서드

• finalize 메서드는 객체의 수명이 끝났을 때 객체를 제거하기 위한 목적으로 사용되는 메서드
• 반환 값이 없음

class Test {
  public Test(){
    System.out.print("A");
  }
  public Test(int a){
    System.out.print("B: "+a);
  }
  public void finalize(){
    System.out.print("C");
  }
  public void fn(){
    System.out.print("D");
  }
  public static void main(String[] args){
    Test tes1 = new Test(); // A
    Test tes2 = new Test(5); // B: 5
    tes1.fn(); // D
    tes1.finalize(); // C
  }
}

09. 클래스 상속 ⭐⭐⭐

1) 클래스 상속(Inheritance)

• 상속은 어떤 객체가 있을 때 그 객체의 변수와 메서드를 다른 객체가 물려받는 기능
• 자식 클래스를 생성하면 무조건 부모 클래스의 생성자를 실행한 후에 자식 클래스의 생성자를 실행

⭐ 2) 상속 문법

class 부모_클래스명{ // 슈퍼 클래스
}
class 자식_클래스명 extends 부모_클래스명{ // 하위 클래스, 서브 클래스
}

class A {
  public void fnA(){
    System.out.print("A");
  }
}
class B extends A{
  public void fnB(){
    System.out.print("B");
  }
}
public class Test {
  public static void main(String[] args){
    B b = new B();
    b.fnA(); // A
    b.fnB(); // B
  }
}

→ ⭐ 자바는 자식 클래스를 생성하면 부모 클래스 생성자를 먼저 방문하지만, 파이썬은 자식 클래스의 생성자만 방문

3) 오버로딩(Overloading)

• 동일 이름의 메서드를 매개변수만 다르게 하여 여러 개 정의할 수 있는 기능
  • 메서드 이름이 같아야 함
  • 매개변수 개수가 달라야 함
  • 매개변수 개수가 같을 경우 데이터 타입이 달라야 함
  • 반환형은 같거나 달라도 됨

class A {
  public void fn(){
    System.out.println("A");
  }
  public void fn(int i){
    System.out.println(i);
  }
  public void fn(double d){
    System.out.println(d);
  }
  public int fn(int a, int b){
    return a+b;
  }
}
public class Test {
  public static void main(String[] args){
    A a = new A();
    a.fn(); // A
    a.fn(7); // 7
    a.fn(10.0); // 10.0
    System.out.print(a.fn(2, 3)); // 5
  }
}

4) 오버라이딩(Overriding)

• 하위 클래스에서 상위 클래스 메서드를 재정의할 수 있는 기능
  • 오버라이드하고자 하는 메서드가 상위 클래스에 존재하여 함
  • 메서드 이름은 같아야 함
  • 메서드 매개변수 개수, 데이터 타입이 같아야 함
  • 메서드 반환형이 같아야 함

class 부모_클래스명{
  public 반환_자료형 메서드명(자료형 변수명){ }
}
class 자식_클래스명 extends 부모_클래스명{
  public 반환_자료형 메서드명(자료형 변수명){ 
    // 부모 클래스의 메서드명, 매개변수가 동일해야 함
  }
}

class A {
  public void fn(){
    System.out.println("A");
  }
}
class B extends A {
  public void fn(){
    System.out.println("B");
  }
}
public class Test {
  public static void main(String[] args){
    A a = new B(); // B의 생성자 B()와 A의 생성자 A()를 호출해야 하지만 둘 다 없으므로 아무 일 X
    a.fn(); // B
  }
}

→ A a = new B(); 는 다형성(polymorphism)의 예로, 부모 클래스 A의 참조 변수가 자식 클래스 B의 인스턴스를 참조할 수 있음을 보여줌

• 생성자 vs 오버라이딩 : 생성자는 클래스명과 동일한 이름의 메서드, 오버라이딩은 부모, 자식 간 동일한 이름의 메서드

class Parent {
  public Parent(){
    System.out.println("A");
  }
  public void fn(){
    System.out.println("B");
  }
}
class Child extends Parent {
  public Child(){
    System.out.println("C");
  }
  public void fn(){
    System.out.println("D");
  }
}
public class Test {
  public static void main(String[] args){
    Child c = new Child(); // A\nC\n
    c.fn(); // D
}

5) 부모 클래스 접근

• 자바는 super 키워드를 이용하여 상위 클래스의 변수나 메서드에 접근할 수 있음

super.메서드명();

class A {
  public void fn(){
    System.out.println("A");
  }
}
class B extends A {
  public void fn(){
    super.fn();
    System.out.println("B");
  }
}
public class Test {
  public static void main(String[] args){
    A a = new B(); 
    a.fn(); // A\nB\n
  }
}

10. 추상 클래스 ⭐⭐

1) 추상 클래스

• 미구현 추상 메서드를 한 개 이상 가지며, 자식 클래스에서 해당 추상 메서드를 반드시 구현하도록 강제하는 기능

abstract class 추상_클래스명 { 
  abstract 자료형 메서드명(); // 메서드 내부는 정의하지 않음
}
class 자식_클래스명 extends 추상_클래스명{
  자료형 메서드명(){
    명령어; // 메서드를 상속받아 메서드 내부를 정의
  }
}

11. 인터페이스 ⭐

1) 인터페이스(Interface)

• 자바의 다형성을 극대화하여 개발코드 수정을 줄이고 프로그램 유지보수성을 높이기 위한 문법(인터페이스는 일종의 추상 클래스)
• 오직 추상 메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않음
• 인터페이스는 구현된 것은 아무것도 없고 밑그림만 그려져 있는 '기본 설계도'

interface 인터페이스_클래스명 {
  자료형 메서드명(); // 메서드 내부는 정의하지 않음
}
class 자식_클래스명 implements 인터페이스_클래스명{
  자료형 메서드명(){
    // interface의 메서드를 상속받아 내부를 정의
  }
}

interface A{
  void fn();
}
class B implements A {
  public void fn(){
    System.out.println("B");
  }
}
class C implements A {
  public void fn(){
    System.out.println("C");
  }
}
public class Test {
  public static void main(String[] args){
    A b = new B(); 
    A c = new C(); 
    b.fn(); // B
    c.fn(); // C
  }
}

12. 스레드 ⭐

1) 스레드

• 프로세스보다 가벼운, 독립적으로 수행되는 순차적인 제어의 흐름이며, 실행 단위

2) 스레드 구현

① Thread 클래스 상속

1. Thread 클래스 상속 부분

• 스레드를 만들기 위해서는 Thread 클래스를 상속받고, run() 메서드에 스레드 동작 시 수행할 코드를 작성(run 메서드 오버라이딩)

class T_Test extends Thread{
  public void run(){
    // 스레드 동작 시 수행할 코드
  }
}

→ Thread 클래스의 run() 메서드를 상속받아 재정의

2. Thread 클래스 호출 부분

• 스레드 클래스를 생성하여 스레드 변수에 저장 1) Thread 스레드변수 = new 상속받은스레드클래스(); 2) Thread 스레드변수 = new Thread(new 상속받은스레드클래스());
• 스레드변수.start()를 통해 스레드의 run() 메서드를 실행

class T_Test extends Thread{
  public void run(){
    System.out.println("Run");
  }
}

public class Test {
  public static void main(String[] args){
    Thread t1 = new T_Test(); 
    Thread t2 = new Thread(new T_Test());

    t1.start();
    t2.start();
    System.out.println("Main");
  }
}

→ main 함수에서 t1.start(); 이후, t2.start();를 하면 main 함수와 t1 스레드, t2 스레드가 동시에 동작하게 되므로 출력 결과는 달라질 수 있음

② Runnable 인터페이스 상속

1. Runnable 인터페이스 상속 부분

• 스레드를 만들기 위해서는 Runnable 인터페이스 상속받고, run() 메서드에 스레드 동작 시 수행할 코드를 작성(run 메서드 오버라이딩)

  class T_Test implements Runnable{
  public void run(){
    // 스레드 동작 시 수행할 코드
  }
  }

  → Runnable 클래스의 run() 메서드를 상속받아 재정의

2. Runnable 클래스 호출 부분

• 스레드 클래스를 생성하여 스레드 변수에 저장 1) Thread 스레드변수 = new Thread(new 상속받은스레드클래스());
• 위 Thread와 마찬가지로 스레드변수.start()를 통해 스레드의 run() 메서드를 실행

13. 컬렉션 ⭐

1) 컬렉션 프레임워크(Collection Framework)의 개념

출처 : [IT 기술 면접] Java의 Collection Framework 이란?

• 다수의 데이터를 효과적으로 처리할 수 있는 표준화된 방법을 제공하는 클래스의 집합
• 자바에서는 컬렉션 프레임워크를 통해 모든 컬렉션 클래스와 인터페이스를 제공
• ⭐ map은 Collection 인터페이스를 상속받고 있지 않지만 Collection으로 분류

2) 컬렉션 프레임워크 특징

• 배열의 단점을 보완 : 배열(Array)의 단점을 보완하여 만들어진 클래스로, 메모리 낭비를 방지하고 동적인 크기 변경 가능
• 자료구조의 구현 : 자료구조 형태인 List, Set, Map 등이 클래스로 구현
• 일관된 인터페이스 : 대량의 데이터를 일관된 인터페이스로 제공하여 쉽고 효율적으로 프로그램 작성 가능

3) 컬렉션 프레임워크의 구조

• 자바에서 컬렉션 프레임워크는 인터페이스로 List, Set, Map 등을 제공
• ⭐ Vector와 Hashtable의 경우 컬렉션 프레임워크의 명명법을 따르지 않음 → 가능하면 Vector 대신 ArrayList를, Hashtable 대신 Hashmap 사용을 권장

14. 예외 처리 ⭐

1) 예외 처리(Exception Handling)

• 프로그램이 동작 중에 의도하지 않은 비정상적인 동작을 처리

public class Test {
  public static void main(String[] args){
    try {
      int a = 4/0;
    }
    catch (Exception e) {
      System.out.println(e.getMessage()); // /by zero(0으로 나눌 수 없어 예외 발생)
    }
    finally {
      System.out.println("Finally");
    }
  }
}

2) throw

• 의도적으로 예외를 던지는 예약어
• 컴파일에는 문제가 없지만 런타임에 발생된 에러를 처리하기 위해 사용

public class Test {
  public static void main(String[] args){
    try {
      throw new Exception();
    }
    catch (Exception e) {
      System.out.println("강제 예외 발생"); 
    }
  }
}

⭐ 3) throws

• 메서드에서 발생하는 예외를 던지는 예약어

접근제어자 자료형 메서드명(매개변수) throws 예외처리명{
  명령문;

public class Test {
  public void divide(int a, int b) throws Eception{
    System.out.println(a/b); 
  }
  public static void main(String[] args){
    try {
      a.divide(4, 0);
    }
    catch (Exception e) {
      System.out.println(e.getMessage()); // /by zero
    }
  }
}

1. 프로그래밍을 위한 기본 사항

01. 진수

1) 진수(Antilogarithm)

• 특정 개수의 숫자만을 이용하여 수를 나타내는 수 체계

  2) 진수 변환

  ① 10진수를 n진수로 변환
• 10진수 값을 몫이 작은 n보다 작을 때까지 n으로 나누고 나머지 값들을 표시한 후에 나머지 값들을 읽음

② n진수를 10진수로 변환

• n진수에서 마지막 자리는 자리 숫자에 자릿값인 $\text n^0$을 곱하고, 마지막에서 두 번째 자리는 자리 숫자에 자릿값인 $\text n^1$을 곱하고, 마지막에서 세 번째 자리는 자리 숫자에 자릿값인 $\text n^2$을 곱하고, ··· 자리 숫자와 자릿값을 더해 10진수를 계산

3) 아스키 코드

① 아스키 코드

• 미국 ANSI에서 표준화한 정보교환용 부호체계
• 영문 키보드로 입력할 수 있는 모든 기호가 할당된 기본적인 부호체계

② 주요 아스키 코드

2. C언어

01. C언어 기본

1) C언어 기본 구조

• C언어는 본문 전에 처리하는 전처리 부분과 본문으로 구성되어 있음
• 헤더는 xxx.h 파일로, 헤더 안에는 프로그래밍에 필요한 함수가 포함

  2) 전처리기

  ① 전처리기(Preprocessor)
• 실행 파일을 생성하는 과정에서 소스 파일 내에 존재하는 전처리 지시문을 처리하는 작업

② 전처리기 종류

• #include : C언어 프로그램에 헤더 파일을 포함할 때 사용하는 전처리기
• #define : 매크로를 정의할 때 사용하며, 상숫값을 지정하기 위한 예약어로 구문의 상수로 치환할 때 사용하는 전처리기

02. 자료형 ⭐

1) 자료형

• 프로그래밍 언어에서 실숫값, 정숫값과 같은 여러 종류의 데이터를 식별하는 형태
• 메모리 공간을 효율적으로 사용하고 2진수 데이터를 다양한 형태로 사용하기 위해 존재

2) 자료형 유형

03. 식별자 ⭐

1) 식별자

• 변수, 상수, 함수 등 서로 구분하기 위해 사용되는 이름
• 프로그램의 구성요소를 구별하기 위해 사용

2) 식별자 명명 규칙

에약어 이미 문법적인 용도로 사용되고 있는 단어

3) 식별자 표기법

04. 변수 ⭐⭐

1) 변수(Variable)

• 저장하고자 하는 어떠한 값이 있을 때, 그 값을 주기억장치에 기억하기 위한 공간

2) 변수 선언(Variable Declaration)

• 변수나 함수가 있음을 알려주는 행위
• 변수가 어떤 자료형을 사용할지 알려주기 위해 사용
  • 초기화하지 않는 경우 : 자료형 변수명;
  • 초기화하는 경우 : 자료형 변수명=초깃값;

3) 변수 유효범위(Variable Scope)

① 전역 변수(Global Variable)

• 어떤 블록에도 속하지 않은 변수

  블록(Block) : C언어에서 중괄호로 묶는 부분

• 프로그램이 시작되면 변수가 생성되고, 프로그램이 종료되면 변수가 소멸
• 초기화하지 않으면 정수형은 0, 실수형은 0.0, 문자형은 NULL로 초기화
• 아무 곳에서나 사용 가능

② 지역 변수(Local Variable)

• 블록 내에서 선언하는 변수
• 블록이 시작되는 부분에 바로 선언해주어야 하고, 중괄호가 닫히는 시점에 소멸
• 해당 블록 안에서만 사용 가능

③ static 변수(초기화용)

• 블록 내외부 상관없이 선언할 수 있는 변수
• 변수 선언할 때 static이라는 키워드를 붙임
• 블록 내외부 상관없이 프로그램이 시작되면 변수가 생성되고, 프로그램이 종료되면 변수 소멸
• 전역 변수로 선언할 경우 프로그램 전체에서, 블록 내에 선언할 경우 블록 내에서만 사용 가능

05. 표준 입출력 함수 ⭐⭐

1) 표준 출력 함수(printf)

• printf는 지정된 지정된 포맷 스트링으로 데이터를 출력하는 함수

① 단순 출력

printf(문자열);

② 이스케이프 문자를 이용한 출력

• 이스케이프 문자는 문자열 내에서 특수한 기능을 수행하는 문자
• 특수한 기능을 수행하기 위해서 이스케이프 문자를 printf 함수의 큰 따옴표 안에 넣음
  • \n (New Line) : 커서를 다음 줄 앞으로 이동(개행)
  • \t (Tab) : 커서를 일정 간격만큼 수평 이동

③ 포맷 스트링을 이용한 변수 출력

• 일반적으로 scanf를 통해 사용자로투버 입력을 받아들이거나 printf를 통해 결과를 출력하기 위해 사용하는 형식
• 인자에는 변수명, 값, 수식이 올 수 있음

  printf(포맷_스트링이_포함된_문자열, 인자, ···);

④ 포맷 스트링을 이용한 변수 상세 출력

• 포맷 스트링을 이용해 정렬, 0 채우기, 출력할 공간 확보, 소수점 자릿수 표기를 지정 가능

  %[-][0][전체자리수].[소수점자리수]스트링

2) 표준 입력 함수(scanf)

• 키보드로 입력받은 문자열에서 지정된 포맷 스트링으로 데이터를 읽는 함수
• scanf의 포맷 스트링은 printf의 포맷 스트링과 동일

  scanf(포맷_스트링이_포함된_문자열, 변수의_주솟값, ···);

  scanf를 사용하기 위해서는 stdio.h 헤더를 선언해야함

06. 연산자 ⭐⭐⭐

1) 연산자(Operator)

• 프로그램 실행을 위해 연산을 표현하는 기호

2) 연산자 종류

• 증감 연산자(++,$--$) : 피연산자를 1씩 증가 혹은 1식 감소시킬 때 사용
• 산술 연산자(+, $-$, *, /, %) : 산술식을 구성
• 시프트 연산자(<<, >>) : 비트를 이동
• 관계 연산자(>, <, >=, <=, ==, !=) : 두 피연산자 사이의 크기를 비교
• 비트 연산자(&, |, ^, ~) : 비트 단위로 논리 연산할 때 사용
• 논리 연산자(&&, ||, !) : 두 피연산자 사이의 논리적인 관계 정의
• 삼항 연산자((조건식)? (참):(거짓)) : 조건이 참일 경우 (참) 값을, 거짓일 경우 (거짓) 값을 반환
• 대입 연산자(=, +=, -=, *=, /=, %=) : 변수(왼쪽)에 값(오른쪽)을 대입할 때 사용

3) 연산자 우선순위

• 증산시 관비논삼대

4) 연산자 상세

① 증감 연산자(Increment & Decrement Operator)

② 산술 연산자

③ 시프트 연산자(Shift Operator) ⭐

• <<로 1비트 이동시킬 때마다 2배씩 증가하게 되고, >>로 1비트 이동시킬 때마다 2배씩 감소

④ 관계 연산자(Relation Operator)

• 참이면 1을, 거짓이면 0을 반환

⑤ 비트 연산자(Bit Operator)

⑥ 논리 연산자(Logig Operator)

• 참이면 1, 거짓이면 0 반환

⑦ 삼항 연산자(Ternary Operator)

조건식 ? 참일때값 : 거짓일때값;

⑧ 대입 연산자(Assignment Operator)

• 변수(왼쪽)에 값(오른쪽)을 대입할 때 사용

07. 조건문

• 조건의 참, 거짓 여부에 따라 실행 경로를 달리하는 if 문과 여러 경로 중에 하나를 선택하는 switch 문으로 구분

1) if 문

if(조건문){
  명령문;
}

2) switch 문

switch (식){
  case 값:
    명령문;
    break;
  default:
    명령문;

• 식을 계산해서 일치하는 값을 가진 case 문을 실행
• 식이 어떠한 값도 만족하지 않으면 default로 진입
• ⭐ break가 존재하지 않을 경우 break를 만날 때까지 switch 문에 있는 다른 문장 실행

08. 반복문

• 특정 부분을 조건이 만족할 때가지 실행하도록 하는 명령문
• 반복문을 사용할 때 특별한 조건이 없으면 무한 처리를 반복(무한 루프)함

1) while 문

while(조건문){
  명령문;
}

2) do while 문

do{
  명령문;
}while(조건문);

• 참, 거짓과 관련 없이 무조건 한 번은 실행하고, 그 다음부터는 조건이 참인 동안에 해당 분기를 반복해서 실행하는 명령문

3) for 문

for (초기식; 조건식; 증감식){
  명령문;
}

명령문;

• 초기식, 조건식, 증감식을 지정하여 반복

4) 루프 제어 명령문

① break 문

• 반복문이나 switch 문을 중간에 탈출하기 위해 사용하는 명령어

② continue 문

• 반복문에서 다음 반복으로 넘어갈 수 있도록 하는 명령어

09. 배열 ⭐⭐⭐

1) 배열(Array)

• 같은 자료형의 변수들로 이루어진 집합

2) 배열 종류

① 1차원 배열

• 초기값이 없는 경우 : 자료형 배열명[배열_요소_개수];
• 초기값이 있는 경우 : 자료형 배열명[배열_요소_개수] = {초깃값};

int a[3] = {1, 2};
int 데이터가 들어갈 공간 = 배열값;

• 배열 요소 개수에 정의된 숫자만큼 같은 자료형의 데이터 공간 할당
• 초깃값을 선언하지 않으면 쓰레깃값이 저장
• 배열 요소 개수보다 적은 개수만큼 초기화하면 정수형일 경우 0으로, 실수형일 경우 0.0으로, 문자형일 경우 NULL로 초기화
  • NULL의 아스키코드는 0

② 2차원 배열

• 초기값이 없는 경우 : 자료형 배열명[행의_개수][열의_개수];
• 초기값이 있는 경우 : 자료형 배열명[행의_개수][열의_개수] = {초깃값};

int a[2][3] = {1, 2, 3, 4};

• (행의 개수)$\times$(열의 개수)에 정의된 숫자만큼 같은 자료형의 데이터 공간 할당
• 초깃값을 선언하지 않으면 쓰레깃값 저장

10. 문자열 ⭐⭐⭐

1) 1차원 배열과 문자열

• C언어에서는 문자열은 char 형 배열로 표현
• 문자열을 초기화할 때 마지막 NULL 문자가 삽입되므로 초기화하는 글자 수보다 1 이상 큰 값으로 배열을 선언(초기화할 때 배열의 크기를 명시하지 않으면 문자열의 문자 수+1만큼 자동 생성)
• printf 함수에서 %s를 이용하여 문자열을 읽고 출력하는데, printf 파라미터로 문자를 읽기 시작할 시작 주소를 알려주면 시작 주소부터** NULL 직전 값까지 읽어서 출력**

#include <stdio.h>
void main(){
  char a[8] = "Hello"; 
  printf("%s\n", a); // Hello
  printf("%s\n", a+1); // ello
  a[3] = NULL;
  printf("%s\n", a+1); // el
  printf("%s\n", a+4); // o
}

char a[8] = "Hello";

a[3] = NULL;

2) 2차원 배열과 문자열

• 여러 개 정의할 때 char 형 2차원 배열을 사용

  #include <stdio.h>
  void main(){
  char a[2][8] = {"Hello", "Stranger"};
  printf("%s\n", a[0]) // Hello
  printf("%s\n", a[1]) // Stranger
  printf("%s\n", a[1]+3) // anger
  a[1][4] = NULL; 
  printf("%s\n", a[1]+2) // ra

char a[2][8] = {"Hello", "Stranger"};

a[1][4] = NULL;

11. 구조체 ⭐⭐

1) 구조체

• 사용자가 기본 자료형을 가지고 새롭게 정의할 수 있는 사용자 정의 자료형

2) 구조체 선언

struct 구조체명{
  자료형 변수명1;
  자료형 변수명2;
  ···
};

• 구초체는 구조체변수.변수명 형태로 값을 가리킴

  #include <stdio.h>
  struct Student {
  char gender;
  int age;
  };
  

void main(){ struct Student s = {'F', 21}; s.gender = 'M'; printf("%c", s.gender); // M printf("%d", s.age); // 21

## <span style="background-color:#fff5b1">12. 함수 ⭐⭐⭐</span>
### 1) main 함수
① main 함수
- main 함수는 프로그램이 실행하는 모든 프로그램의 시작점
- main 함수에 있는 명령어를 실행

② main 함수 형태
```c
자료형 main(파라미터){
  명령어;
}

• *void main() *일 경우 반환할 값이 없으므로 return; 을 사용하거나 return 자체를 사용하지 않고, *int main() *일 경우 return 반환값; 을 명시해주어야 함
• main 함수나 사용자 정의 함수는 return 을 만나면 그 즉시 함수를 종료

  void main(){
  return;
  }

  int main(){
  return 반환값;
  }

void

• 함수를 호출한 호출자에게 결괏값을 제공하지 않는다는 의미의 자료형
• void는 '존재하지 않음'이라는 뜻으로 반환 값이 없다는 의미로 사용

2) 사용자 정의 함수

① 사용자 정의 함수(User-Defined Function)

• 사용자가 직접 새로운 함수를 정의하여 사용하는 방법
• 매개변수나 생성된 변수는 사용자 정의 함수가 종료되면 없어짐

② 사용자 정의 함수 선언

자료형 함수명(자료형 변수명, ···){
  명령어;
  return 반환값;
}

③ 매개변수 전달 방법

• 매개변수 전달 방법은 함수가 필요로 하는 값을 매개변수로 만들면 함수를 호출하는 쪽에서 매개변수를 사용하여 해당 함수에게 변수의 값, 변수의 주솟값을 전달하는 방식
• 매개변수 전달 방법 구성 요소

#include <stdio.h>

int fn(int x, int y){ // → 매개변수 
  ···
}

void main(){
  int i, j;
  ···
  fn(i, j); // → 전달인자
}

• ⭐ 매개변수 전달 방법 종류

④ 재귀 함수

• 재귀 함수는 함수 자신이 자신을 부르는 함수
• 재귀 함수 선언

  자료형 함수명(자료형 변수명, ···){
  ···
  함수명(변수명, ···)
  ···
  return 반환값;

3) 표준 함수

① 문자열 함수 #include<string.h>

*1. strcat(String Concatenate) *

• 문자열끼리 연결하는 함수
  • strcat(dest, src); : src 의 문자열을 dest 문자열 뒤에 붙임
  • strncat(dest, src, maxlen); : src 의 문자열에서 maxlent의 개수만큼 dest 문자열 뒤에 붙임

2. strcpy(String Copy)

• 문자열을 복사하는 함수
  • strcpy(dest, src); : src의 문자열을 dest 문자열에 복사
  • strncpy(dest, src, maxlen); : src의 무자열에서 maxlent의 개수만큼 dest 문자열에 복사

3. strcmp(String Compare)

• 문자열을 비교하는 함수
  • strcmp(s1, s2); : s1, s2의 대소를 비교
  • strncmp(s1, s2, maxlent); : maxlen 길이만큼만 s1, s2의 대소를 비교
• 문자열에 대해서 ASCII 코드를 비교하여 s1이 s2보다 크면 1을, s1과 s2가 같으면 0을, s1이 s2보다 작으면 -1을 반환

4. strlen(String Length)

• 문자열의 길이를 알려주는 함수
  • strlen(s); : s의 길이를 알려줌

5. strrev(String Reverse)

• 문자열을 거꾸로 뒤집는 함수
  • strrev(str); : str 내에 문자열을 거꾸로 뒤집음

6. strchr

• 문자열 내에 일치하는 문자가 있는지 검사하는 함수
  • strchr(str, c); : str 내에 c가 존재하면 첫번째 c의 위치를 반환

② 수학 함수 #include<math.h>

1. sqrt

• 양의 제곱근을 계산하는 함수
  • sqrt(n); : $\sqrt n$ 의 값을 계산

양의 제곱근은 소수를 확인할 때도 사용한다. a라는 값의 소수를 확인할 때는 2 ~ (a-1)의 모든 정수들로 나눴을 때 나누어 떨어지지 않는지 확인하는 것이 정석이지만, sqrt를 이용하면 2 ~ $\sqrt a$의 정수들만 나누어 떨어지지 않는지 확인하면 소수를 구할 수 있기 때문이다.

⭐ 2. ceil

• 소수점 올림 함수
  • ceil(n); : 소수점 올림

⭐ 3. floor

• 소수점 내림 함수
  • floor(n); : 소수점 내림

③ 유틸리티 함수

1. rand(Random) #include<stdlib.h>

• 임의의 값을 생성하는 함수
  • rand(); : 임의의 정숫값 1개를 생성

2. srand(Seed Random) #include<stdlib.h>

• 난수 생성 알고리즘에 사용하는 seed를 정해주는 함수
• srand를 사용하면 rand 함수를 사용할 때 해당 seed 값에 해당하는 난수 패턴으로 생성
  • srand(seed); : seed 값에 따라 난수 발생기를 초기화

3. time #include<time.h>

• 현재 시간을 가져오는 함수
• 1970년 1월 1일 이후로 몇 초가 경과했는지를 나타냄 time(NULL); : time 함수에 파라미터를 NULL로 하면 현재 시간을 리턴

  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>
  void main() {
  int a;
  int i;
  srand(time(NULL));
  for(i=0; i<6; i++){
    a = rand()%45+1;
    printf("%d ", a); // 29 2 43 25 4
  }
  }

  rand() 함수는 임의로 난수만 생성하기 때문에 여러 번 실행하면 동일한 숫자가 나올 수 있음

4. atoi(ASCII to Integer) #include<stdlib.h>

• 문자열을 정수형으로 변환하는 함수
  • atoi(str) : 문자열(str)을 정수(int)형으로 변환

    #include <stdio.h>
    #include <stdlib.h>
    void main() {
    char *a = "1";
    int num = atoi(a);
    printf("%d ", num); // 1
    }

    문자열을 저장하기 위해서 일반적으로 배열을 사용하지만, 문자형 포인터를 생성하면서 문자열을 대입할 수 있음

5. atof(ASCII to Floating Point) #include<stdlib.h>

• 문자열을 실수형으로 변환하는 함수
  • atof(str) : 문자열(str)을 실수형(float, double)형으로 변환

⭐ 6. itoa(integer to ASCII)

• 정수형을 문자열로 변환하는 함수
  • itoa(value, str, radix) : value를 변환하여 str에 radix 진수로 저장

13. 포인터 ⭐⭐⭐

1) 포인터

• 변수의 주솟값을 저장하는 공간

2) 포인터 선언

자료형* 포인터_변수명 = &변수명;

• 자료형 뒤에 *를 붙이면 주소를 저장하는 포인터 변수, 일반 변수명에 &를 붙이면 해당 변수명의 주솟값
• 주소에 해당하는 값을 가리키는 * 연산과 변수에 주솟값을 나타내는 & 연산은 반대 기능 → *(&) 는 상쇄

#include <stdio.h>
void main() {
  int a = 10;
  int* b = &a;
  printf("%d %d %d", a, *b, *(&a))); // 10 10 10
}

⭐ 3) 배열과 포인터

• 자료형 배열명[요소]; 일 때 다음 코드는 동일
  • 배열의 i번지 주소 : 배열+i == &배열[i];
  • 배열의 i번지 값 : *(배열+i) == 배열[i];

① 1차원 배열과 1차원 포인터

• 1차원 배열에서 배열명만 단독으로 사용할 경우 1차원 포인터와 동일
• 1차원 배열일 때는 배열명[요소] 형태, *(배열명+요소)일 경우 값을 가리키고, 1차원 포인터일 때는 포인터[요소] 형태, *(포인터+요소)일 경우 값을 가리킴

  #include <stdio.h>
  void main() {
  int a[3] = {1, 2};
  int *p = a;  
  printf("%d %d %d\n", a[0], *b, *(&a))); // 10 10 10
  }

② 2차원 배열과 1차원 포인터

• 2차원 배열에서 배열명만 단독으로 사용할 경우 2차원 포인터와 동일
• 2차원 배열일 때는 배열명[요소] 형태, *(배열명+요소)는 1차원 포인터와 동일하고, 1차원 포인터에 대해 *과 []을 이용해야 값을 가리킬 수 있음

  #include <stdio.h>
  void main() {
  int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
  int *p = a[1];  
  printf("%d %d %d\n", *a[0], *a[1], *a[2]); // 1 3 5
  printf("%d %d %d\n", **a, **(a+1), **(a+2)); // 1 3 5
  printf("%d %d\n", *p, *(p+1)); // 3 4
  printf("%d %d\n", p[0], p[1]); // 3 4
  }

③ 2차원 배열과 포인터 배열

#include <stdio.h>
void main() {
  int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
  int *p[3] = {a[2], a[0], a[1]};  
  printf("%d %d %d\n", a[0][0], a[1][0], a[2][0]); // 1 3 5
  printf("%d %d %d\n", *a[0], *a[1], *a[2]); // 1 3 5
  printf("%d %d %d\n", p[0][0], p[1][0], p[2][0]); // 1 3 5
  printf("%d %d %d\n", *p[1], *p[2], *p[0]); // 1 3 5
}

④ 2차원 배열과 2차원 포인터

• 2차원 배열에서 배열명만 단독으로 사용할 경우 2차원 포인터와 동일
• 2차원 배열일 때 배열명[요소][요소], *배열명[요소], **(배열명+요소)일 경우 값을 가리킴
• ⭐ 2차원 포인터는 int **p, **q; 형태로 선언할 수 있으나 2차원 포인터 p, q는 2차원 배열에서 한 덩어리의 크기를 알 수 없기 때문에 열의 개수를 명시하는 형태로 포인터 변수를 선언
• ⭐ 포인터 변수 선언할 때 괄호가 없으면 2차원 배열에 대한 포인터가 아닌 포인터 배열이 됨
  • 자료형 (*포인터 변수)[열의 크기];

    #include <stdio.h>
    void main() {
    int a[3][2] = {{1, 2}, {3, 4}, {5, 6}};
    int (*p)[2] = a;
    int (*q)[2] = a+1;
    printf("%d %d %d\n", a[0][0], a[0][1], a[1][0]); // 1 2 3
    printf("%d %d %d\n", p[0][0], p[0][1], p[1][0]); // 1 2 3
    printf("%d %d %d\n", q[0][0], q[0][1], q[1][0]); // 3 4 5
    }

⭐ 4) 구조체와 포인터

① 구조체 변수와 구조체 포인터

• 구조체는 일반 구조체 변수로 접근할 때는 . *으로 접근하고, *구조체 포인터로 접근할 때는 -> 로 접근

#include <stdio.h>
Struct Student{
  char gender;
  int age;
}
void main() {
  struct Student s = {'F', 21};
  struct Student *p = &s;
  printf("%c %d\n", s.gender, s.age); // F 21
  printf("%c %d\n", (&s)->gender, (&s)->age); // F 21
  printf("%c %d\n", p->gender, p->age); // F 21
  printf("%c %d\n", (*p).gender, (*p).age); // F 21
  printf("%c %d\n", p[0].gender, p[0].age); // F 21
}

② 1차원 구조체 배열과 1차원 구조체 포인터 ⭐

• 1차원 구조체 배열에서 배열명만 단독으로 사용할 경우 1차원 구조체 포인터와 동일
• 1차원 구조체 배열일 때 배열명[요소].변수명 형태, (*(배열명+요소)).변수명, 배열명->변수명 형태, (배열명+요소)->변수명 형태로 값을 가리킴
• 1차원 포인터일 때 포인터[요소].변수명 형태, (*(포인터+요소)).변수명, 포인터->변수명 형태, (포인터+요소)->변수명 형태로 값을 가리킴

#include <stdio.h>
Struct Student{
  char gender;
  int age;
}
void main() {
  struct Student s[3] = {'F', 21, 'M', 20, 'M', 24};
  struct Student *p = &s;
  printf("%c %d\n", s[0].gender, s[0].age); // F 21
  printf("%c %d\n", (*s)->gender, (*s)->age); // F 21
  printf("%c %d\n", s->gender, s->age); // F 21
  printf("%c %d\n", (s+1)->gender, (s+1)->age); // M 20
  printf("%c %d\n", p[0].gender, p[0].age); // F 21
  printf("%c %d\n", (*p).gender, (*p).age); // F 21
  printf("%c %d\n", p->gender, p->age); // F 21
  printf("%c %d\n", (p+1)->gender, (p+1)->age); // M 20
}

⭐ 5) 함수 포인터

• 함수의 주소를 저장하고, 해당 주소의 함수를 호출하는 데 사용하는 포인터

  리턴타입 (*함수_포인터)(함수 파라미터);

#include <stdio.h>
void fn1(){
  printf("fn1 함수\n");
}
int fn2(int a){
  printf("fn2 함수: %d\n", a);
  return 0;
}
void main(){
  void (*pf1)();
  int (*pf2)(int);
  fn1(); // fn1 함수
  fn2(5); //fn2 함수: 5
  pf1 = fn1; 
  pf2 = fn2;
  pf1(); // fn1 함수
  pf2(2); //fn2 함수: 2

언리얼 엔진에서는 협업을 위한 아주 강력한 도구를 제공합니다. 바로 'Multi-User Editing' 이라는 플러그인으로, 공유 편집 세션에서 무려 실시간 협업이 가능합니다.

이 Multi-User Editing 워크플로우는 하나의 서버가 여러 세션을 호스팅하는 클라이언트-서버 모델을 기반으로 구축되어 있어, 협업을 하기 위해서는 먼저 몇가지 조건을 만족해야합니다.

• 각 컴퓨터에 동일한 버전의 언리얼 엔진을 설치해야 합니다.
• 모든 컴퓨터가 동일한 LAN 또는 VPN 에 연결되어 있어야합니다.
• 모든 컴퓨터가 하나의 프로젝트(주로 Server)의 복사본을 가지고 있어야 합니다.

1. Multi-User Editing 플러그인 활성화

해당 기능을 사용하기 위해 [Edit] - [Plugins] 에서 'Multi-User Editing' 플러그인을 활성화시켜줍니다.

플러그인을 활성화하면, 각 컴퓨터 마다 고유 색상을 커스터마이징하여 서로 구별하기 쉬운 아이덴티티를 가질 수 있습니다.

• [Edit] - [Project Settings] - [Multi-User Editing]
  • 'Enable Multi-User Toolbar Button'을 활성화
  • 'Display Name'과 'Avatar Color'를 변경

2. 서버(Server)

서버 시작

먼저 공유 편집 세션을 구축하기 위해서 서버를 열어야합니다. [Window] - 'Mullti-User Browser'를 선택하여 열린 블라우저 창에서 왼쪽 위에 있는 Launch 아이콘을 클릭하여 서버를 시작할 수 있습니다.

혹은 이전 단계에서 'Enable Multi-User Toolbar Button'을 활성화했다면 툴바에 있는 Multi-User Editing 아이콘을 눌러 'Mullti-User Browser'를 표시할 수도 있습니다.

서버가 제대로 시작했다면 아래와 같이 서버 관리 창이 실행됩니다.

세션 시작

서버를 시작했다면, 이제 협업을 위한 방을 만들 차례입니다. 즉, 아직 해당 서버에 연결된 언리얼 에디터 인스턴스가 없다는 뜻이며, 인스턴스를 연결하기 위해서는 새로운 세션을 구축할 필요가 있습니다.

'Mullti-User Browser'에서 왼쪽 위에 Launch 오른쪽에 있는 Create 아이콘을 클릭하여 세션을 구성할 수 있습니다.

새롭게 생성할 세션의 이름을 입력하고 서버를 선택하여 세션을 생성합니다.

별다른 행동없이도 자동으로 세션에 참가됩니다. 아래와 같이 세션에 참가되었다면 성공적으로 세션을 시작한 것입니다.

3. 클라이언트(Client)

이제 생성된 세션에 다른 컴퓨터가 들어갈 준비가 되었습니다. 세션에 들어가려는 클라이언트도 서버와 마찬가지로 'Mullti-User Browser'를 열어 세션 목록을 확인하면, 서버에서 만든 세션이 보입니다.

이 세션에 참가하면 모든 참가자가 수행한 변경 사항 히스토리가 표시되며 자동으로 변경 사항을 공유합니다.

4. 트랜잭션 동기화

작업 중인 에셋 타입과 적용된 변경 사항의 특성에 따라 연결된 클라이언트 사이에 변경 사항을 동기화합니다.

레벨: 즉시 동기화

레벨 콘텐츠에 적용된 모든 변경 사항은 해당 세션의 다른 모든 컴퓨터에 즉시 동기화됩니다.

시퀀서: 재생 동기화 및 선택적 UI 동기화

이 협업 시스템은 레벨 시퀀스와 마스터 시퀀스를 레벨과 같이 취급하기때문에, 사용자가 '트랙 추가나 제거, 새 키프레임 추가'와 같이 시퀀스를 변경하면 이러한 변경사항을 세션의 다른 모든 사용자에게 즉시 동기화합니다.

또한 한 사용자가 시퀀스를 열면 모든 클라이언트에서 시퀀서 UI를 자동으로 열도록 선택할 수 있으며, 시퀀스를 재생하면 동일한 시퀀스가 열려 있는 모든 사용자에 대해 동일한 시퀀스가 즉시 재생됩니다.

시퀀서 UI 동기화를 활성화하려면 Concert.EnableOpenRemoteSequencer 콘솔 명령을 사용하면 됩니다.

기타 에셋: 저장 시 동기화

프로젝트에 포함되어 있는 대부분의 에셋 타입(머티리얼, 머티리얼 인스턴스, 스태틱 메시 에셋, 블루프린트 클래스)은 수정될 때마다 즉시 동기화되지 않습니다. 누군가가 편집 중인 에셋에는 자물쇠 모양의 더티 상태의 아이콘이 표시됩니다. 이 경우 다른 사용자는 해당 에셋을 수정하지 못하도록 '잠금' 상태가 됩니다.

이후 변경한 에셋을 저장하면 세션의 다른 모든 사용자에게 트랜젝션을 전송하며, 잠금 상태였던 에셋의 잠금이 해제됩니다. 수정하지 않은 에셋을 잠그거나 해제하고자 한다면, 에셋을 우클릭하여 [Multi-User] - 'Lock Asset(s)'을 선택하면 됩니다.

5. 세션 변경사항 지속

여러 컴퓨터에서 세션의 레벨과 에셋을 변경하면, 이 트랜잭션이 본인이 사용하고 있는 컴퓨터의 프로젝트를 구성하는 실제 로컬 파일에는 아직 반영되어 있지 않습니다. 이 라이브 세션의 에디터는 일종의 가상 샌드박스 방식으로 로컬 프로젝트 콘텐츠 위에 트랜잭션을 적용하기 때문입니다.

따라서 다른 사람이 라이브 세션 도중에 수행한 작업을 본인의 로컬 프로젝트 파일에 유지하려면 해당 변경 사항을 동기화해야 합니다. 이를 위해서는 에디터 오른쪽 아래에 있는 'Source Control' 아이콘을 눌러 'Persist Session Change...'를 선택합니다. 세션 참가자가 이를 선택하면, 현재 세션에서 이루어진 모든 수정 사항을 디스크의 로컬 파일에 적용합니다.

이후 라이브 세션 도중 수정된 파일에서 로컬 컴퓨터의 프로젝트에 적용할 파일을 선택할 수 있습니다.

만약 변경 사항을 지속시키지 않고 세션을 나가버린다면 에디터는 세션 시작 또는 참가 이전 상태로 프로젝트를 자동으로 되돌립니다. 하지만 이는 이전 트랜잭션이 완전히 사라진 것이 아니고, 이후에 같은 세션에 다시 참가하면 멀티 유저 편집 시스템이 모든 해당 트랜잭션을 그대로 에디터에 다시 적용합니다.

Reference

STL은 '표준 템플릿 라이브러리'의 약자로, C++ 프로그래밍 능률을 한껏 올리는 데 큰 기여를 한 라이브러리입니다. STL이라 함은 주로 세 개의 라이브러리를 사용합니다.

• container : 임의 타입의 객체를 보관
• iterator : container에 보관된 원소에 접근
• algorithm : iterator들을 이용하여 일련의 작업을 수행

Container

• sequence container : vector, list, deque
• associative container

sequence container(unsorted)

1. Vector(std::vector)

선언

#include <vector>
std::vector<int> vec;

초기화

std::vector< int > vec = {1,2,3,4,5}; 
std::vector< int > vec(10); 
std::vector< int > vec(10,5); 

멤버 함수

vec.push_back( value ); // 맨 뒤에 원소 value 추가
vec.insert( vec.begin(), value ); //원하는 위치에 원하는 값 삽입
vec.pop_back(); // 맨 마지막 원소 제거
vec.erase( vec.begin() ); // 원하는 위치, 범위의 원소 제거
vec.clear();// 벡터 초기화 (길이 = 0)
vec.resize( n ); // 크기를 n으로 바꿈 ( 늘어난 위치의 원소들은 0으로 초기화 )
vec.size(), vec.empty(), vec.front(), vec.back(), vec.begin(), vec.end()

2. List(std::list)

선언

#include <deque>

초기화

멤버 함수

associative container(sorted)

1. Set(std::set)

선언

#include <deque>

초기화

멤버 함수

container adaptor

1. Stack(std::stack)

선언

#include <deque>

초기화

멤버 함수

Reference

• [모두의 코드] 씹어먹는 C++ - <10 - 1. C++ STL - 벡터(std::vector), 리스트(list), 데크(deque)>
• [Lee's blog] C++ STL 사용방법 모음집

문제 두 개의 단어 begin, target과 단어의 집합 words가 있습니다. 아래와 같은 규칙을 이용하여 begin에서 target으로 변환하는 가장 짧은 변환 과정을 찾으려고 합니다.

1. 한 번에 한 개의 알파벳만 바꿀 수 있습니다.
2. words에 있는 단어로만 변환할 수 있습니다.

예를 들어 begin이 "hit", target가 "cog", words가 ["hot","dot","dog","lot","log","cog"]라면 "hit" -> "hot" -> "dot" -> "dog" -> "cog"와 같이 4단계를 거쳐 변환할 수 있습니다.

두 개의 단어 begin, target과 단어의 집합 words가 매개변수로 주어질 때, 최소 몇 단계의 과정을 거쳐 begin을 target으로 변환할 수 있는지 return 하도록 solution 함수를 작성해주세요.

제한사항

- 각 단어는 알파벳 소문자로만 이루어져 있습니다.
- 각 단어의 길이는 3 이상 10 이하이며 모든 단어의 길이는 같습니다. 
- words에는 3개 이상 50개 이하의 단어가 있으며 중복되는 단어는 없습니다.
- begin과 target은 같지 않습니다.
- 변환할 수 없는 경우에는 0를 return 합니다.

Input

Output

4

Code

문제 ...(생략) 사람들은 현재 1열로 줄을 서있고, 맨 앞의 사람만 이동이 가능하다. 인규는 번호표 순서대로만 통과할 수 있는 라인을 만들어 두었다. 이 라인과 대기열의 맨 앞 사람 사이에는 한 사람씩 1열이 들어갈 수 있는 공간이 있다. 현재 대기열의 사람들은 이 공간으로 올 수 있지만 반대는 불가능하다. 승환이를 도와 프로그램을 완성하라.

입력 입력의 첫째 줄에는 현재 승환이의 앞에 서 있는 학생들의 수 N(1 ≤ N ≤ 1,000,자연수)이 주어진다. 다음 줄에는 승환이 앞에 서있는 모든 학생들의 번호표(1,2,...,N) 순서가 앞에서부터 뒤 순서로 주어진다.

출력 승환이가 무사히 간식을 받을 수 있으면 "Nice"(따옴표는 제외)를 출력하고 그렇지 않다면 "Sad"(따옴표는 제외)를 출력한다.

Input

5
5 4 1 3 2

Output

Nice

Code

#include <iostream>
#include <stack>

using namespace std;

int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    int N, temp, cnt=1;
    cin>>N;

    stack<int> bottom;

    while(N--){
        cin>>temp;

        if(cnt==temp) cnt++;
        else bottom.push(temp);
        while (!bottom.empty() && bottom.top()==cnt)
        {
            bottom.pop();
            cnt++;
        }
    }

    if(bottom.empty()) cout<<"Nice";
    else cout<<"Sad";

    return 0;
}

문제 골드바흐의 추측: 2보다 큰 짝수는 두 소수의 합으로 나타낼 수 있다. 짝수 N을 두 소수의 합으로 나타내는 표현을 골드바흐 파티션이라고 한다. 짝수 N이 주어졌을 때, 골드바흐 파티션의 개수를 구해보자. 두 소수의 순서만 다른 것은 같은 파티션이다.

입력 첫째 줄에 테스트 케이스의 개수 T (1 ≤ T ≤ 100)가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 N은 짝수이고, 2 < N ≤ 1,000,000을 만족한다.

출력 각각의 테스트 케이스마다 골드바흐 파티션의 수를 출력한다.

Input

5 6 8 10 12 100

Output

1 1 2 1 6

Code

#include <iostream>

using namespace std;


int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    int num, N;
    cin >> num;

    bool arr[1000001] = {false, };
    arr[0]=arr[1]=true;

    for(int i=2; i*i<1000001; i++){
        if(arr[i]) continue;
        for(int j=2*i; j<1000001; j+=i) arr[j] = true;
    }

    while(num--){
        cin >> N;
        int count=0;

        for(int i=2; i<=N/2; i++) if(!arr[i] && !arr[N-i]) count++;
        cout << count << '\n';
    }

    return 0;
}

풀이

골트바흐의 추측에 따르면, 2보다 큰 모든 짝수는 두개의 소수(Prime nember)의 합으로 표시할 수 있다. 하나의 소수를 두 번 사용하는 것 또한 허용된다. 이를 기반으로 2보다 큰 짝수에 대한 소수를 중복을 허용하고 쭉 나열해 본다면 아래와 같다.

표를 들여다보면 숫자들 사이에서 어떤 규칙을 발견할 수 있다. 바로 하나의 소수의 합으로 이루지거나 중간을 기점으로 대칭하다는 것 이다.

출처 : [wikipedia] 골트바흐의 추측

이 이미지는 골트바흐의 숫자를 짝수 50까지 시각화한 것이며, 대칭한 규칙을 쉽게 확인할 수 있다. 이 대칭성을 토대로 임의의 짝수 N의 골트바흐 파티션은 임의의 소수 a가 있을 때 N-a가 소수면 그 조건이 성립된다. 이 조건을 만족하는 소수 a의 개수를 구하면 골트바흐 파티션의 개수를 구할 수 있다.

이때, 소수 a는 골트바흐 숫자의 대칭성에 따라 N의 절반 이하의 범위에서 찾을 수 있다. 코드로는 2부터 주어진 임의의 짝수/2 까지의 반복 내에서 위 조건을 만족하는 소수 쌍의 개수를 구하는 방향으로 작성할 수 있다.

시행착오

처음에 호기롭게 작성한 식에서 N/2까지 유추를 했지만 시간복잡도가 O(N)이어서 시간 초과를 맛봤다. 이번 기회에 시간복잡도를 고려하면서 더 좋은 코드를 구현할 수 있도록 고민하는 과정의 필요성을 몸소 느꼈다.

#include <iostream>

using namespace std;


int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    int num, N;
    cin >> num;

    bool arr[1000001] = {false, };
    arr[0]=arr[1]=true;

    for(int i=2; i*i<1000001; i++){
        if(arr[i]) continue;
        for(int j=2*i; j<1000001; j+=i) arr[j] = true;
    }

    while(num--){
        cin >> N;
        int count=0;

        for(int i=2; i<=N/2; i++){
            for(int j=N-1; j>=N/2; j--){
                if(!arr[i] && !arr[j]){
                    if(i+j<N) break;
                    else if(i+j == N)
                        count++;
                }
                else continue;
            }
        }

        cout << count << '\n';
    }

    return 0;
}

문제 M이상 N이하의 소수를 모두 출력하는 프로그램을 작성하시오.

입력 첫째 줄에 자연수 M과 N이 빈 칸을 사이에 두고 주어진다. (1 ≤ M ≤ N ≤ 1,000,000) M이상 N이하의 소수가 하나 이상 있는 입력만 주어진다.

출력 한 줄에 하나씩, 증가하는 순서대로 소수를 출력한다.

출처 : [wikipedia] 에라토스테네스의 체

2부터 차례대로 소수를 구하게 되면 시간 초과 결과와 마주하게된다. 이를 해결하기 위해서는 에라토스테네스의 체를 이용해야한다. 에라토스테네스의 체는 특정 범위가 주어졌을 때 그 범위 내의 소수를 찾는 빠르고 쉬운 방법이다.

Input

3 6

Output

3 5 7 11 13

Code

using namespace std;

int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    int min, max;
    cin >> min>>max;


    bool arr[max];
    arr[0] = arr[1] = false;

    for(int i=2; i<=max; i++)
        arr[i] = true;


    for(int i=2; i*i <= max; i++){
        if(!arr[i]) continue;
        for(int j = i*2; j <= max; j += i) arr[j]=false;
    }

    for(int i=min; i<=max; i++)
        if(arr[i]) cout<<i<<'\n';

    return 0;
}

시행착오

처음에는 1434 문제와 비슷한 맥락으로 무작정 소수를 구하는 코드를 작성했다. 그 결과는 어김없이 시간 초과 라는 결과를 마주했다.

$^1$첫번째 시도

#include <iostream>
#include <cmath>

using namespace std;

bool isPrime(long long n)
{
    for(int i=2; i<=sqrt(n); i++)
            if(n%i == 0) return false;

    return true;
}

int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    long long min, max;
    cin >> min>>max;

    for(int i=min; i<=max; i++){
        while(isPrime(i)){
            cout << i << endl;
            i++;
        }  
    }

    return 0;
}

$^2$두번째 시도

wikipedia에서 제공해주는 C++ 코드 기반으로 소수 구하기 코드를 작성했더니 어김없이 마주친 시간 초과 OTL..

using namespace std;

int main(){
    ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

    int min, max;
    cin >> min>>max;

    bool arr[max];
    arr[0] = arr[1] = false;

    for(int i=2; i<=max; i++)
        arr[i] = true;

    for(int i=2; i*i <= max; i++){
        if(!arr[i]) continue;
        for(int j = i*i; j <= max; j += i) arr[j]=false;
    }

    for(int i=min; i<=max; i++) if(arr[i]) cout<<i<<endl;

    return 0;
}

$^3$세번째 시도

사실 스스로의 힘으로 풀어보고 싶어서 여러번 도전 끝에 10번의 시간 초과 결과를 받고 다른 사람들의 코드를 찾아보기 시작했다. 그러다 ★한 줄기 빛☆ 같은 글을 발견하였다.

5. 에라토스테네스의 체를 구현할 때 흔히 안쪽 루프를 int j = i * i로 시작하는데, 
이렇게 하면 i가 46341이 되는 순간부터 
i * i가 int의 범위를 초과하기 때문에 오버플로우가 발생합니다. 
long long을 사용하거나, i * i 대신 i * 2부터 시작하는 등의 방법을 사용하세요.

이 글을 믿고 i*i 대신 i*2 로 시작하는 코드로 수정했더니 마법처럼 시간 초과의 저주가 풀렸다!

...생략

    for(int i=2; i*i <= max; i++){
        if(!arr[i]) continue;
        for(int j = i*2; j <= max; j += i) arr[j]=false;
    }

...

그리고 같은 글에서 앞으로의 코드 스타일에 변화를 주는 문장을 만났다. "추가로 endl은 버퍼를 flush하기 때문에 너무 느립니다. \n을 대신 사용하세요." 지금부터 endl을 내주고 '\n'를 취한다!

1. 외부 카메라를 통해 영상 촬영하기

$^\textbf{1}$Uses Intel RealSense D435

먼저 'Intel RealSense D435'를 사용하기 위한 코드를 준비합니다.

import pyrealsense2 as rs
import numpy as np
import cv2

# Configure depth and color streams
pipeline = rs.pipeline()
config = rs.config()

# Get device product line for setting a supporting resolution
pipeline_wrapper = rs.pipeline_wrapper(pipeline)
pipeline_profile = config.resolve(pipeline_wrapper)
device = pipeline_profile.get_device()
device_product_line = str(device.get_info(rs.camera_info.product_line))

found_rgb = False
for s in device.sensors:
    if s.get_info(rs.camera_info.name) == 'RGB Camera':
        found_rgb = True
        break
if not found_rgb:
    print("The demo requires Depth camera with Color sensor")
    exit(0)

config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)

if device_product_line == 'L500':
    config.enable_stream(rs.stream.color, 960, 540, rs.format.bgr8, 30)
else:
    config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)

# Start streaming
pipeline.start(config)

try:
    while True:

        # Wait for a coherent pair of frames: depth and color
        frames = pipeline.wait_for_frames()
        depth_frame = frames.get_depth_frame()
        color_frame = frames.get_color_frame()
        if not depth_frame or not color_frame:
            continue

        # Convert images to numpy arrays
        depth_image = np.asanyarray(depth_frame.get_data())
        color_image = np.asanyarray(color_frame.get_data())

        # Apply colormap on depth image (image must be converted to 8-bit per pixel first)
        depth_colormap = cv2.applyColorMap(cv2.convertScaleAbs(depth_image, alpha=0.03), cv2.COLORMAP_JET)

        depth_colormap_dim = depth_colormap.shape
        color_colormap_dim = color_image.shape

        # If depth and color resolutions are different, resize color image to match depth image for display
        if depth_colormap_dim != color_colormap_dim:
            resized_color_image = cv2.resize(color_image, dsize=(depth_colormap_dim[1], depth_colormap_dim[0]), interpolation=cv2.INTER_AREA)
            images = np.hstack((resized_color_image, depth_colormap))
        else:
            images = np.hstack((color_image, depth_colormap))

        # Show images
        cv2.namedWindow('RealSense', cv2.WINDOW_AUTOSIZE)
        cv2.imshow('RealSense', images)
        cv2.waitKey(1)

finally:

    # Stop streaming
    pipeline.stop()

$^\textbf{2}$ Record video with webcam

촬영한 영상 혹은 사진을 Instant NGP가 사용할 수 있는 데이터로 정제하기 위해서 저장하는 과정을 거칩니다. 파일명은 이미 저장된 파일과 겹치지 않게 시간을 기준으로 생성되도록 작성하였습니다.

import cv2
import time
import pyrealsense2 as rs
import numpy as np

# intel realsense initial

# Configure depth and color streams
pipeline = rs.pipeline()
config = rs.config()

# Get device product line for setting a supporting resolution
pipeline_wrapper = rs.pipeline_wrapper(pipeline)
pipeline_profile = config.resolve(pipeline_wrapper)
device = pipeline_profile.get_device()
device_product_line = str(device.get_info(rs.camera_info.product_line))

# Get device product line for setting a supporting resolution
pipeline_wrapper = rs.pipeline_wrapper(pipeline)
pipeline_profile = config.resolve(pipeline_wrapper)
device = pipeline_profile.get_device()
device_product_line = str(device.get_info(rs.camera_info.product_line))

found_rgb = False
for s in device.sensors:
    if s.get_info(rs.camera_info.name) == 'RGB Camera':
        found_rgb = True
        break
if not found_rgb:
    print("The demo requires Depth camera with Color sensor")
    exit(0)

# config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)

if device_product_line == 'L500':
    config.enable_stream(rs.stream.color, 960, 540, rs.format.bgr8, 30)
else:
    config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)

# Start streaming
pipeline.start(config)

# ------------------------------------------------------

fc = 20.0
codec = cv2.VideoWriter_fourcc('D', 'I', 'V', 'X')
count = 99

while(True):

    frames = pipeline.wait_for_frames()
    color_frame = frames.get_color_frame()
    color_image = np.asanyarray(color_frame.get_data())
    color_colormap_dim = color_image.shape
    images = color_image

    if count != time.strftime('%H',time.localtime(time.time())): # 시간이 바뀌면 영상파일을 새로 만든다. (시간으로 감지)

        count = time.strftime('%H',time.localtime(time.time()))
        print('시간 변경 감지')

        out = cv2.VideoWriter(time.strftime('%Y-%m-%d %H시 %M분',time.localtime(time.time()))+'.avi', codec, fc, (720,1084))
        print('파일 생성:',time.strftime('%Y-%m-%d %H시 %M분',time.localtime(time.time()))+'.avi')

    # Show images
    # cv2.namedWindow('RealSense', cv2.WINDOW_AUTOSIZE)
    cv2.imshow('Record&Save', images)
    out.write(images)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cv2.destroyAllWindows()

2. Instant NGP 실행 프로그램 다운로드

저는 그래픽카드로 RTX 3060을 사용하고 있으므로 'RTX 3000 & 4000 series, RTX A4000–A6000, and other Ampere & Ada cards' 응용 프로그램을 다운받아서 실험을 진행하였습니다.

3. 인풋 데이터 얻기

저는 COLMAP이 추정한 intrinsic parameters과 고정된 intrinsic parameters에 따라 reconstruction 결과가 달라지는지 비교하고자 두 단계를 거쳐 실험하였습니다. 단순히 추정치만으로 실험하실 분은 3.1 번의 과정을 진행하시면 됩니다.

3.1. COLMAP 추정 instrinsic parameters 사용 - Instant NGP에서 제공하는 코드 사용

NVIDIA에서는 친절하게 custom data를 활용한 Instant NGP 사용 tutorial video를 제공하고 있습니다. 아래 코드를 통해 본인의 데이터를 통해 모델에 필요한 파일 transform.json 을 얻으실 수 있습니다.

$^\textbf{1}$ Go to data path

제 경우에는 촬영한 영상을 설치한 프로그램 폴더의 data 폴더 내의 test 폴더에 위치시켰습니다. cd C:\(your path here)\Instant-NGP-for-RTX-3000-and-4000\data\test

$^\textbf{2}$ Primary data cleaning

먼저 학습 데이터로 사용할 이미지를 추출하기 위한 작업을 거칩니다. 이때, 실험적으로 --video_in 에 사용될 영상은 .mov 파일 형식일 때 잘되는 것을 확인하였습니다. python ..\scripts\colmap2nerf.py --video_in test.MOV --video_fps 2 --run_colmap --overwrite

비디오로부터 이미지를 추출하고 그 사이에서 양질의 이미지만을 고르는 과정을 거칠 것이기 때문에 "Feature extract"가 시작된다면 이미 이미지 추출은 끝났기때문에 ctrl+C를 눌러 작업을 취소합니다. (계속 진행해도 상관없습니다만 작업 속도가 오래걸릴 수 있습니다.)

이후, C:\(your path here)\Instant-NGP-for-RTX-3000-and-4000\data\test 경로에 이미지와 여러 파일이 생성되는 것을 확인할 수 있습니다.

이후 images 폴더 내의 이미지 파일을 열어 흐릿하거나 쓸모 없는 프레임을 삭제합니다. 저는 IrfanView 64라는 프로그램을 이용하여 이미지 사이즈를 조절하거나, 흐린 사진을 간편하게 삭제하였습니다.

$\scriptsize{\textcolor{gray}{\textrm{이런 이미지를 삭제하면 됩니다.}}}$

$^\textbf{3}$ Secondary data cleaning

양질의 이미지세트를 얻었다면 이 이미지들을 기반으로 camera parameters를 추정합니다. python C:\Users\(your path here)\instant-ngp\scripts\colmap2nerf.py --colmap_matcher exhaustive --run_colmap --aabb_scale 16 --overwrite

비디오 또는 밀접하게 관련된 샷 세트의 경우 이미지가 순서대로 있으므로 "--colmap_matcher"를 제거할 수 있습니다. 이렇게 하면 몇 분이 절약됩니다. 더 자세한 사항은 nerf_dataset_tips.md를 참조하세요.

코드 실행이 끝나면 폴더에 다음과 같이 파일들이 생성되는 것을 확인하실 수 있습니다. 최종적으로 transforms.json 파일을 얻어 Instant NGP의 인풋데이터인 카메라 데이터를 얻을 수 있습니다.

3.2. 고정된 intrinsic parameters 사용 - Colmap을 통해 intrinsic parameters 얻기

$^\textbf{1}$ Get intrinsic parameters

카메라가 기본적으로 가지고 있는 intrinsic parameters를 출력하였습니다.

import pyrealsense2 as rs
pipeline = rs.pipeline()
config = rs.config()

pipeline_wrapper = rs.pipeline_wrapper(pipeline)
pipeline_profile = config.resolve(pipeline_wrapper)
device = pipeline_profile.get_device()
device_product_line = str(device.get_info(rs.camera_info.product_line))

config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)

pipeline.start(config)


frames = pipeline.wait_for_frames()
color_frame = frames.get_color_frame()

intrinsics = color_frame.profile.as_video_stream_profile().intrinsics
fx, fy = intrinsics.fx, intrinsics.fy  # Focal length
cx, cy = intrinsics.ppx, intrinsics.ppy  # Principal point
coeffs = intrinsics.coeffs  # Distortion coefficients

print("Intrinsic parameters:")
print("Focal Length (fx, fy):", fx, fy)
print("Principal Point (cx, cy):", cx, cy)
print("Distortion Coefficients:", coeffs)   

pipeline.stop()

$^\textbf{2}$ Find parameters through colmap

Colmap이란 간단히 말해 SfM(Structure from Motion)과 MVS(Multi-View Stereo) 기술을 사용하여, 여러 장의 2D 이미지로부터 3D 모델을 자동으로 생성하는 오픈소스 소프트웨어입니다. 정렬된 이미지 컬렉션과 정렬되지 않은 이미지 컬렉션을 재구성하기 위한 다양한 기능을 제공합니다:

• Automatic Camera Calibration: 이미지 집합에서 카메라의 위치와 방향을 추정합니다.
• Point Cloud Generation: 이미지 집합에서 3D 포인트 클라우드를 생성합니다.
• Dense 3D Reconstruction: 생성된 포인트 클라우드를 바탕으로 더 밀도 있는 3D 모델을 생성합니다.
• Texture Mapping for 3D Models: 3D 모델에 이미지 텍스처를 매핑하여 사실적인 외관을 생성합니다.

① Create project

1. [File] - [New Project] 클릭
2. [New] - Database를 저장할 원하는 경로에 Database 파일을 생성
3. [Select] - Image들이 저장된 폴더를 지정
4. [Save] 버튼 클릭

② Feature extraction for each image

1. [Processing] - [Feature Extraction]

• custom parameters를 앞에서 구한 intel realsense의 intrinsic parameter로 설정 + Camera model은 OPENCV 로 설정

2. [Database management] - [Cameras]

• 카메라 데이터 테이블을 통해 이미지에 대한 카메라 intrinsic parameters가 잘 매칭되어 있는지 확인합니다.

③ Feature matching for each image

[Processing] - [Feature Matching]

• 특징 매칭을 위한 단계입니다.

④ Reconstruction

[Reconstruction] - [Start Reconstruction]

• reconstruction 시작 전, reconstruction options - Bundle 에서 'Camera parameters' 파트의 카메라 파라미터 refine 항목들을 uncheck합니다.

⑤ Save model

[File] - [Export model as text]

• 앞서 구한 카메라 파라미터를 Instant NGP에서 사용할 수 있는 데이터 형식으로 사용할 수 있도록, images 폴더가 있는 데이터 root 폴더에 colmap_text 폴더를 생성합니다. 그리고 이 경로(제 경우에는 C:\(your path here)\Instant-NGP-for-RTX-3000-and-4000\data\test\colmap_text)에 text로 된 model를 export합니다.

$^\textbf{3}$ Get transforms.json file

애써 구한 파라미터들이 덮어 씌워지면 안되므로 기존 코드에 있던 --run_colmap 는 지우고 코드를 실행합니다. python C:\Users\(your path here)\instant-ngp\scripts\colmap2nerf.py --aabb_scale 16 --overwrite

그러면 최종적으로 아래와 같이 tranforms.json 파일이 생성됩니다.

4. instant-ngp.exe 실행하기

앞서 설치한 instant-ngp.exe 응용 파일을 실행하시면 아래와 같이 처음에는 검은 화면으로 시작합니다. 이제 이 프로그램에 우리가 구한 인풋 데이터 images와 tranforms.json이 들어있는 폴더 채로 drag&drop 하여 넣어주면 됩니다.

Results

Reference

• COLMAP Official Documentation
• [Realsense2] 파이썬으로 realsense 프로그래밍 | 작성자 초초
• kmss1258/Colmap-setup

Swap chain은 두 개의 버퍼 front buffer와 back buffer를 사용하여 화면에 자연스럽게 이어지는 이미지를 표시하는 방법입니다. 이때, front buffer는 현재 화면에 표시되고 있는 이미지를 담고 있는 버퍼로, 사용자가 보고 있는 화면의 내용을 담고 있습니다. back buffer는 새로운 이미지가 렌더링되는 버퍼로, 화면에 보이지 않는 버퍼 메로리가 두세개로 이루어져 있으며 다음 렌더링할 새로운 프레임이 여기에 렌더링됩니다. 렌더링이 완료되면, back buffer의 내용이 front buffer로 교체됩니다. 이 과정을 'swap'이라고 합니다. swap 후, 새로운 이미지가 front buffer에 표시되어 사용자가 볼 수 있게 됩니다.

이 swap chain이 필요한 이유는 화면 갱신율과 렌더링 속도가 다를 때 발생하는 Screen Tearing 현상을 방지하기 위함입니다. 또한 사용자에게 부드러운 이미지 전환 경험을 제공합니다. 이미지가 렌더링되는 동안 사용자는 오래된 프레임을 보게 되므로, 렌더링 과정에서 발생할 수 있는 끊김이나 지연 현상을 줄일 수 있습니다. DirectX에서의 swap chain은 DXGI에 포함되어 있습니다.

• [WIKIPEDIA] Swap chain

Data preprocessing

align_face.py : 이미지를 다운로드하고, 얼굴을 정렬한 후, 정렬된 얼굴 이미지를 저장

cache_dir = Path(args.cache_dir)
cache_dir.mkdir(parents=True, exist_ok=True)

output_dir = Path(args.output_dir)
output_dir.mkdir(parents=True,exist_ok=True)

print("Downloading Shape Predictor")
f=open_url("https://drive.google.com/uc?id=1huhv8PYpNNKbGCLOaYUjOgR1pY5pmbJx", cache_dir=cache_dir, return_path=True)
predictor = dlib.shape_predictor(f)

for im in Path(args.unprocessed_dir).glob("*.*"):
    faces = align_face(str(im),predictor)

    for i,face in enumerate(faces):
        if(args.output_size):
            factor = 1024//args.output_size
            assert args.output_size*factor == 1024
            face_tensor = torchvision.transforms.ToTensor()(face).unsqueeze(0).cuda()
            face_tensor_lr = face_tensor[0].cpu().detach().clamp(0, 1)
            face = torchvision.transforms.ToPILImage()(face_tensor_lr)
            if factor != 1:
                face = face.resize((args.output_size, args.output_size), PIL.Image.LANCZOS)
        if len(faces) > 1:
            face.save(Path(args.output_dir) / (im.stem+f"_{i}.png"))
        else:
            face.save(Path(args.output_dir) / (im.stem + f".png"))

• align_face : 얼굴 정렬을 수행하는 함수로, 얼굴의 특징점(landmarks)을 찾아서 얼굴이 중심에 오도록 이미지를 재조정. 이 함수는 입력으로 이미지 파일 경로(filepath)와 얼굴의 랜드마크를 찾는데 사용되는 모델(predictor)을 통해 정렬된 얼굴 이미지를 반환.

Main

main.py : ① Embedding ② Alignment ③ Blending

from models.Embedding import Embedding
from models.Alignment import Alignment
from models.Blending import Blending

def main(args):
    # ① Embedding
    ii2s = Embedding(args)

    im_path1 = os.path.join(args.input_dir, args.im_path1)
    im_path2 = os.path.join(args.input_dir, args.im_path2)
    im_path3 = os.path.join(args.input_dir, args.im_path3)

    im_set = {im_path1, im_path2, im_path3}
    ii2s.invert_images_in_W([*im_set])
    ii2s.invert_images_in_FS([*im_set])

    # ② Alignment
    align = Alignment(args)
    align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth)
    if im_path2 != im_path3:
        align.align_images(im_path1, im_path3, sign=args.sign, align_more_region=False, smooth=args.smooth, save_intermediate=False)

    # ③ Blending
    blend = Blending(args)
    blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign)

① Embedding

Embedding.py ii2s = Embedding(args)

class Embedding(nn.Module):

    def __init__(self, opts):
        super(Embedding, self).__init__()
        self.opts = opts
        self.net = Net(self.opts)
        self.load_downsampling()
        self.setup_embedding_loss_builder()


    def load_downsampling(self):
        factor = self.opts.size // 256
        self.downsample = BicubicDownSample(factor=factor)

    def setup_embedding_loss_builder(self):
        self.loss_builder = EmbeddingLossBuilder(self.opts)

ii2s.invert_images_in_W([*im_set])

    def invert_images_in_W(self, image_path=None):
        self.setup_dataloader(image_path=image_path)
        device = self.opts.device
        ibar = tqdm(self.dataloader, desc='Images')
        for ref_im_H, ref_im_L, ref_name in ibar:
            optimizer_W, latent = self.setup_W_optimizer()
            pbar = tqdm(range(self.opts.W_steps), desc='Embedding', leave=False)
            for step in pbar:
                optimizer_W.zero_grad()
                latent_in = torch.stack(latent).unsqueeze(0)

                gen_im, _ = self.net.generator([latent_in], input_is_latent=True, return_latents=False)
                im_dict = {
                    'ref_im_H': ref_im_H.to(device),
                    'ref_im_L': ref_im_L.to(device),
                    'gen_im_H': gen_im,
                    'gen_im_L': self.downsample(gen_im)
                }

                loss, loss_dic = self.cal_loss(im_dict, latent_in)
                loss.backward()
                optimizer_W.step()

                if self.opts.verbose:
                    pbar.set_description('Embedding: Loss: {:.3f}, L2 loss: {:.3f}, Perceptual loss: {:.3f}, P-norm loss: {:.3f}'
                                         .format(loss, loss_dic['l2'], loss_dic['percep'], loss_dic['p-norm']))

                if self.opts.save_intermediate and step % self.opts.save_interval== 0:
                    self.save_W_intermediate_results(ref_name, gen_im, latent_in, step)

            self.save_W_results(ref_name, gen_im, latent_in)

ii2s.invert_images_in_FS([*im_set])

    def invert_images_in_FS(self, image_path=None):
        self.setup_dataloader(image_path=image_path)
        output_dir = self.opts.output_dir
        device = self.opts.device
        ibar = tqdm(self.dataloader, desc='Images')
        for ref_im_H, ref_im_L, ref_name in ibar:

            latent_W_path = os.path.join(output_dir, 'W+', f'{ref_name[0]}.npy')
            latent_W = torch.from_numpy(convert_npy_code(np.load(latent_W_path))).to(device)
            F_init, _ = self.net.generator([latent_W], input_is_latent=True, return_latents=False, start_layer=0, end_layer=3)
            optimizer_FS, latent_F, latent_S = self.setup_FS_optimizer(latent_W, F_init)


            pbar = tqdm(range(self.opts.FS_steps), desc='Embedding', leave=False)
            for step in pbar:

                optimizer_FS.zero_grad()
                latent_in = torch.stack(latent_S).unsqueeze(0)
                gen_im, _ = self.net.generator([latent_in], input_is_latent=True, return_latents=False,
                                               start_layer=4, end_layer=8, layer_in=latent_F)
                im_dict = {
                    'ref_im_H': ref_im_H.to(device),
                    'ref_im_L': ref_im_L.to(device),
                    'gen_im_H': gen_im,
                    'gen_im_L': self.downsample(gen_im)
                }

                loss, loss_dic = self.cal_loss(im_dict, latent_in)
                loss.backward()
                optimizer_FS.step()

                if self.opts.verbose:
                    pbar.set_description(
                        'Embedding: Loss: {:.3f}, L2 loss: {:.3f}, Perceptual loss: {:.3f}, P-norm loss: {:.3f}, L_F loss: {:.3f}'
                        .format(loss, loss_dic['l2'], loss_dic['percep'], loss_dic['p-norm'], loss_dic['l_F']))

            self.save_FS_results(ref_name, gen_im, latent_in, latent_F)

② Alignment

Alignment.py align = Alignment(args)

class Alignment(nn.Module):

    def __init__(self, opts, net=None):
        super(Alignment, self).__init__()
        self.opts = opts
        if not net:
            self.net = Net(self.opts)
        else:
            self.net = net

        self.load_segmentation_network()
        self.load_downsampling()
        self.setup_align_loss_builder()

    def load_segmentation_network(self):
        self.seg = BiSeNet(n_classes=16)
        self.seg.to(self.opts.device)

        if not os.path.exists(self.opts.seg_ckpt):
            download_weight(self.opts.seg_ckpt)
        self.seg.load_state_dict(torch.load(self.opts.seg_ckpt))
        for param in self.seg.parameters():
            param.requires_grad = False
        self.seg.eval()

    def load_downsampling(self):

        self.downsample = BicubicDownSample(factor=self.opts.size // 512)
        self.downsample_256 = BicubicDownSample(factor=self.opts.size // 256)

    def setup_align_loss_builder(self):
        self.loss_builder = AlignLossBuilder(self.opts)

align.align_images(im_path1, im_path2, sign=args.sign, align_more_region=False, smooth=args.smooth) : 두 이미지의 특성을 반영하여 최적의 정렬을 수행

    def align_images(self, img_path1, img_path2, sign='realistic', align_more_region=False, smooth=5,
                     save_intermediate=True):

        ################## img_path1: Identity Image
        ################## img_path2: Structure Image

        device = self.opts.device
        output_dir = self.opts.output_dir
        target_mask, hair_mask_target, hair_mask1, hair_mask2 = \
            self.create_target_segmentation_mask(img_path1=img_path1, img_path2=img_path2, sign=sign,
                                                 save_intermediate=save_intermediate)

        im_name_1 = os.path.splitext(os.path.basename(img_path1))[0]
        im_name_2 = os.path.splitext(os.path.basename(img_path2))[0]

        latent_FS_path_1 = os.path.join(output_dir, 'FS', f'{im_name_1}.npz')
        latent_FS_path_2 = os.path.join(output_dir, 'FS', f'{im_name_2}.npz')

        latent_1, latent_F_1 = load_FS_latent(latent_FS_path_1, device)
        latent_2, latent_F_2 = load_FS_latent(latent_FS_path_2, device)

        latent_W_path_1 = os.path.join(output_dir, 'W+', f'{im_name_1}.npy')
        latent_W_path_2 = os.path.join(output_dir, 'W+', f'{im_name_2}.npy')

• save_intermediate : 중간 결과를 저장할 것인지를 결정
• create_target_segmentation_mask : 이미지의 특정 영역을 추출하는 데 사용되는 대상 세그멘테이션 마스크를 생성
• load_FS_latent : 이미지의 특성을 불러옴

첫 번째 정렬 단계

        optimizer_align, latent_align_1 = self.setup_align_optimizer(latent_W_path_1)

        pbar = tqdm(range(self.opts.align_steps1), desc='Align Step 1', leave=False)
        for step in pbar:
            optimizer_align.zero_grad()
            latent_in = torch.cat([latent_align_1[:, :6, :], latent_1[:, 6:, :]], dim=1)
            down_seg, _ = self.create_down_seg(latent_in)

            loss_dict = {}
            ##### Cross Entropy Loss
            ce_loss = self.loss_builder.cross_entropy_loss(down_seg, target_mask)
            loss_dict["ce_loss"] = ce_loss.item()
            loss = ce_loss

            loss.backward()
            optimizer_align.step()

        intermediate_align, _ = self.net.generator([latent_in], input_is_latent=True, return_latents=False,
                                                   start_layer=0, end_layer=3)
        intermediate_align = intermediate_align.clone().detach()

• setup_align_optimizer : 이미지 정렬을 위한 최적화기와 정렬 대상 이미지의 특성을 설정
• create_down_seg : 주어진 latent code를 이용하여 이미지를 생성하고, 생성된 이미지의 세그멘테이션을 생성하는 과정을 수행

두 번째 정렬 단계

        optimizer_align, latent_align_2 = self.setup_align_optimizer(latent_W_path_2)

        with torch.no_grad():
            tmp_latent_in = torch.cat([latent_align_2[:, :6, :], latent_2[:, 6:, :]], dim=1)
            down_seg_tmp, I_Structure_Style_changed = self.create_down_seg(tmp_latent_in)

            current_mask_tmp = torch.argmax(down_seg_tmp, dim=1).long()
            HM_Structure = torch.where(current_mask_tmp == 10, torch.ones_like(current_mask_tmp),
                                       torch.zeros_like(current_mask_tmp))
            HM_Structure = F.interpolate(HM_Structure.float().unsqueeze(0), size=(256, 256), mode='nearest')

        pbar = tqdm(range(self.opts.align_steps2), desc='Align Step 2', leave=False)
        for step in pbar:
            optimizer_align.zero_grad()
            latent_in = torch.cat([latent_align_2[:, :6, :], latent_2[:, 6:, :]], dim=1)
            down_seg, gen_im = self.create_down_seg(latent_in)

            Current_Mask = torch.argmax(down_seg, dim=1).long()
            HM_G_512 = torch.where(Current_Mask == 10, torch.ones_like(Current_Mask),
                                   torch.zeros_like(Current_Mask)).float().unsqueeze(0)
            HM_G = F.interpolate(HM_G_512, size=(256, 256), mode='nearest')

            loss_dict = {}

            ########## Segmentation Loss
            ce_loss = self.loss_builder.cross_entropy_loss(down_seg, target_mask)
            loss_dict["ce_loss"] = ce_loss.item()
            loss = ce_loss

            #### Style Loss
            H1_region = self.downsample_256(I_Structure_Style_changed) * HM_Structure
            H2_region = self.downsample_256(gen_im) * HM_G
            style_loss = self.loss_builder.style_loss(H1_region, H2_region, mask1=HM_Structure, mask2=HM_G)

            loss_dict["style_loss"] = style_loss.item()
            loss += style_loss

            loss.backward()
            optimizer_align.step()

        latent_F_out_new, _ = self.net.generator([latent_in], input_is_latent=True, return_latents=False,
                                                 start_layer=0, end_layer=3)
        latent_F_out_new = latent_F_out_new.clone().detach()

마지막 정렬 단계

: 특정 영역에 대한 마스크(원래 이미지와 목표 이미지의 특정 영역)를 생성하고, 두 이미지의 latent code를 섞음. 이 과정을 두번 반복하여 최종적으로 두 이미지가 섞인 latent code로 결합하여 최종 이미지를 생성하고 이를 저장.

        free_mask = 1 - (1 - hair_mask1.unsqueeze(0)) * (1 - hair_mask_target)

        ##############################
        free_mask, _ = self.dilate_erosion(free_mask, device, dilate_erosion=smooth)
        ##############################

        free_mask_down_32 = F.interpolate(free_mask.float(), size=(32, 32), mode='bicubic')[0]
        interpolation_low = 1 - free_mask_down_32


        latent_F_mixed = intermediate_align + interpolation_low.unsqueeze(0) * (
                latent_F_1 - intermediate_align)

        if not align_more_region:
            free_mask = hair_mask_target
            ##########################
            _, free_mask = self.dilate_erosion(free_mask, device, dilate_erosion=smooth)
            ##########################
            free_mask_down_32 = F.interpolate(free_mask.float(), size=(32, 32), mode='bicubic')[0]
            interpolation_low = 1 - free_mask_down_32


        latent_F_mixed = latent_F_out_new + interpolation_low.unsqueeze(0) * (
                latent_F_mixed - latent_F_out_new)

        free_mask = F.interpolate((hair_mask2.unsqueeze(0) * hair_mask_target).float(), size=(256, 256), mode='nearest').cuda()
        ##########################
        _, free_mask = self.dilate_erosion(free_mask, device, dilate_erosion=smooth)
        ##########################
        free_mask_down_32 = F.interpolate(free_mask.float(), size=(32, 32), mode='bicubic')[0]
        interpolation_low = 1 - free_mask_down_32

        latent_F_mixed = latent_F_2 + interpolation_low.unsqueeze(0) * (
                latent_F_mixed - latent_F_2)

        gen_im, _ = self.net.generator([latent_1], input_is_latent=True, return_latents=False, start_layer=4,
                                       end_layer=8, layer_in=latent_F_mixed)
        self.save_align_results(im_name_1, im_name_2, sign, gen_im, latent_1, latent_F_mixed,
                                save_intermediate=save_intermediate)

• dilate_erosion : 마스크의 크기를 조절하고 마스크를 부드럽게 만드는 함수
• save_align_results : 생성된 특성을 이용하여 최종 이미지를 생성하고, 이를 저장

③ Blending

Blending.py blend = Blending(args)

class Blending(nn.Module):

    def __init__(self, opts, net=None):
        super(Blending, self).__init__()
        self.opts = opts
        if not net:
            self.net = Net(self.opts)
        else:
            self.net = net

        self.load_segmentation_network()
        self.load_downsampling()
        self.setup_blend_loss_builder()


    def load_segmentation_network(self):
        self.seg = BiSeNet(n_classes=16)
        self.seg.to(self.opts.device)

        if not os.path.exists(self.opts.seg_ckpt):
            download_weight(self.opts.seg_ckpt)
        self.seg.load_state_dict(torch.load(self.opts.seg_ckpt))
        for param in self.seg.parameters():
            param.requires_grad = False
        self.seg.eval()

    def load_downsampling(self):
        self.downsample = BicubicDownSample(factor=self.opts.size // 512)
        self.downsample_256 = BicubicDownSample(factor=self.opts.size // 256)

    def setup_blend_loss_builder(self):
        self.loss_builder = BlendLossBuilder(self.opts)

blend.blend_images(im_path1, im_path2, im_path3, sign=args.sign) : 두 이미지의 특성을 합성하고, 세 번째 이미지의 특성을 더하는 블렌딩 함수

    def blend_images(self, img_path1, img_path2, img_path3, sign='realistic'):

        device = self.opts.device
        output_dir = self.opts.output_dir

        im_name_1 = os.path.splitext(os.path.basename(img_path1))[0]
        im_name_2 = os.path.splitext(os.path.basename(img_path2))[0]
        im_name_3 = os.path.splitext(os.path.basename(img_path3))[0]

        I_1 = load_image(img_path1, downsample=True).to(device).unsqueeze(0)
        I_3 = load_image(img_path3, downsample=True).to(device).unsqueeze(0)

        HM_1D, _ = cuda_unsqueeze(dilate_erosion_mask_path(img_path1, self.seg), device)
        HM_3D, HM_3E = cuda_unsqueeze(dilate_erosion_mask_path(img_path3, self.seg), device)

        opt_blend, interpolation_latent = self.setup_blend_optimizer()
        latent_1, latent_F_mixed = load_FS_latent(os.path.join(output_dir, 'Align_{}'.format(sign),
                                            '{}_{}.npz'.format(im_name_1, im_name_3)),device)
        latent_3, _ = load_FS_latent(os.path.join(output_dir, 'FS',
                                            '{}.npz'.format(im_name_3)), device)

        with torch.no_grad():
            I_X, _ = self.net.generator([latent_1], input_is_latent=True, return_latents=False, start_layer=4,
                               end_layer=8, layer_in=latent_F_mixed)
            I_X_0_1 = (I_X + 1) / 2
            IM = (self.downsample(I_X_0_1) - seg_mean) / seg_std
            down_seg, _, _ = self.seg(IM)
            current_mask = torch.argmax(down_seg, dim=1).long().cpu().float()
            HM_X = torch.where(current_mask == 10, torch.ones_like(current_mask), torch.zeros_like(current_mask))
            HM_X = F.interpolate(HM_X.unsqueeze(0), size=(256, 256), mode='nearest').squeeze()
            HM_XD, _ = cuda_unsqueeze(dilate_erosion_mask_tensor(HM_X), device)
            target_mask = (1 - HM_1D) * (1 - HM_3D) * (1 - HM_XD)


        pbar = tqdm(range(self.opts.blend_steps), desc='Blend', leave=False)
        for step in pbar:

            opt_blend.zero_grad()

            latent_mixed = latent_1 + interpolation_latent.unsqueeze(0) * (latent_3 - latent_1)

            I_G, _ = self.net.generator([latent_mixed], input_is_latent=True, return_latents=False, start_layer=4,
                               end_layer=8, layer_in=latent_F_mixed)
            I_G_0_1 = (I_G + 1) / 2

            im_dict = {
                'gen_im': self.downsample_256(I_G),
                'im_1': I_1,
                'im_3': I_3,
                'mask_face': target_mask,
                'mask_hair': HM_3E
            }
            loss, loss_dic = self.loss_builder(**im_dict)

            loss.backward()
            opt_blend.step()

        ############## Load F code from  '{}_{}.npz'.format(im_name_1, im_name_2)
        _, latent_F_mixed = load_FS_latent(os.path.join(output_dir, 'Align_{}'.format(sign),
                                                        '{}_{}.npz'.format(im_name_1, im_name_2)), device)
        I_G, _ = self.net.generator([latent_mixed], input_is_latent=True, return_latents=False, start_layer=4,
                           end_layer=8, layer_in=latent_F_mixed)

        self.save_blend_results(im_name_1, im_name_2, im_name_3, sign, I_G, latent_mixed, latent_F_mixed)

처음에 빌드 에러를 마주하면 당혹스럽기 그지없습니다. 엎친 데 덮친 격으로 잘만 열리던 프로젝트도 열리지 않습니다..!! 이때 당황하지 마시고 하나하나 해결해봅시다. 언젠가 프로젝트는 열릴 것입니다.

Error 1

Unable to build while is active. Exit the editor and game, or press Ctrl+Alt+F11 if iterating on code in the editor or game

Solution

*1) *언리얼 엔진 에디터를 끄고 Visual studio 만 켠 채로 솔루션 빌드를 하거나 *2) *live coding을 끄는 방법이 있습니다.

live coding Ctrl + Alt + F11은 언리얼 엔진5 에디터에서 컴파일 역할을 하는 기능입니다.

참고

• https://docs.unrealengine.com/5.3/ko/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine/
• https://daekyoulibrary.tistory.com/entry/UE5-Unable-to-build-while-Live-Coding-is-active-Exit-the-editor-and-game-or-press-CtrlAltF11-if-iterating-on-code-in-the-editor-or-game-%EC%98%A4%EB%A5%98

Packaging (Windows): Platform Win64 is not a valid platform to build. Check that the SDK is installed properly.

UATHelper: Packaging (Windows): Platform Win64 is not a valid platform to build. Check that the SDK is installed properly.
UATHelper: Packaging (Windows): Took 0.8534231999999999s to run dotnet.exe, ExitCode=6
UATHelper: Packaging (Windows): UnrealBuildTool failed. See log for more details. (C:\Users\figster\AppData\Roaming\Unreal Engine\AutomationTool\Logs\C+Program+Files+Epic+Games+UE_5.1\UBT-MyProject2-Win64-Development.txt)
UATHelper: Packaging (Windows): AutomationTool executed for 0h 0m 3s
UATHelper: Packaging (Windows): AutomationTool exiting with ExitCode=6 (6)
UATHelper: Packaging (Windows): BUILD FAILED
PackagingResults: Error: Unknown Error

Visual stdio에서 Workloads가 제대로 설치되지 않았을 때 발생하는 에러입니다.

Solution

언리얼 엔진은 Visual Studio와 통합되어 설계되었기에 visual studio의 환경이 적절히 구성되어야 합니다. VS를 사용한 언리얼 엔진 개발 시 다음의 Visual Studio Workloads 옵션을 설치해야 합니다.

• .NET desktop development
• Desktop development with C++
• Universal Windows Platform development
• Game development with C++
  • 추가로 우측의 Unreal Engine 관련 요소를 설치해주어야 원활한 개발 환경을 구성할 수 있습니다.

참고

• https://docs.unrealengine.com/5.3/ko/setting-up-visual-studio-development-environment-for-cplusplus-projects-in-unreal-engine/

Distance Field

언리얼 엔진은 Distance Field를 활용하여 Static Mesh Actor를 위한 dynamic ambient occlusion 및 그림자 기능을 제공합니다. 이 외에도, Actor의 Mesh Distance Field representation은 GPU particle collision이나 동적 흐름 맵을 만드는 Material Editor와 함께 사용될 수 있습니다.

Signed Distance Field

Static Mesh의 표면을 나타내기 위해서 Signed Distance Field (SDF)가 사용됩니다. Signed Distance Field란 위치를 입력으로 받아 해당 위치에서 object의 가장 가까운 부분까지의 거리를 출력하는 함수를 이용해 object를 나타내는 방식입니다. UE에서 이는 volume texture에 가장 가까운 표면까지의 거리를 저장하여 작동합니다. Mesh 외부의 모든 점은 양의 거리로 간주되고 메쉬 내부의 모든 점은 음의 거리로 저장합니다.

Signed Distance Field가 픽셀에서 어떻게 보이는지에 대한 예

Mesh Distance Field

Level에 배치된 Actor는 모두 Mesh Distance Field로 구성됩니다. Mesh Distance Field가 생성될 때 결과를 volume texture에 저장하는 triangle raytracing을 사용하여 "오프라인"으로 생성됩니다. 이 때문에 Mesh Distance Field 생성은 런타임에 수행할 수 없습니다. 이 방법은 모든 방향에서 Signed Distance Field 광선을 계산하여 가장 가까운 표면을 찾고 해당 정보를 저장합니다.

회색보다 흰색에 가까운 영역이 표시되면 메쉬 표면의 교차점을 찾는 데 많은 단계가 필요했음을 의미합니다. 표면에 대한 grazing angle(스침각: 입사 광선과 반사 표면 사이의 각도)의 광선은 단순한 메시보다 교차하는 데 훨씬 더 많은 단계를 거칩니다.

Grazing Angle

Enabling Mesh Distance Field

Mesh Distance Field를 활성화하기 위해서는 [Edit] - [Project Settings] - [Rendering] - [Lighting] - [Generate Mesh Distance Fields]를 체크합니다.

Visualize Mesh Distance Field

뷰포트에서 전역 거리 필드를 시각화기 위해서는 [Show] - [Visualize] - [Mesh Distance Field]를 체크합니다.

단일 메시가 가질 수 있는 최대 볼륨 텍스처 크기는 128x128x128 해상도에서 8MB입니다.

Global Distance Field

Global Distance Field는 해당 Level에서 카메라를 따라 Signed Distance Field occlusion을 사용하는 low-resolution Distance Field입니다. 이는 object 별 Mesh Distance Field의 캐시를 생성하고 카메라를 중심으로한 몇 개의 볼륨 텍스처인 clipmap으로 합성합니다. 새로 보이는 영역이나 장면 수정의 영향을 받는 영역만 업데이트하면 되기 때문에 구성 비용이 많이 들지 않습니다.

Visualize Global Distance Field

뷰포트에서 전역 거리 필드를 시각화기 위해서는 [Show] - [Visualize] - [Global Distance Field]를 체크합니다.

참고

• https://docs.unrealengine.com/4.27/en-US/BuildingWorlds/LightingAndShadows/MeshDistanceFields/
• http://bytewrangler.blogspot.com/2011/10/signed-distance-fields.html
• https://www.mathworks.com/help/radar/ref/grazingang.html

Upper Body Ik Plugin이 현재 5.3에서 오류가 발생합니다. 깃허브의 풀리퀘스트를 참고하여 수정한 코드는 아래 링크에서 다운받을 수 있습니다.

• UpperBody-IK-Plugin

Using UpperBody IK plugin

플러그인 import

1. [프로젝트 폴더]에 [Plugins]라고 하는 폴더를 생성
2. 플러그인 폴더 [UBIKSolver-main] 드래그 & 드랍
3. 프로젝트 실행하고 rebuild
   • 플러그인이 잘 임포트되면 위처럼 플러그인 창에 나타남

Blueprint

Animation Blueprint 생성

1. Animation blueprint를 'SK_Mannequin_Skeleton'로 생성
2. [AnimationBlueprint] - [AnimGraph]
3. [AnimationBlueprint] - [Event Graph]

VRPwan 수정

1. 스켈레탈 메시 추가하고 Animation blueprint로 지정했던 스켈레톤을 가진 스켈레탈 메시로 변경
2. [skeletal mesh] - [Animation] - [Animation Mode] 는 'Use AnimationBlueprint'로, [Anim Class] 는 위에서 생성한 Animation blueprint로 설정
3. [Event Graph] 에 'Event Tick' 이벤트 추가하여 아래 이미지 노드를 추가

Results

기존 언리얼 엔진 5의 VR pawn에 매핑되어 있는 애니메이션을 리타겟팅하여 upper body 스켈레탈 메시의 손가락 애니메이션을 제어하였습니다.

참고

• https://www.youtube.com/watch?v=6Xiq6w9mJaI

Animation Retargeting

가상 3d world에서 손을 뻗는 자세를 취하고 있는 캐릭터와 같은 동작을 옆 캐릭터에게 시키려면 어떻게 해야할까요? 단순히 같은 애니메이션을 적용시키면 되지 않을까 하고 생각할 수 있습니다.

애니메이션을 적용한다는 것은 joint 를 제어한다는 것과 같습니다. 실제 사람의 뼈처럼 캐릭터에는 가상 뼈가 존재합니다. 이 가상 뼈 즉, bone의 사이사이는 회전을 제어할 수 있는 joint가 존재하며, 이 joint의 회전을 통해 뼈의 움직임을 조작할 수 있습니다.

이미지에서 볼 수 있듯 어깨로부터 팔꿈치, 팔꿈치로부터 손목처럼 가상 뼈는 parent-child 관계로 계층적으로 이루어져 있습니다. 이를 통해 우측 이미지와 같이 어깨를 회전하면 아래 자식 뼈들도 함께 회전하게 됩니다. 이런 식으로 joint의 변형을 통해 애니메이션을 동작할 수 있습니다.

리타겟팅이 필요한 이유

그러면 이 가상 뼈를 통한 애니메이션 적용을 상상해봅시다. 아래와 같이 애니메이션을 공유고자 하는 캐릭터가 표준 캐릭터, 작고 다부진 캐릭터, 크고 홀쭉한 캐릭터로 세 버전이 있다고 가정해 봅시다. 세 캐릭터가 총을 들고 전진하고 있는 모습을 취한다고 하면 대충 어떤 식으로 자세를 잡을지 상상할 수 있습니다.

리타겟팅을 적용하지 않은 스켈레톤 에셋을 사용할 경우

만약 표준 캐릭터의 애니메이션을 그대로 다른 두 캐릭터에 적용한다면 다음과 같은 모습으로 적용됩니다. 머릿 속으로 상상했던 모습과 달리 원치않은 변형이 일어난 것처럼 보입니다.

애니메이션 리타겟팅은 이런 기존의 어떤 캐릭터로부터 다른 캐릭터에 동일한 애니메이션을 재생하려는 시도로부터 시작합니다. 이런 불필요한 변형을 방지하기 위해 리타겟팅을 사용하는 것입니다. 애니메이션 리타겟팅은 스켈레톤, 즉 가상 뼈대를 사용하는 캐릭터 간에 애니메이션을 공유할 수 있도록 해주는 기능입니다.

리타겟팅을 적용한 스켈레톤 에셋을 사용할 경우

캐릭터에 리타기팅을 적용한 결과, 방정식을 통해 비율 차이를 계산하여 캐릭터에 애니메이션이 제대로 적용된 것을 확인할 수 있습니다. 살색 표시는 원래 스켈레톤을, 흰색은 현재 스켈레톤으로 두 리타겟팅 전 스켈레톤과의 차이를 확인할 수 있습니다. 표준 캐릭터는 리타기팅되지 않은 bone과 스켈레톤에 완벽히 일치하는 것으로 보입니다. 이렇게 리타겟팅을 사용하면, 캐릭터 사이에 애니메이션 애셋을 공유하여 애니메이션을 완전히 새로 만들 필요가 없어져 메모리를 효율적으로 사용할 수 있습니다.

Animation retargeing in Unreal Engine

캐릭터들은 크기, 비율, 모양이 제각각이기 때문에 캐릭터마다 본 개수, 본 이름, 오리엔테이션 등의 다양한 유형의 뼈를 가집니다. 따라서 언리얼 엔진에서는 하나의 캐릭터에서 다른 캐릭터로 애니메이션을 리타기팅하는 유연한 툴을 제공합니다. 이러한 방법 중 하나가 바로 IK Rig 및 IK Retargeter를 함께 사용하는 것입니다. 이를 사용하면 스켈레톤 계층구조 및 비율이 현저히 차이나는 캐릭터들을 리타기팅할 수 있습니다.

IK Rig를 사용하여 다양한 스켈레탈 메시 간에 애니메이션을 공유하는 IK Retargeter를 구성할 수 있습니다. 서로 다른 스켈레톤은 각기 다른 bone 개수, bone 이름, orientation 등으로 정의되어 있는데 이는 IK rig을 통해 제어할 수 있습니다. 예를 들어 서로 다른 캐릭터의 팔을 구성하고 있는 bone이 각각 3개, 5개로 구성되어 있는 상황을 가정해봅시다. 조인트와 본의 개수가 달라 1대 1로 바로 매핑시킬 수 없는 상황에 IK Rig은 이를 리타겟 체인을 통해 매핑합니다.

팔을 조인트와 본으로 구성된 스켈레톤이 아닌 조인트 체인으로 정의하여 매우 차이가 큰 본 구조체를 가진 캐릭터들을 한층 유연하게 리타기팅할 수 있습니다. 리타기팅할 모든 주요 팔다리에 대해 체인을 생성해야 합니다.

Start Retargeting

Same skeleton asset

Different skeleton asset

Import another skeletal mesh

1. Using Unreal engine market place

2. Using Mixamo

• https://www.mixamo.com/#/

Initializing IK Rig

1. [Content] - [Animation] 폴더 생성
2. 우클릭 - [Animation] - [Retargeting] - [IK Rig] 선택하고 ‘IK_UECharater’ IK Rig 생성
3. ‘IK_UECharater’ IK Rig 선택하고 [Preview Skeletal Mesh]를 ‘SKM_Quinn_Simple’로 설정
4. 위와 똑같은 과정을 리타겟팅할 스켈레탈 메쉬에도 적용

Initializing IK Retargeter

1. 우클릭 - [Animation] - [Retargeting] - [IK Retargeter] 선택하고 ‘RT_UE2Shinbi’ IK Retargeter 생성
2. ‘RT_UE2Shinbi’ IK Retargeter 선택하고 [Source IKRig Asset]을 기존 애니메이션이 있는 ‘IK_UECharacter’로, [Target IKRig Asset]을 애니메이션을 적용할 ‘IK_Shinbi’로 설정

Setting IK Rig

Setting IK Retargeter

1. 우측 Chain Mappings의 Source Chain을 설정한 solver로 각각 매핑
2. Asset Browser의 애니메이션을 실행하면 똑같이 동작하는 것을 확인

Export retargeted animaion

리타겟팅된 애니메이션을 내보낼 수 있습니다.

Runtime IK Retargeting

1. 애니메이션 블루프린트를 만들고, 타겟 스켈레톤을 선택
2. ‘Retarget Pose From Mesh’ 노드를 추가하여 IK Retargeter 선택
3. 소스 캐릭터가 숨겨진 상황에서는 비저빌리티 기반 애님 틱 옵션(Visibility Based Anim Tick Option) 을 최적화(Optimizations) 카테고리의 항상 포즈 틱 및 본 새로고침(Always Tick Pose and Refresh Bones) 으로 설정해야 합니다.

참고

• https://medium.com/@nvidiaomniverse/what-is-animation-retargeting-4aadab383032
• https://docs.unrealengine.com/5.3/ko/animation-retargeting-in-unreal-engine/
• https://devjino.tistory.com/276
• https://www.youtube.com/watch?v=xvHOamXuZDI