파이팅웨이

SpringBoot 게시판 만들기-2. 댓글 기능 구현

코오오 코오 — Wed, 6 Mar 2024 00:56:53 +0900

미리 만들어둔 뷰

댓글 기능을 하려면?

1. 도메인 작성

2. 리포지토리 작성

3. 서비스 메서드 작성

4. 컨트롤러 작성

5. 뷰 작성

1. 도메인 작성

댓글 기능에 필요한 건?

1-1. 댓글 id

1-2. 댓글 내용

1-3. 댓글 생성 시간

1-4. 댓글 수정 시간

1-5. 댓글 작성자

1-6. 댓글이 달린 게시글 표시(댓글과 게시글은 다대일 관계이다.)

위 내용을 바탕으로 comment 엔티티를 설계해준다.

comment.java

@Builder
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Table(name = "comments")
@Entity
public class Comment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(columnDefinition = "TEXT", nullable = false)
    private String comment;

    @Column(name = "created_date")
    @CreatedDate
    private LocalDateTime createdDate;

    @Column(name = "modified_date")
    @LastModifiedDate
    private LocalDateTime modifiedDate;

    @ManyToOne
    @JoinColumn(name = "article_id")
    private Article article;

    @ManyToOne
    @JoinColumn(name = "user_id")
    private User user; // 작성자

    //댓글 수정
    public void update(String comment) {
        this.comment = comment;
    }
}

이미 작성해 둔 Article 엔티티에도, 댓글을 추가해준다.

Article.java

@Entity
@Getter//모든필드에 대한 접근자 메서드 생성
@NoArgsConstructor(access = AccessLevel.PROTECTED)//기본 생성자 생성
public class Article {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name="id",updatable = false)
    private Long id;

    @Column(name="title",nullable = false)
    private String title;

    @Column(name="content",nullable = false)
    private String content;
    @Column(name="author",nullable = false)
    private String author;


    @Builder
    public Article(String author,String title,String content,String comment){
        this.author=author;
        this.title=title;
        this.content=content;
    }
    public void update(String title,String content){
        this.title=title;
        this.content=content;
    }
    @CreatedDate//엔티티가 생성될 때 생성 시간 저장
    @Column(name="created_at")
    private LocalDateTime createdAt;

    @LastModifiedDate//엔티티가 수정될 때 수정 시간 저장
    @Column(name="updated_at")
    private LocalDateTime updatedAt;

    @OneToMany(mappedBy = "article", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE)
    @OrderBy("id asc") // 댓글 정렬
    private List<Comment> comments;
}

@OneToMany 애너테이션은 일대다 관계를 나타낸다. 게시글 하나에 여러 댓글이 달릴 수 있음.

mappedBy 속성을 통해 article 필드가 관계의 주인으로 매핑됨을 나타낸다.

FetchType.EAGER는 연관된 엔티티를 즉시 로딩하는 전략.

CascadeType.REMOVE가 지정되어 있어, 부모 엔티티가 삭제될 때 관련된 모든 자식 엔티티도 함께 삭제된다.

2. 리포지토리 작성

public interface CommentRepository extends JpaRepository<Comment,Long> {
}

여기까지가 엔티티를 구성하는 과정.

다음으로는 API 를 구현한다.

3. 서비스 메서드 작성

3-1. dto 작성

서비스 계층에서 요청을 받을 객체 생성

AddCommentRequest.java

@NoArgsConstructor
@AllArgsConstructor
@Getter
public class AddCommentRequest {
    private Long id;
    private String comment;
    private String createdDate = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm"));
    private String modifiedDate = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy.MM.dd HH:mm"));
    private String user;
    private int article;

    public Comment toEntity() {//생성자를 사용해 객체 생성
        return Comment.builder()
                .comment(comment)
                .createdDate(createdDate)
                .modifiedDate(modifiedDate)
                .user(user)
                .article(article)
                .build();
    }
}

3-2. 서비스 메서드 작성

CommentService.java

@RequiredArgsConstructor
@Service
public class CommentService {

    private final CommentRepository commentRepository;
    private final UserRepository userRepository;
    private final BlogRepository blogRepository;

    //댓글 추가 메서드
    public Comment save(Long id,AddCommentRequest request, String userName) {
        Optional<User> userOptional = userRepository.findByEmail(userName);
        User user;
        if (userOptional.isPresent()) { // Optional이 값으로 채워져 있는지 확인
            user = userOptional.get(); // User 객체 추출
        } else {
            System.out.println("사용자가 존재하지 않습니다: " + userName);
            return null;
        }
        Article article = blogRepository.findById(id).orElseThrow(() ->
                new IllegalArgumentException("댓글 쓰기 실패: 해당 게시글이 존재하지 않습니다. " + id));

        request.setUser(user);
        request.setArticle(article);

        return commentRepository.save(request.toEntity());
    }
    //댓글을 읽어온다.
    @Transactional(readOnly = true)
    public List<Comment> findAll(Long id) {
        Article article = blogRepository.findById(id).orElseThrow(() ->
                new IllegalArgumentException("해당 게시글이 존재하지 않습니다. id: " + id));
        List<Comment> comments = article.getComments();
        return comments;
    }

    //댓글 업데이트
    @Transactional
    public void update(Long articleId, Long id, UpdateCommentRequest dto) {
        Comment comment = commentRepository.findByArticleIdAndId(articleId, id).orElseThrow(() ->
                new IllegalArgumentException("해당 댓글이 존재하지 않습니다. " + id));

        comment.update(dto.getComment());
    }

    //댓글 삭제
    @Transactional
    public void delete(Long articleId, Long id) {
        Comment comment = commentRepository.findByArticleIdAndId(articleId, id).orElseThrow(() ->
                new IllegalArgumentException("해당 댓글이 존재하지 않습니다. id=" + id));

        commentRepository.delete(comment);
    }
    //게시글을 작성한 유저인지 확인
    private static void authorizedArticleAuthor(Article article){
        String UserName= SecurityContextHolder.getContext().getAuthentication().getName();
        if(!article.getAuthor().equals(UserName)){

        }
    }
}

4. 컨트롤러 작성

URL에 매핑을 해주고, 필요한 서비스 메서드들을 호출하자.

CommentApiController.java

@RequiredArgsConstructor
@RequestMapping("/api")
@RestController
public class CommentApiController {
    private final CommentService commentService;
    //댓글 생성
    @PostMapping("/articles/{id}/comments") //+현재 인증 정보를 가져오는 principal객체
    public ResponseEntity<Comment> save(@PathVariable Long id,@RequestBody AddCommentRequest request,Principal principal) {
        Comment savedComment=commentService.save(id,request, principal.getName());

        return ResponseEntity.status(HttpStatus.CREATED)
                .body(savedComment);
    }

    //댓글 읽어오기
    @GetMapping("/articles/{id}/comments")
    public List<Comment> read(@PathVariable long id) {
        return commentService.findAll(id);
    }

    //댓글 업데이트
    @PutMapping({"/articles/{articleId}/comments/{id}"})
    public ResponseEntity<Long> update(@PathVariable long articleId, @PathVariable Long id, @RequestBody UpdateCommentRequest dto) {
        commentService.update(articleId, id, dto);
        return ResponseEntity.ok(id);
    }

    //댓글 삭제
    @DeleteMapping("/articles/{articleId}/comments/{id}")
    public ResponseEntity<Long> delete(@PathVariable long articleId, @PathVariable Long id) {
        commentService.delete(articleId, id);
        return ResponseEntity.ok(id);
    }
}

기능 구현은 끝

5.뷰 작성

5-1. 댓글을 보여주기 위해 GET 요청이 오면, 응답을 위한 dto가 필요하다.

CommentResponse.java

@RequiredArgsConstructor
@Getter
public class CommentResponse {
    private Long id;
    private String comment;
    private LocalDateTime createdAt = LocalDateTime.now();
    private LocalDateTime modifiedAt = LocalDateTime.now();
    private String nickname;
    private Long userId;
    private Long ArticleId;

    /* Entity -> Dto*/
    public CommentResponse(Comment comment) {
        this.id = comment.getId();
        this.comment = comment.getComment();
        this.createdAt = comment.getCreatedDate();
        this.modifiedAt = comment.getModifiedDate();
        this.ArticleId = comment.getArticle().getId();
        this.nickname = comment.getUser().getNickname();
        this.userId = comment.getUser().getId();
    }
}

5-2. 뷰에게 데이터를 전달하기 위한 객체이다.

ArticleListViewResponse.java

@Getter
@NoArgsConstructor
public class ArticleViewResponse {
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdAt;
    private String author;

    private List<CommentResponse> comments;

    public ArticleViewResponse(Article article){
        this.id= article.getId();
        this.title=article.getTitle();
        this.content= article.getContent();
        this.createdAt = LocalDateTime.now();
        this.author=article.getAuthor();
        this.comments = article.getComments().stream().map(CommentResponse::new).collect(Collectors.toList());
    }
}

Article 정보만 전달하던 기존에서 comments를 추가하였다.

5-3.article.html 파일에

댓글 부분을 추가한다.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>블로그 글</title>
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css">
</head>
<body>
<div class="p-5 mb-5 text-center bg-light">
    <h1 class="mb-3" th:style="'font-family: \'Segoe UI\', Tahoma, Geneva, Verdana, sans-serif;'">My Blog</h1>
    <h4 class="mb-3">블로그에 오신 것을 환영합니다.</h4>
</div>
<input type="hidden" id="article-id" th:value="${article.id}">
<div class="container mt-5">
    <div class="row">
        <div class="col-lg-8">
            <article th:classappend="'article-section'">
                <!-- 블로그 글 id 추가 -->
                <header class="mb-4">
                    <h1 class="fw-bolder mb-1" th:text="${article.title}"></h1>
                    <div class="text-muted fst-italic mb-2" th:text="|Posted on ${#temporals.format(article.createdAt, 'yyyy-MM-dd HH:mm')} By ${article.author}|"></div>
                </header>
                <hr class="section-divider">
                <hr class="section-divider" th:remove="tag"/>
                <section class="mb-5">
                    <p class="fs-5 mb-4" th:text="${article.content}"></p>
                </section>
            </article>
            <!-- 글 수정, 삭제 버튼 -->
            <button type="button" id="modify-btn" th:onclick="|location.href='@{/new-article?id={articleId}(articleId=${article.id})}'|"
                    class="btn btn-primary btn-sm">수정</button>
            <button type="button" id="delete-btn" class="btn btn-secondary btn-sm">삭제</button>

            <hr class="section-divider">
            <hr class="section-divider" th:remove="tag"/>
            <!-- 댓글 섹션 시작 -->
            <section id="comments-section" th:style="'margin-top: 20px;'">
                <div id="comments-container">
                    <!-- 댓글 목록이 여기에 동적으로 추가될 것입니다. -->
                    <table class="table">
                        <thead>
                        <tr><th>Comments</th></tr>
                        </thead>
                        <tbody>
                        <!-- 각 댓글을 표 형식으로 표시 -->
                        <tr th:each="item : ${comments}">
                            <td th:text="${item.comment}"></td> <!-- 댓글 내용 -->
                            <td th:text="${item.nickname}"></td> <!-- 댓글 작성자 -->
                            <td th:text="${#temporals.format(item.modifiedAt, 'yyyy-MM-dd HH:mm')}"></td> <!-- 댓글 작성자 -->
                        </tr>
                        </tbody>
                    </table>
                </div>
                <!-- 댓글 작성 폼 -->
                <form id="comment-form">
                    <div class="form-group">
                        <label for="comment">댓글 추가:</label>
                        <textarea class="form-control" id="comment" rows="3"></textarea>
                    </div>
                    <button type="button" class="btn btn-primary" id="create-comment-btn">댓글 작성</button>
                </form>
            </section>
            <!-- 댓글 섹션 끝 -->
        </div>
    </div>
</div>
<script src="/js/comment.js"></script>
<script src="/js/article.js"></script>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
</body>
</html>

5-4. 자바스크립트로

버튼을 눌렀을 때 댓글 생성 API에 관련 요청을 보내준다.

comment.js

const createCommentButton = document.getElementById('create-comment-btn');

if (createCommentButton) {
    createCommentButton.addEventListener('click', function(event) {
        event.preventDefault();
        alert("success");

        const data = {
            postsId: $('#article-id').val(),
            comment: $('#comment').val()
        };

        if (!data.comment || data.comment.trim() === "") {
            alert("공백 또는 입력하지 않은 부분이 있습니다.");
            return false;
        } else {
            body = JSON.stringify({
                        comment: $('#comment').val()
                    });
                    function success() {
                        alert('등록 완료되었습니다.');
                        location.replace('/articles/'+data.postsId);
                    };
                    function fail() {
                        alert('등록 실패했습니다.');
                        location.replace('/articles/'+data.postsId);
                    };
                    httpRequest('POST', '/api/articles/' + data.postsId + '/comments', body, success, fail);
        }
    });
}
// 쿠키를 가져오는 함수
 function getCookie(key) {
     var result = null;
     var cookie = document.cookie.split(';');
     cookie.some(function (item) {
         item = item.replace(' ', '');

         var dic = item.split('=');

         if (key === dic[0]) {
             result = dic[1];
             return true;
         }
     });

     return result;
 }
function httpRequest(method, url, body, success, fail) {
    alert("success");

    fetch(url, {
        method: method,
        headers: { // 로컬 스토리지에서 액세스 토큰 값을 가져와 헤더에 추가
            Authorization: 'Bearer ' + localStorage.getItem('access_token'),
            'Content-Type': 'application/json',
        },
        body: body,
    }).then(response => {
        if (response.status === 200 || response.status === 201) {
            return success();
        }
        const refresh_token = getCookie('refresh_token');
        if (response.status === 401 && refresh_token) {
            fetch('/api/token', {
                method: 'POST',
                headers: {
                    Authorization: 'Bearer ' + localStorage.getItem('access_token'),
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    refreshToken: getCookie('refresh_token'),
                }),
            })
                .then(res => {
                    if (res.ok) {
                        return res.json();
                    }
                })
                .then(result => { // 재발급이 성공하면 로컬 스토리지값을 새로운 액세스 토큰으로 교체
                    localStorage.setItem('access_token', result.accessToken);
                    httpRequest(method, url, body, success, fail);
                })
                .catch(error => fail());
        } else {
            return fail();
        }
    });
}

댓글을 단 모습이다.

SpringBoot 게시판 만들기-1. CRUD, 로그인 기능 구현

코오오 코오 — Mon, 4 Mar 2024 19:05:37 +0900

기본적인 CRUD 기능이 있는 게시판으로, 웹 애플리케이션과 SpringBoot에 대한 기초를 다지기 위한 프로젝트를 작성한다.

스프링 부트 3 백엔드 개발자 되기: 자바 편

초기 구성을 위 책에서 상당 부분 참고했고, 추가적인 기능을 쌓아가는 식으로 진행할 계획이다.

책을 통해 완성할 수 있는 기능은 다음과 같다.1.게시판 CRUD 기능2. Spring Security를 이용한 로그인3. OAuth2를 이용한 구글 로그인4. AWS Elastic Beanstalk를 이용한 배포 5. Github Action 을 이용한 CI/CD

여기서1. 게시글에 댓글 추가
2. 게시글 검색
3. 게시글 페이징

4. 게시글 조회수
5. Spring Security를 이용한 로그인과 OAuth2를 이용한 구글 로그인 중 선택하여 로그인

6. 그 외 회원 정보 입력

같은 기능을 추가할 예정이다.

책을 통해 아래와 같은 결과를 얻을 수 있다.

로그인 화면

구글 연동을 통한 로그인

로그인 후 보이는 게시글 리스트. 레이아웃 부분에서 기존 코드에서 살짝 수정을 거쳤다.

게시글 작성 화면

게시글을 작성하면 보이는 화면.

댓글 영역이 있긴 한데 기능을 아직 구현하진 않았다.

새 글이 추가된 모습. 작성자를 표현하는 방법이 이메일 뿐이다.

AWS Elasticbeanstalk를 통해 배포한 후 모습

책을 따라했을 뿐인데도 알 수 없는 오류가 많아 생각보다 오래 걸렸다.

아직 공부가 부족한 탓에 무엇 때문이었는지는 모르겠고, 그냥 안된다.. 안된다... 하다가 결국 새 애플리케이션을 생성해서 해결했다.

배포 후 한 달 방치해놨더니 별 거 한 것도 없는데 5만원이 청구되었다... 따라서 현재는 삭제.

코드

https://github.com/saaut/springbootProject_myBlog

Dynamic Programming-Floyd Warshall 알고리즘

코오오 코오 — Sun, 11 Jun 2023 12:31:57 +0900

Dynamic Programming(동적 알고리즘)이란?

최적화 문제를 해결하는 알고리즘

1.입력 크기가 작은 '부분 문제'들을 모두 해결

2.그 해들을 이용하여 보다 '큰 크기의 부분 문제'들을 해결

3.최종적으로 원래 주어진 입력의 문제를 해결.

Divide&Conquer(분할 정복 알고리즘) 방식과 구조적으로 유사하지만, 순서는 반대이다.

거기에 더해, 동적 계획 알고리즘은 B와 C의 해를 구하는 데 E와 F의 해 모두를 이용한다.

분할 정복 알고리즘의 경우,

D,E,F,G는 각각 더 이상 분할할 수 없는 부분 문제들이다.

D와 E의 해를 취합하여 B의 해를 구하고,

F와 G의 해를 취합하여 C의 해를 구하고,

B와 C의 해를 취합하여 A를 구한다...

동적 계획 알고리즘의 경우,

먼저 최소 단위의 부분 문제 D, E, F, G의 해를 각각 구하고,

D, E, F의 해를 이용하여 B의 해를 구한다.

E, F, G의 해를 이용하여 C의 해를 구한다.

B와 C의 해를 구하는데 있어 E와 F의 해 모두를 이용했다는 점에서 차이를 볼 수 있다.

동적 계획 알고리즘의 예시

1.모든 쌍 최단 경로 문제

-각 쌍의 점 사이의 최단 경로를 찾는 문제

A와 B 사이의 최단 경로를 찾는 문제가 있다. 그런데 그래프에서 둘이 이어지는 경로가 하나가 아니라, 다른 노드들에 의해 N개가 된다면? 컴퓨터는 모든 Path를 다 찾아서 비교하게 될 것이다. Time Complexity O(n^4)

-Idea

(1)그래프에 3개의 점이 있는 경우, 점 A에서 점 B까지의 최단 경로를 찾으려면, 2가지 경로, 즉 점 A에서 B로 직접 가는 경로 하나와, 점 1을 경유하는 경로 중에서 짧은 것을 선택하면 된다.(n번 반복)

(2) 그래프에 4개의 점이 있는 경우, A에서 B까지의 최단 경로를 찾을 때 직접 가는 경로 하나와, 점을 하나만 지나는 경로 n개와, 점 2개를 지나는 경로를 선택할 수 있다. 이 때, 점 2개를 지나는 경로의 경우 점 1개를 지나는 경로에 대한 연산과 겹치기 때문에, 반복 작업을 하지 않고 넘어간다. ->모든 경로를 여러 번 계산할 필요가 없다.

(3) 이 때, starting point와 destination을 고정해서 생각하지 말고, 그래프에 존재하는 점을 고정해서 생각하라.

그래프에 존재하는 점 하나에서, 다른 점까지의 최소 경로를 이차원 배열 형태로 출력할 수 있다.

그래프의 경로를 이차원 배열 형태로 출력하기

(4)그리고 존재하는 경로를 통해서, 정해지지 않은 경로의 거리를 구할 수 있다.

1->5로 가는 방법이 현재 존재하지 않지만, 2를 거치는 방법으로 거리 1만큼 걸려 갈 수 있다.

(5)이를 여러 번 반복해서 배열을 업데이트 해준다.

Dijkstra와 비슷한 느낌이 들기도 한다.

이처럼 문제 해결 과정에 반복 연산이 여러 번 있으면 동적 알고리즘이라 표현한다.

피보나치 수열도 이와 같은 계열이다.

정리하면 위와 같다

-구현 방법

플로이드-워샬 알고리즘

-warshall은 그래프에서 모든 쌍의 '경로 존재 여부'를 찾아내는 동적 계획 알고리즘을 제안했다.

-Floyd는 이를 변형하여 모든 쌍의 '최단 경로'를 찾는 알고리즘을 고안했다.

-따라서 모든 쌍의 최단 경로를 찾는 동적 계획 알고리즘을 플로이드-워샬 알고리즘이라 한다.

-플로이드-워샬 알고리즘의 시간복잡도는 O(n^3)으로 다익스트라 알고리즘을 n번 사용할때의 시간복잡도와 동일하다.

-그러나 플로이드 알고리즘은 매우 간단하여 다익스트라 알고리즘을 사용하는 것보다 효율적이다.

A에서 B로 직접 가는 경로, A에서 점 1을 경유하여 B로 가는 경로가 있다.

B에서 C로 직접 가는 경로, B에서 점 1을 경유하여 C로 가는 경로가 있다.

이런 식으로 모든 쌍에 대하여, 직접 가는 경로와 1을 경유하는 경로를 비교한다.

그 다음엔 점 2를 경유하여 가는 거리와 비교한다.

이때, 점 2는 1을 경유하는 경로를 거친다.

이런 식으로 모든 쌍에 대하여 두 개의 점을 경유하는 경로를 비교한다.

n번 반복하여 가장 짧은 것을 고른다.

-수행 과정

배열 D를 만들어 갱신해 나간다.

그래프와 배열 D

위는 배열 D를 갱신하는 과정이다. 직접 가는 경로와, 점 1을 거쳐서 가는 경로 중에서 어떤 값이 더 작은지 비교하고, 갱신한다.

k를 1씩 증가시켜가며 n번 반복한다.

-시간복잡도

k n번반복

2차원 배열 D에 있어 행n번 반복, 열 n 번 반복

총 n^3번 반복

O(n^3)

서버에서 로그아웃 깜빡했을때

코오오 코오 — Mon, 15 May 2023 13:06:57 +0900

https://bewan.tistory.com/50

다른사용자 강제 logout 시키기

운영상의 이유로 현재 접속중인 사용자들을(또는 특정 사용자) 시스템에서 logout 시킬 경우가 필요한 경우가 있다. 이와같이 부득이하게 다른 사용자(혹은 내 계정)을 logout 시키고자 할때 아래

bewan8.com

who
ps -dN|grep pts/0
kill -9 12345

원격 리눅스 서버에서 파이썬 파일 실행하기

코오오 코오 — Mon, 15 May 2023 12:48:55 +0900

1.원격 서버 연결

2.python 코드 전송(FTP, SCP or Git)

3.cd 명령을 사용하여 python코드를 업로드한 디렉토리로 이동

cd /path/to/directory

설치 종속성(필요한 경우): 코드가 외부 라이브러리 또는 패키지에 의존하는 경우 원격 서버에 설치해야 할 수 있습니다. Pip for Python 패키지와 같은 서버 운영 체제에 적합한 패키지 관리자를 통해 설치

4.python 명령을 통해 실행

python3 your_script.py

코드 실행 모니터링: 코드에 따라 포그라운드 또는 백그라운드에서 실행될 수 있습니다. 코드가 예상대로 실행되는지 확인하고 필요에 따라 출력 또는 로그를 모니터링합니다.

5.중단하기

(1)

키보드 인터럽트: Python 코드가 명령줄의 포그라운드에서 실행 중인 경우 일반적으로 Ctrl + C를 눌러 코드를 중지할 수 있습니다. 그러면 Python 프로세스에 키보드 인터럽트 신호가 전송되어 프로세스가 종료됩니다.

(2)

프로세스 종료: Python 코드가 백그라운드에서 실행 중이거나 별도의 프로세스로 실행 중인 경우, Python 프로세스의 프로세스 ID(PID)를 찾고 kill 명령을 사용하여 종료할 수 있습니다. 다음은 특정 PID를 사용하여 프로세스를 종료하는 방법의 예입니다

kill PID

PID를 Python 프로세스의 실제 프로세스 ID로 바꿉니다. PID는 ps 또는 top과 같은 도구를 사용하거나 프로세스 이름을 검색하여 찾을 수 있습니다.

(3)

정상 종료: Python 코드가 정상 종료를 처리하도록 설계된 경우 코드 실행을 중지하는 특정 메커니즘을 구현했을 수 있습니다. 이 경우 코드에서 특정 신호를 보내거나 특정 이벤트를 트리거하여 전체 종료를 시작할 수 있습니다. 코드를 정상적으로 중지하는 방법을 결정하려면 코드의 특정 구현을 참조하십시오.

원격 서버에서 Python 코드를 실행하는 경우 서버에 대한 SSH 연결을 설정하고 위에서 언급한 필요한 명령을 실행하여 코드 실행을 중지해야 할 수 있습니다.

6.python 패키지가 필요한 경우

리눅스에서 pip 명령어를 사용해서 설치 가능

(1) pip 설치 확인

pip --version

(2) pip 설치

필요한 경우, 서버의 운영 체제 및 Python 버전에 적합한 설치 지침에 따라 설치할 수 있습니다. 이 지침은 서버 환경에 따라 다를 수 있습니다. 예를 들어 Ubuntu 또는 Debian 기반 시스템에서 다음 명령을 사용하여 Python 3용 pip를 설치할 수 있습니다.

sudo apt-get install python3-pip

(3) pip 사용하여 패키지 설치

pip install example_package

(4)더 이상 필요하지 않을 경우, 삭제

pip uninstall package_name

종속성은 자동으로 제거되지 않는다.

cmd에서 원격 리눅스 서버 접속하고 파일 다루기

코오오 코오 — Mon, 15 May 2023 12:13:32 +0900

1.파일 업로드

(1)윈도우에서 리눅스로 파일 전송

pscp -P port_number filename root@server_ip:/path

pscp -P 3000 c:\SignalUsServerTest\requirements.txt root@101.101.167.67:/root/download

(2)리눅스에서 윈도우로 파일 전송

pscp user_name@server_ip:/path c:\path

pscp root@101.101.167.67:/root/download c:\SignalUsServerTest

cmd에서 사용가능

2.cmd에서 원격 Linux서버에 연결하기

ssh username@remote_server_ip

ssh -p port_number username@remote_server_ip

ssh root@101.101.167.67

ssh -p 3000 root@101.101.167.67

3.디렉토리 이동

cd /path/to/directory

cd /root/download

4.현재 파일과 디렉토리 나열

ls

5.파일 액세스, 열람

nano, vi, cat과 같은 텍스트 편집기 사용 가능

cat filename

6.파일 삭제

삭제하면 복구 불가

rm filename

7.파일 수정

텍스트 편집기 사용 가능 nano

nano filename

텍스트 편집기 내에서 제공된 명령 또는 바로 가기를 사용해 수정.

파일 편집을 마치면 저장(Ctrl+O), 종료(Ctrl+X)하면

원격 서버의 파일도 수정 사항으로 업데이트 된다.

8.디렉토리 삭제

rm -r dir1

9.모든 작업 수행 후 ssh 세션 종료

exit

안드로이드 스튜디오 카메라 화면 캡처하기

코오오 코오 — Tue, 9 May 2023 19:48:06 +0900

서치하여 얻은 '카메라 기능 구현'에서

찍은 사진을 저장하는 단계를 제외하고, 오로지 캡처된 화면만을 이용하는 어플을 만드는 중이었다.

따라서 기존 카메라를 이용하여 얻은 이미지의 바이트 데이터를 서버로 전송하려 했으나,

카메라를 이용하는 과정 중 필수로 delay가 생겨 못 쓰게 되었다...

앱의 목표가 실시간으로 촬영-서버로 전송-서버와 소통 후 결과값 출력 이고 ,

실시간이니만큼 전송 중에도 촬영 화면은 계속해서 보여야 하는데

딜레이가 생겨 보낼 때마다 화면이 멈춰버리면

진정한 실시간 전송은 불가능하다.

3초에 한 번 같은 느린 전송은 가능하겠지만

프리뷰를 보는 유저도 멈춤에 답답하고

이미지 처리도 3초에 한 번씩만 되니까 섬세한 작업은 할 수 없다.

따라서 기존 코드를 짜다 말고 갈아엎기로 했다.

OpenCV를 이용하여 frame을 캡처하면 이를 서버로 전송할 때도 화면이 멈추지 않는다고 한다.

기존에 카메라가 실행되고 있을 때, 이 미리 보기 화면을 이용하는 코드이다.

세이브 기능은 삭제했지만, 아직 데이터를 이용하여 무언가 구현한 게 없다.

//캡처와 전송시작
    private void startCaptureImg() {
        if (null == mCameraDevice || !binding.preview.isAvailable() || null == mPreviewSize) {//카메라가 사용할 수 있는 상태인지 확인
            Log.e(TAG, "mCameraDevice is null, return");
            return;
        }
        Toast.makeText(getContext(), "이미지가져오기 실행", Toast.LENGTH_SHORT).show();

        assert getActivity() != null;//activity와 fragment가 잘 attach되어있고, 아직 destroy되지 않았다는 뜻
        SurfaceTexture texture = binding.preview.getSurfaceTexture();//Preview texture과 관련된 surfacetexture를 찾는다.

        assert texture !=null;//Preview texture를 사용할 수 있는 지 확인
        try {
            int width = 640;
            int height = 480;

            assert texture != null;
            ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);//JPEG 형식으로 캡처된 이미지를 수신할 ImageReader 인스턴스 생성
            List<Surface> outputSurfaces = new ArrayList<Surface>(2);
            outputSurfaces.add(reader.getSurface());
            outputSurfaces.add(new Surface(texture));


            final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            captureBuilder.addTarget(reader.getSurface());
            captureBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);//카메라실행을 위한 세팅. 카메라 캡처 요청에 대한 제어 모드를 자동으로 설정한다.


            ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {//이미지를 사용할 수 있을 때 트리거되는 OnImageAvailableListener를 만든다.
                @Override
                public void onImageAvailable(ImageReader reader) {//readerListender 내부에서 캡처된 이미지를 획득
                    Image image = null;
                    try {
                        image = reader.acquireLatestImage();
                        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                        byte[] bytes = new byte[buffer.remaining()];
                        buffer.get(bytes);
                        Toast.makeText(getContext(), "바이트 데이터 얻기 성공", Toast.LENGTH_SHORT).show();

                        sendImageToServer(bytes); // Call your method to send the byte data to the server
                    } finally {
                        if (image != null) {
                            image.close();
                        }
                    }
                }
            };

            HandlerThread thread = new HandlerThread("CameraPicture");
            thread.start();
            final Handler backgroudHandler = new Handler(thread.getLooper());
            reader.setOnImageAvailableListener(readerListener, backgroudHandler);

            final CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {
                @Override
                public void onCaptureCompleted(CameraCaptureSession session,//캡처 완료 시 서버로 전송
                                               CaptureRequest request, TotalCaptureResult result) {
                    super.onCaptureCompleted(session, request, result);
                    startPreview();
                }

            };

            mCameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(CameraCaptureSession session) {
                    try {
                        session.capture(captureBuilder.build(), captureListener, mBackgroundHandler);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();

                    }
                }

                @Override
                public void onConfigureFailed(CameraCaptureSession session) {

                }
            }, mBackgroundHandler);



        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    private void sendImageToServer(byte[] imageData) {
        // Implement your networking code here to send the byte data to the server
        // This can involve using libraries such as HttpURLConnection, OkHttp, Retrofit, etc.
        // Construct an HTTP request, set headers and parameters, and attach the byte data
        // to the request body before sending it to the server.
        Toast.makeText(getContext(), "서버로 이미지 전송 시도", Toast.LENGTH_SHORT).show();
    }

위를 활용한 전체 코드이다. 특정 앱 개발에 쓰이던 부분은 삭제했지만 대충 해서 쓸 데 없는 부분이 많을 것이고..., 카메라 부분 외에는 많이 조잡하다. 코틀린에서 자바로 자동 변환 기능을 사용했기 때문에...

import android.app.Activity;
import android.content.Context;
import android.content.res.Configuration;
import android.graphics.ImageFormat;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.*;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.media.MediaRecorder;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.util.Size;
import android.util.SparseIntArray;
import android.view.LayoutInflater;
import android.view.Surface;
import android.view.TextureView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.databinding.DataBindingUtil;
import androidx.fragment.app.Fragment;
import androidx.navigation.NavController;
import androidx.navigation.Navigation;

import java.io.File;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

import io.reactivex.disposables.CompositeDisposable;
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import com.example.signalussample1_java.databinding.FragmentCameraBinding;
import com.gun0912.tedpermission.PermissionListener;
import com.gun0912.tedpermission.normal.TedPermission;

@Metadata(
        mv = {1, 7, 1},
        k = 1,
        d1 = {"\u0000B\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u000e\n\u0002\b\u0005\n\u0002\u0018\u0002\n\u0002\b\u0005\n\u0002\u0010\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\n\u0002\u0018\u0002\n\u0002\b\u0003\u0018\u00002\u00020\u00012\u00020\u0002B\u0005¢\u0006\u0002\u0010\u0003J\u0012\u0010\u0010\u001a\u00020\u00112\b\u0010\u0012\u001a\u0004\u0018\u00010\u0013H\u0016J&\u0010\u0014\u001a\u0004\u0018\u00010\u00132\u0006\u0010\u0015\u001a\u00020\u00162\b\u0010\u0017\u001a\u0004\u0018\u00010\u00182\b\u0010\u0019\u001a\u0004\u0018\u00010\u001aH\u0016J\u001a\u0010\u001b\u001a\u00020\u00112\u0006\u0010\u001c\u001a\u00020\u00132\b\u0010\u0019\u001a\u0004\u0018\u00010\u001aH\u0016R\u001a\u0010\u0004\u001a\u00020\u0005X\u0086\u000e¢\u0006\u000e\n\u0000\u001a\u0004\b\u0006\u0010\u0007\"\u0004\b\b\u0010\tR\u001a\u0010\n\u001a\u00020\u000bX\u0086.¢\u0006\u000e\n\u0000\u001a\u0004\b\f\u0010\r\"\u0004\b\u000e\u0010\u000f¨\u0006\u001d"},
        d2 = {"Lcom/example/signalussample1/fragment/cameraFragment;", "Landroidx/fragment/app/Fragment;", "Landroid/view/View$OnClickListener;", "()V", "body_part", "", "getBody_part", "()Ljava/lang/String;", "setBody_part", "(Ljava/lang/String;)V", "navController", "Landroidx/navigation/NavController;", "getNavController", "()Landroidx/navigation/NavController;", "setNavController", "(Landroidx/navigation/NavController;)V", "onClick", "", "v", "Landroid/view/View;", "onCreateView", "inflater", "Landroid/view/LayoutInflater;", "container", "Landroid/view/ViewGroup;", "savedInstanceState", "Landroid/os/Bundle;", "onViewCreated", "view", "app_debug"}
)
public final class cameraFragment extends Fragment implements View.OnClickListener  {
    @NotNull
    private String body_part = "";
    public NavController navController;
    private HashMap _$_findViewCache;
    private static final String TAG = "VideoFragment";

    FragmentCameraBinding binding;

    // 카메라 광각, 전면, 후면
    private static final String CAM_WHAT = "2";
    private static final String CAM_FRONT = "1";
    private static final String CAM_REAR = "0";

    private String mCamId;

    CameraCaptureSession mCameraCaptureSession;
    CameraDevice mCameraDevice;
    CameraManager mCameraManager;

    Size mVideoSize;
    Size mPreviewSize;
    CaptureRequest.Builder mCaptureRequestBuilder;

    int mSensorOrientation;

    Semaphore mSemaphore = new Semaphore(1);

    HandlerThread mBackgroundThread;
    Handler mBackgroundHandler;

    MediaRecorder mMediaRecorder;

    private boolean mIsRecordingVideo;
    //public Handler handler;
    public static cameraFragment newInstance() {
        return new cameraFragment();
    }

    @NotNull
    public final NavController getNavController() {
        NavController var10000 = this.navController;
        if (var10000 == null) {
            Intrinsics.throwUninitializedPropertyAccessException("navController");
        }

        return var10000;
    }

    public final void setNavController(@NotNull NavController var1) {
        Intrinsics.checkNotNullParameter(var1, "<set-?>");
        this.navController = var1;
    }

    @Nullable
    public View onCreateView(@NotNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        TedPermission.create()
                .setPermissionListener(permission)
                .setRationaleMessage("녹화를 위하여 권한을 허용해주세요.")
                .setDeniedMessage("권한이 거부되었습니다. 설정 > 권한에서 허용해주세요.")
                .setPermissions(android.Manifest.permission.CAMERA, android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.RECORD_AUDIO)
                .check();

        binding = DataBindingUtil.inflate(inflater, R.layout.fragment_camera, container, false);
        mCamId = CAM_FRONT;
        mCompositeDisposable = new CompositeDisposable();


        return binding.getRoot();
    }

    public void onViewCreated(@NotNull View view, @Nullable Bundle savedInstanceState) {
        Intrinsics.checkNotNullParameter(view, "view");
        super.onViewCreated(view, savedInstanceState);


        this.navController = Navigation.findNavController(view);
        TextView var10000 = (TextView)this._$_findCachedViewById(id.translated);
        ((ImageView)this._$_findCachedViewById(id.imageView12)).setOnClickListener((View.OnClickListener)this);

        startCaptureImg();

    }

    public void onClick(@Nullable View v) {

        Integer var2 = v != null ? v.getId() : null;
        var3 = id.imageView12;
        if(var2!=null){
            if(var2==var3){
                startCaptureImg();

            }
        }   

    }


    public View _$_findCachedViewById(int var1) {
        if (this._$_findViewCache == null) {
            this._$_findViewCache = new HashMap();
        }

        View var2 = (View)this._$_findViewCache.get(var1);
        if (var2 == null) {
            View var10000 = this.getView();
            if (var10000 == null) {
                return null;
            }

            var2 = var10000.findViewById(var1);
            this._$_findViewCache.put(var1, var2);
        }

        return var2;
    }

    public void _$_clearFindViewByIdCache() {
        if (this._$_findViewCache != null) {
            this._$_findViewCache.clear();
        }

    }
    PermissionListener permission = new PermissionListener() {
        @Override
        public void onPermissionGranted() {
            Toast.makeText(getContext(), "권한 허가", Toast.LENGTH_SHORT).show();

        }

        @Override
        public void onPermissionDenied(List<String> deniedPermissions) {
            Toast.makeText(getContext(), "권한 거부", Toast.LENGTH_SHORT).show();

        }
    };

    public void onActivityCreated(@androidx.annotation.Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        assert getActivity() != null;
    }

    @Override
    public void onResume() {
        super.onResume();

        startBackgroundThread();
        if (binding.preview.isAvailable()) {
            openCamera(binding.preview.getWidth(), binding.preview.getHeight());
        } else {
            binding.preview.setSurfaceTextureListener(mSurfaceTextureListener);
        }
    }


    private TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener() {
        @Override
        public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
            openCamera(binding.preview.getWidth(), binding.preview.getHeight());
        }

        @Override
        public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
            if(!mIsRecordingVideo) configureTransform(width, height);
        }

        @Override
        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
            return true;
        }

        @Override
        public void onSurfaceTextureUpdated(SurfaceTexture surface) {

        }
    };

    private CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            mCameraDevice = camera;
            startPreview();
            mSemaphore.release();
            if (null != binding.preview) {
                configureTransform(binding.preview.getWidth(), binding.preview.getHeight());
            }

        }

        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            mSemaphore.release();
            camera.close();
            mCameraDevice = null;
        }

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            mSemaphore.release();
            camera.close();
            mCameraDevice = null;
            Activity activity = getActivity();
            assert activity != null;
            activity.finish();
        }
    };


    //카메라 기능 호출
    private void openCamera(int width, int height) {
        Activity activity = getActivity();
        assert activity != null;
        mCameraManager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
        try {
            if (!mSemaphore.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
                throw new RuntimeException("Time out waiting to lock camera opening.");
            }
            CameraCharacteristics cc = mCameraManager.getCameraCharacteristics(mCamId);
            StreamConfigurationMap scm = cc.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            mSensorOrientation = cc.get(CameraCharacteristics.SENSOR_ORIENTATION);
            if (scm == null) {
                throw new RuntimeException("Cannot get available preview/video sizes");
            }

            mVideoSize = chooseVideoSize(scm.getOutputSizes(MediaRecorder.class));
            mPreviewSize = chooseOptimalSize(scm.getOutputSizes(SurfaceTexture.class), width, height, mVideoSize);

            int orientation = getResources().getConfiguration().orientation;
            if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                binding.preview.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
            } else {
                binding.preview.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
            }

            configureTransform(width, height);
            mMediaRecorder = new MediaRecorder();
            mCameraManager.openCamera(mCamId, mStateCallback, mBackgroundHandler);
        } catch (CameraAccessException | SecurityException | NullPointerException | InterruptedException e) {
            e.printStackTrace();
            activity.finish();
        }


    }

    private static Size chooseVideoSize(Size[] choices) {
        for (Size size : choices) {
            // 해상도에 맞게 설정
            if(size.getWidth() == size.getHeight() * 4 / 3 && size.getWidth() <= 1080){
                return size;
            }
        }
        return choices[choices.length - 1];
    }

    private static Size chooseOptimalSize(Size[] choices, int width, int height, Size aspectRatio) {
        List<Size> bigEnough = new ArrayList<>();
        int w = aspectRatio.getWidth();
        int h = aspectRatio.getHeight();
        for (Size ops : choices) {
            if(ops.getHeight() == ops.getWidth() * h / w && ops.getWidth() >= width && ops.getHeight() >= height) {
                bigEnough.add(ops);
            }
        }

        if (bigEnough.size() > 0) {
            return Collections.min(bigEnough, new CompareSizesByArea());
        } else {
            return choices[0];
        }
    }


    // 카메라 닫기
    private void closeCamera() {
        try {
            mSemaphore.acquire();
            closePreviewSession();
            if (null != mCameraDevice) {
                mCameraDevice.close();
                mCameraDevice = null;
            }
            if (null != mMediaRecorder) {
                mMediaRecorder.release();
                mMediaRecorder = null;
            }
        } catch (InterruptedException ie) {
            ie.printStackTrace();
        } finally {
            mSemaphore.release();
        }
    }

    //미리보기 기능
    private void startPreview() {
        if(null == mCameraDevice || !binding.preview.isAvailable() || null == mPreviewSize) {
            Toast.makeText(getContext(), "CameraDeviceIsNotAvailable", Toast.LENGTH_SHORT).show();
            return;
        }

        try {
            closePreviewSession();
            SurfaceTexture texture = binding.preview.getSurfaceTexture();
            assert texture != null;
            texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
            mCaptureRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

            Surface previewSurface = new Surface(texture);
            mCaptureRequestBuilder.addTarget(previewSurface);
            mCameraDevice.createCaptureSession(Collections.singletonList(previewSurface), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    mCameraCaptureSession = session;
                    updatePreview();
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    Activity activity = getActivity();
                    assert activity != null;
                    Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
                }
            }, mBackgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }

    }

    private void updatePreview() {
        if (null == mCameraDevice) {
            return;
        }
        try {
            setUpCaptureRequestBuilder(mCaptureRequestBuilder);
            HandlerThread thread = new HandlerThread("CameraPreview");
            thread.start();
            mCameraCaptureSession.setRepeatingRequest(mCaptureRequestBuilder.build(), null, mBackgroundHandler);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
        builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
    }


    private void configureTransform(int viewWidth, int viewHeight) {
        Activity activity = getActivity();
        if (null == binding.preview || null == mPreviewSize || null == activity) {
            return;
        }
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
        Matrix matrix = new Matrix();
        RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
        RectF bufferRect = new RectF(0, 0, mPreviewSize.getWidth(), mPreviewSize.getHeight());

        float centerX = viewRect.centerX();
        float centerY = viewRect.centerY();

        if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
            bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
            matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
            float scale = Math.max(
                    (float) viewHeight / mPreviewSize.getHeight(),
                    (float) viewWidth / mPreviewSize.getWidth()
            );
            matrix.postScale(scale, scale, centerX, centerY);
            matrix.postRotate(90 * (rotation - 2), centerX, centerY);
        }
        activity.runOnUiThread(() -> binding.preview.setTransform(matrix));
    }

    private void startBackgroundThread() {
        mBackgroundThread = new HandlerThread("CameraBackground");
        mBackgroundThread.start();
        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());
    }

    private void stopBackgroundThread() {
        mBackgroundThread.quitSafely();
        try {
            mBackgroundThread.join();
            mBackgroundThread = null;
            mBackgroundHandler = null;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void closePreviewSession() {
        if (mCameraCaptureSession != null) {
            mCameraCaptureSession.close();
            mCameraCaptureSession = null;
        }
    }

    private static final int SENSOR_ORIENTATION_DEFAULT_DEGREES = 90;
    private static final int SENSOR_ORIENTATION_INVERSE_DEGREES = 270;
    private static final SparseIntArray DEFAULT_ORIENTATIONS = new SparseIntArray();
    private static final SparseIntArray INVERSE_ORIENTATIONS = new SparseIntArray();
    static {
        DEFAULT_ORIENTATIONS.append(Surface.ROTATION_0, 90);
        DEFAULT_ORIENTATIONS.append(Surface.ROTATION_90, 0);
        DEFAULT_ORIENTATIONS.append(Surface.ROTATION_180, 270);
        DEFAULT_ORIENTATIONS.append(Surface.ROTATION_270, 180);
    }

    static {
        INVERSE_ORIENTATIONS.append(Surface.ROTATION_0, 270);
        INVERSE_ORIENTATIONS.append(Surface.ROTATION_90, 180);
        INVERSE_ORIENTATIONS.append(Surface.ROTATION_180, 90);
        INVERSE_ORIENTATIONS.append(Surface.ROTATION_270, 0);
    }


    //캡처와 전송시작
    private void startCaptureImg() {
        if (null == mCameraDevice || !binding.preview.isAvailable() || null == mPreviewSize) {//카메라가 사용할 수 있는 상태인지 확인
            Log.e(TAG, "mCameraDevice is null, return");
            return;
        }
        Toast.makeText(getContext(), "이미지가져오기 실행", Toast.LENGTH_SHORT).show();

        assert getActivity() != null;//activity와 fragment가 잘 attach되어있고, 아직 destroy되지 않았다는 뜻
        SurfaceTexture texture = binding.preview.getSurfaceTexture();//Preview texture과 관련된 surfacetexture를 찾는다.

        assert texture !=null;//Preview texture를 사용할 수 있는 지 확인
        try {
            int width = 640;
            int height = 480;

            assert texture != null;
            ImageReader reader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);//JPEG 형식으로 캡처된 이미지를 수신할 ImageReader 인스턴스 생성
            List<Surface> outputSurfaces = new ArrayList<Surface>(2);
            outputSurfaces.add(reader.getSurface());
            outputSurfaces.add(new Surface(texture));


            final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            captureBuilder.addTarget(reader.getSurface());
            captureBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);//카메라실행을 위한 세팅. 카메라 캡처 요청에 대한 제어 모드를 자동으로 설정한다.


            ImageReader.OnImageAvailableListener readerListener = new ImageReader.OnImageAvailableListener() {//이미지를 사용할 수 있을 때 트리거되는 OnImageAvailableListener를 만든다.
                @Override
                public void onImageAvailable(ImageReader reader) {//readerListender 내부에서 캡처된 이미지를 획득
                    Image image = null;
                    try {
                        image = reader.acquireLatestImage();
                        ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                        byte[] bytes = new byte[buffer.remaining()];
                        buffer.get(bytes);
                        Toast.makeText(getContext(), "바이트 데이터 얻기 성공", Toast.LENGTH_SHORT).show();

                        sendImageToServer(bytes); // Call your method to send the byte data to the server
                    } finally {
                        if (image != null) {
                            image.close();
                        }
                    }
                }
            };

            HandlerThread thread = new HandlerThread("CameraPicture");
            thread.start();
            final Handler backgroudHandler = new Handler(thread.getLooper());
            reader.setOnImageAvailableListener(readerListener, backgroudHandler);

            final CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {
                @Override
                public void onCaptureCompleted(CameraCaptureSession session,//캡처 완료 시 서버로 전송
                                               CaptureRequest request, TotalCaptureResult result) {
                    super.onCaptureCompleted(session, request, result);
                    startPreview();
                }

            };

            mCameraDevice.createCaptureSession(outputSurfaces, new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(CameraCaptureSession session) {
                    try {
                        session.capture(captureBuilder.build(), captureListener, mBackgroundHandler);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();

                    }
                }

                @Override
                public void onConfigureFailed(CameraCaptureSession session) {

                }
            }, mBackgroundHandler);



        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
    private void sendImageToServer(byte[] imageData) {
        // Implement your networking code here to send the byte data to the server
        // This can involve using libraries such as HttpURLConnection, OkHttp, Retrofit, etc.
        // Construct an HTTP request, set headers and parameters, and attach the byte data
        // to the request body before sending it to the server.
        Toast.makeText(getContext(), "서버로 이미지 전송 시도", Toast.LENGTH_SHORT).show();
    }

    static class CompareSizesByArea implements Comparator<Size> {
        @Override
        public int compare(Size lhs, Size rhs) {
            return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
        }
    }

    CompositeDisposable mCompositeDisposable;

    // $FF: synthetic method
    public void onDestroyView() {
        stopBackgroundThread();
        super.onDestroyView();
        this._$_clearFindViewByIdCache();
    }
}

참고

카메라 이미지 추출에 사용 링크 내 2번.

https://hw00173.tistory.com/15

[안드로이드 링크 정리] Camera2 API를 이용한 사진찍기 기능 관련 링크 [2019_12_01 - 2019_12_08]

해당 작성 링크들은 개발하면서 참고 했던 링크들을 주제별로 정리한 자료입니다. 대부분 링크에 대한 설명이므로, 해당 기능에 대한 설명이 부족할 수 있습니다. ! 1. Camrea2 API를 이용한 카메라

hw00173.tistory.com

카메라 Preview 띄우는 데 이용

안드로이드 Camera2 api 로 동영상 촬영하고 갤러리에 저장하기. (tistory.com)

안드로이드 Camera2 api 로 동영상 촬영하고 갤러리에 저장하기.

공감 및 댓글, 광고클릭은 포스팅 하는데 아주아주 큰 힘이 됩니다!!포스팅 내용이 찾아주신 분들께 도움이 되길 바라며더 깔끔하고 좋은 포스팅을 만들어 나가겠습니다^^ 이번 포스팅에서는 안

altongmon.tistory.com

서버에 이미지를 보낼 때, 파일? 바이트 코드?

코오오 코오 — Tue, 9 May 2023 16:23:18 +0900

이미지를 서버로 보낼 때 이미지 데이터를 전송하기 위한 여러 옵션이 있습니다. 이미지를 저장된 파일로 보내거나 획득한 바이트 데이터를 직접 보낼 수 있습니다. 두 접근 방식 모두 장점과 고려 사항이 있습니다.

저장 파일로 보내기:
- 이 방법에서는 캡처한 이미지를 장치의 저장소에 파일로 저장한 다음 파일을 서버로 보냅니다.
- 장점:
  - 파일을 보내면 전체 바이트 데이터를 메모리에서 관리할 필요 없이 큰 이미지 크기를 쉽게 처리할 수 있습니다.
  - 다른 파일 업로드와 마찬가지로 서버에서 이미지 파일을 처리하고 처리할 수 있습니다.
  - 파일을 서버로 보낼 때 파일과 함께 메타데이터 및 추가 정보를 추가할 수 있습니다.
- 고려 사항:
  - 이미지를 파일로 저장하려면 기기의 저장 공간이 필요합니다.
  - 이미지 파일 저장 및 읽기에는 추가 디스크 I/O 작업이 포함됩니다.
획득한 바이트 데이터 전송:
- 이 방법은 캡처된 이미지에서 얻은 바이트 데이터를 파일로 저장하지 않고 직접 전송합니다.
- 장점:
  - 바이트 데이터를 직접 전송하는 것은 이미지 데이터의 즉각적인 처리 또는 전송이 필요한 실시간 또는 스트리밍 시나리오를 처리할 때 유용할 수 있습니다.
  - 이미지를 디스크에 저장할 필요가 없으며 메모리를 더 효율적으로 사용할 수 있습니다.
- 고려 사항:
  - 바이트 데이터를 직접 보낼 때 서버의 허용된 요청 크기 제한 내에 맞아야 하므로 특히 큰 이미지의 경우 데이터 크기를 처리해야 합니다.
  - 요청의 일부로 전송하기 전에 바이트 데이터를 적절한 형식(예: Base64 인코딩)으로 변환해야 할 수 있습니다.
  - 서버는 바이트 데이터를 직접 수신하고 처리하기 위해 적절한 API 또는 엔드포인트를 가지고 있어야 합니다.

저장된 파일로 전송하거나 바이트 데이터를 직접 전송하는 것 중에서 선택하는 것은 서버의 기능 및 제약 조건, 이미지 크기, 네트워크 조건 및 원하는 처리 흐름과 같은 특정 요구 사항에 따라 다릅니다. 결정을 내릴 때 효율성, 확장성, 서버 측 처리 기능, 장치 및 네트워크 인프라의 한계와 같은 요소를 고려하십시오.

Chat GPT가 알려줬다. 내가 기억하려고 작성함.

산업경영론

코오오 코오 — Sun, 23 Apr 2023 22:29:01 +0900

제 1장 빠르게 변화하는 비즈니스 환경에서의 리스크에 대한 대응과 수익창출

비즈니스와 부의 창출
부의 창출에서 기업가의 중요성
기업과 환경
미국 기업의 변화과정
[부의 창출에 기업가가 미치는 중요성]
-생산의 5가지 요소
1.토지
2.노동
3.자본
4.기업가정신
5.지식

특히 자본이 압도적으로 중요하다.

제 2장 경제학 이해하기

경제시스템이 기업에 영향을 미치는 방법
자유시장 자본주의 이해
사회주의 이해
공산주의 이해
혼합경제로의 추세
[경제학 이해하기]
-아담 스미스와 부의 창출
경제에 가장 중요한 요소는 자유이다. 토지 및 부동산을 소유할 수 있는 자유와, 기업 이익을 소유할 수 있는 권리는 필수적인 것이다. 노력에 대한 댓가가 확실히 보장될 때 사람들은 열심히 일할 것이다.
-아담 스미스의 국부론 '보이지 않는 손' : 자기 중심적인 이익을 다수를 위한 사회적 경제적 이익으로 전환하는 과정.
사람들이 자신의 삶의 상황을 개선해 나가는 과정 속에서 제품이나 서비스, 또는 아이디어의 생산을 통해, 또는 자선 기부활동 등을 통해 경제 전체가 번영하는 데 도움을 주고 있음.
-이것이 적용된 사례
기업 소유주가 자신의 노력에 대한 보상을 '소유'하고 '지킬 수 있다'고 믿을 때 열심히 일하도록 동기부여된다고 한다.
ex)식당이 번창할 때 종업원을 더 채용하고, 가게가 성장한다. ->간접적으로 사회와 국가 경제에 기여한다.

-자유시장 자본주의의 4가지 기본권리
1.사유재산권 ->재산을 사유할 수 있다는 자본주의적 사실이 자본을 모으려는 노력을 부추긴다.
2.기업을 소유할 수 있는 권리, 이익을 모두 가질 수 있는 권리 ->노력에 대한 보상이 올곧게 돌아온다는 점이 열심히 일하도록 동기부여된다.
3.경쟁의 자유 ->다른 기업과 경쟁함으로서 더 나은 기업을 만들겠다는 동기부여된다.
4.선택의 자유 ->고객 입장에서 어떤 기업이든 선택할 수 있다는 점이 동기부여된다.

-자유시장의 작동원리
무엇을, 얼마만큼 생산할 것인지가 시장에 의해 결정된다.
소비자들은 무엇을 선호하고 얼마만큼 좋아하는지에 대한 신호를 보낸다.
가격은 기업에게 한 제품을 얼마만큼 생산할 것인지 알려준다.
어떤 상품이 필요하지만 구하기 어렵다면 더 많은 상품이 나오기 전까지 가격은 계속해서 상승하게 된다.
-가격결정.
수요, 공급, 시장가격. 공급곡선은 우상향곡선 수요곡선은 우하향곡선. 두 곡선이 만나는 균형점이 가격을 결정한다.
-자유경제시스템. 인플레이션과 가격지수
인플레이션 : 시간이 지남에 따라 제품과 서비스의 가격이 전반적으로 상승하는 현상. 화폐가치 하락, 상품가치 상승.
디스인플레이션 : 가격상승이 느려지는 현상
디플레이션 : 가격이 하락하는 현상
스태그플레이션 : 경기가 침체됨에도 불구하고 가격이 오르는 현상

-소비자물가지수(CPI) : 인플레이션 혹은 디플레이션의 정도를 매달 측정하는 통계수치
-핵심 인플레이션 : 소비자물가지수에서 식품과 에너지비용을 차감한것
-생산자 물가지수 : 도매물가의 변동을 측정한 지수

-케인즈 학파의 경제이론 : 정부지출을 늘리고 세금을 줄이는 정책은 경기침체기에 경기를 부양시킬 수 있다. 저서인 <고용,이자 및 화폐의 일반이론>에서 완전고용을 실현, 유지하기 위해서는 자유방임주의가 아닌 정부의 보완책(공공지출)이 필요하다고 주장하였다

제 3장 글로벌 시장에서의 비즈니스

다이나믹한 글로벌 시장
왜 다른 나라와 무역을 하는가?
글로벌 무역에 동참하기
글로벌 시장에 진출하기 위한 전략
글로벌 무역에 영향을 미치는 요인들
보호무역주의
글로벌 무역의 미래
왜 다른 국가와 무역을 하는가?
가장 잘 생산할 수 있는 것을 생산하고, 다른 필요한 것을 살 수 있도록 해준다.
-자유무역
-비교우위론과 절대우위론
비교우위론 : 한 국가는 자신이 가장 효율적으로 생산하는 생산품을 다른 나라에 팔고, 다른 나라로부터는 자신이 그만큼 효율적으로 생산할 수 없는 상품을 사와야한다.
절대우위론 : 한 국가가 특정 생산품에 대한 독점력을 가지고 있거나 다른 모든 나라보다 어떤 제품을 더 효율적으로 생산할 수 있어야 한다.
-글로벌 시장 진출 전략
라이센싱 수출 프랜차이징 위탁제조 전략적 제휴 해외직접투자
--------관여도, 통제력, 위험, 잠재수익의 양-------->
위탁제조, OEM(주문자가 설계, 기술, 특허 소유. 생산만 해라.) ODM(상표는 주문자, 개발은 제조자. 개발자 아이디어 있지만 브랜드는 없을 때)
바이오산업
CRO(위탁연구)
CDO(위탁개발)
CMO(위탁생산)

제 5장 사업 소유구조의 선택

기본적인 기업 소유구조
개인기업(개인사업자)
파트너쉽
주식회사
기업확장: 인수와 합병
프랜차이즈
협동조합
개인기업, 파트너십, 회사의 장단점
-개인사업자의 장점
1.사업 시작과 철수가 용이함
2.자신이 오너가 됨
3.사업체 소유의 자부심이 생김
4.사업 이익을 가질 수 있음
-개인 사업의 단점
1.무한 책임. 사업의 소유주가 사업체의 모든 채무를 부담해야함.
2.제한적 재무 자원. 아무리 자본이 많아도 공장을 세우거나 할 수 없음
3.경영의 어려움. 곡난도 회계
4.엄청난 시간 투자 필요
5.부가 혜택 없음
6.사업의 영속성 제약. 수명있음.

-파트너쉽(동업)의 장점
1.재무적 자원이 더 많아짐
2.공동경영 및 기술과 지식의 상호 보완 및 시너지 창출 가능
3.생존율 더 높아짐
4.특별세 없음
-파트너쉽의 단점
1.무한책임
2.이익분배
3.파트너간 의견 불일치
4.사업 청산의 어려움

-주식회사(전통적인 회사)의 장점
1.유한 책임
2.더 많은 투자금액 유치 가능
3.규모 큼
4.영속성 길다.
5.소유권 변경이 용이하다.
6.능력 있는 종업원을 유치할 수 있다.
7.소유와 경영이 분리되어있다.
-주식회사의 단점
1.초기 비용이 많이 든다.
2.방대한 서류 작업이 필요하다.
3.이중 과세
4.이중 납세 신고서
5.규모가 크다.
6.사업 청산에 어려움이 있다.
7.주주와 이사회와의 잠재적 갈등이 존재한다.

-프랜차이즈(서비스, 상호, 브랜드 권리를 판매)의 장점
1.관리 및 마케팅을 지원받는다.
2.그러면서 개인이 가게를 소유할 수 있다.
3.전국적 인지도가 쌓여있다.
4.재정 조언 및 지원을 받을 수 있다.
5.사업 실패율이 낮다.
-프랜차이즈의 단점
1.창업 비용이 높다.
2.이익을 공유해야 한다.
3.경영 규제가 있다.
4.연미복 효과가 있다.
5.매각에 제약이 있다.
6.프랜차이즈 본사의 부정을 탈 수 있다.

제 6장 기업가정신과 중소기업 창업

미국 기업가들의 일자리 창출 능력
사람들이 기업가가 되기 위해 도전하는 이유
소규모 기업 창업
소기업 운영에 관해 배우기
소기업 경영하기
글로벌 진출 : 소기업의 전망
중소기업의 성공과 실패
-실패이유
경영능력 부족, 불충분한 자금 계획, 잘못된 업종 선택
-중소기업을 잘 경영하려면?
1.다른사람으로부터 배우기 : 중소기업과 창업에 관한 강좌 수강하기, 성공한 지역 사업가 밑에서 일하며 배우기
2.경험 쌓기 : 해당 분야에서 3년 정도 경험 쌓기, 이후 부업으로 소기업 창업하기
3.성공한 기업의 인수 : 견습생으로 봉사한 다음, 나중에 오너가 물러날 때 인수하기
또 실패이유가 뭘까?
-소규모 테스트 없이 시장 진입
-과소 혹은 과대 계상된 제품/서비스 가격
-시장을 구축하는데 필요한 시간을 간과
-자본금 부족
-과다한 자본금을 유치하고 올바른 사용처를 선정하지 않음
-경험 부족과 산업과 시장에 대한 학습 부재
-상환 시기와 방법을 구체적으로 계획하지 않고 차입
-부족한 자본금으로 사업 시작
-사업 유보금이나 예상치 못한 지출에 대한 대비 부재
-과다 신용 구매
-신용도 과다 연장
-신용도 급속히 소진
-정확하고 완벽한 기록 부재로 경영자가 문제 인식 못함
-개인적 낭비벽을 사업에서도 버리지 못함
-사업 주기에 대한 이해 부족
-세금, 보험, 기타 비용에 대한 이해 부족
-스스로 근무 시간을 조절하지 못하고 태만

창업 계획하기 - 사업계획서에 대하여
사업의 성격, 목표시장, 경쟁자에 비해 자사가 가진 우위, 오너가 가진 자원과 자격 등에 대해 자세히 적어 놓은 글.
잠재적 소유주가 구체적으로 무엇을 제공할 것인지 압박하는 수단이 된다.
은행가, 투자자와의 미팅 전 준비 필수 요건

좋은 사업 계획서 작성하기
1.좋은 계획서 작성을 위해서는 오랜 준비시간 필요
2.경영자에 대한 훌륭한 핵심 요약은 관심을 끌고 잠재 투자자들로 하여금 더 읽어보고싶게 유인함
3.사업계획서에 올바른 정보를 담는 것도 중요하지만 누구에게 제시하는가가 더 중요함(올바른 자금 조달처 찾기)
1)경영자 요약
2)회사 배경
3)경영 관리 팀
4)재무 계획
5)필수 자본
6)마케팅 계획
7)입지 분석
8)제조 계획
9)첨부
자금을 조달하기 위해서는 지역개발금융기관에서 특히 저소득 지역을 위해 자금을 대출해주고 자문도 제공한다.
-엔젤투자자 : 잠재적으로 유망한 기업들이 시장에 공개되기 전에 개인 자금을 투자하는 사람
-크라우드 펀딩 : 한 기업이나 제품을 지원하기 위해 다수의 개인들이 기부하는 돈
-벤처투자자 : 일정 지분을 댓가로 신규 기업에게 투자하는 개인 혹은 회사

제 7장 관리와 리더십

진화되는 관리자의 역할
관리의 4가지 기능
계획과 의사결정
조직: 통일된 체계 만들기
지휘: 지속적인 비전과 가치 제공
통제: 성과 지향
SWOT 분석 - 조직의 강점, 약점, 기회와 위협요인을 분석하기 위해 사용되는 계획 도구
리더십의 유형
1.전제적 리더십 : 다른 사람과 상의없이 독단적으로 의사결정을 내린다. 관리자가 결정 사항을 설득한다. 관리자가 의견을 제시하고 질문을 수행한다. 군대, 경찰 등 계급이 존재할 때 쓴다. 위 계급의 사람이 많이 알고, 숙련된 경우. 단순업무, 제조업에 적합하다. 명확한 지시와 지침이 필요한 신참이나, 위기 상황에 효과적이므로.
2.참여적 (민주적)리더심 : 관리자와 종업원이 협의하여 의사결정을 내린다. 관리자가 잠정적인 결정 사항에 대해 발표한다. 관리자가 문제를 제시하고 의견을 수렴한 후 의사를 결정한다. 관리자가 한계를 규정하고 그룹에 의사결정할 것을 부탁한다. 제일 많은 사례로, 합리적 지시를 수용하고, 무조건 수용하는 것은 아니다.
3.자유방임형 리더십 : 관리자가 설정한 목표를 달성하기 위해서라면 직원이 비교적 자유롭게 무엇이든지 할 수 있는 형태. 관리자가 상급자에 의해 규정된 범위 안에서 종업원들이 스스로 기능할 수 있도록 용인한다. 알아서하는데, 월말에 실적만 보자. 전문 영역이 다르므로, 터치하지 않는다. 보험, 영업직, 판매직, 전문직

관리자의 권한 행사가 많을수록, 상사 중심의 리더십이 되고, 종업원의 자유는 이에 반비례한다.

제 9장 생산 및 오퍼레이션스 관리

서비스업의 생산, 운영관리가 중요해진다. 이 때, 서비스는 고객의 흐름에 따라 흘러가므로, 고객이 서비스를 받기 위해 기다리고 있다면 생산이 잘 안되고 있다는 뜻이다.
서비스업인 호텔과 공항의 사례를 보면, 식당 서비스, 고급 엘리베이터, 신속한 프론트데스크, 로비 장식, 객실 푸드 등이 운영관리이다.

Greedy 알고리즘 - Huffman Code

코오오 코오 — Sun, 23 Apr 2023 16:43:20 +0900

greedy 알고리즘 일곱 번째 문제

7.Huffman Code

-텍스트를 압축할때, 파일에 빈번히 나타나는 문자에는 짧은 이진 코드를 할당하고

드물게 나타나는 문자에는 긴 이진 코드를 할당하는 것이다.

-이 때 문자를 표현하기 위해 트리를 이용한다.

-방법 1. min-priority queue를 사용하는 방법

1.각 문자 당 노드를 만들고, 그 문자의 빈도수를 노드에 저장
2.n개의 노드의 빈도수에 대해 우선순위 큐 Q를 만든다.
while(Q에 있는 노드 수 >=2){
  빈도수가 가장 작은 2개의 노드 (A와 B)를 Q에서 제거.
  새 노드 N을 만들고, A와 B를 N의 자식 노드로 만든다.
  N의 빈도수 = A의 빈도수 +B의 빈도수
  노드N을 Q에 삽입한다.}
return Q

-Time Complexity

n개 노드 만들기 : O(n)

heap 만들기. Insert n번 발생 : Nlogn

Q에 있는 노드 수가 1개 남을때까지 반복. : O(n)

반복 안에서 Delete, Insert 수행 : O(logn)+O(logn)

=O(n)+O(nlogn)+n{O(logn)+O(logn)} = O(nlogn)

-전체 흐름

-방법2 Sorting을 사용하는 방법

1.Initial Sequence T sorted by frequency//빈도수에 따라 오름차순 정렬
2.while(#of T>=){//T가 하나 남을때까지 반복
3.  Combine lowest two into sub-tree //가장 작은 2개를 sub tree에 넣고 더해
4.  Move it correct place} //다시 insert
5.return T

-Time Complexity

1.정렬 : O(nlogn)

2.2line부터 n번 반복

3. constant

4.삽입 : O(logn)

=O(nlogn)+O(nlogn)=O(nlogn)

-전체 흐름