본문 바로가기
Programing/Go

[GoLang] 2024년 Golang 배우기 10대 프로젝트 아이디어

by 멍멍돌이야 2024. 6. 10.
반응형

 

동적 웹 애플리케이션 구축

웹 애플리케이션은 온라인 상호 작용 및 작업 수행을 허용하는 웹 브라우저 기반 소프트웨어 프로그램입니다. 여기에는 Facebook과 같은 소셜 미디어 사이트나 Amazon과 같은 전자 상거래 사이트 등 다양한 것들이 포함되며 기본 HTML 페이지부터 복잡한 시스템까지 모든 것이 포함됩니다. 웹 앱은 동적 콘텐츠와 상호 작용을 생성하기 위해 다양한 프로그래밍 언어와 프레임워크로 개발되었으며, 데이터베이스와 자주 연결하여 데이터를 저장하고 필요할 때 검색합니다. 이를 통해 다양한 플랫폼에서 온라인 쇼핑, 소셜 네트워킹, 뱅킹 등을 쉽게 수행할 수 있습니다. 오늘날 세계의 디지털 환경을 형성하는 원활한 사용자 경험을 염두에 두고 반응형 디자인과 서버 측 처리 기능을 갖추고 있습니다.

 

RESTful API 개발

현대의 웹 개발에는 RESTful API 개발이 필수적인 부분이므로 인터넷을 통해 통신할 수 있는 웹 서비스를 구축하기 위한 일관된 방법을 제공해야 합니다. REST는 Representational State Transfer의 약자로, 상태 비저장 클라이언트-서버 통신, 균일한 인터페이스, 리소스 조작을 허용하는 사전 정의된 작업에 초점을 맞춘 아키텍처 스타일입니다. 분산 시스템, 모바일 애플리케이션 및 웹 서비스 구축에 RESTful API가 선호되는 주된 이유는 확장성, 클라이언트 친화성 및 유연성 때문입니다.

 

package main

import (
	"net/http"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	r.GET("/hello", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "Hello, World!"})
	})
	r.Run(":8080")
}

 

URL 단축기

URL을 단축하여 관리 가능한 링크로 변환하는 웹 서비스를 URL 단축기라고 합니다. 단축된 URL은 사용자가 클릭하면 원래의 긴 URL로 연결됩니다. 긴 URL을 더 쉽게 공유할 수 있도록 문자 제한이 있는 소셜 미디어에서 자주 사용됩니다. 일반적으로 URL 단축기에는 저장 및 검색 중에 URL의 전체 텍스트에 대한 대체 수단으로 사용하는 고유 식별자 또는 코드가 있습니다. 이는 URL을 공유하고 클릭 통계를 추적하는 쉬운 방법을 제공하기 때문에 마케팅 전략, 제휴 링크 및 복잡한 URL 정렬에 필수적인 도구입니다.

package main

import (
	"net/http"
	"math/rand"
	"time"
	"github.com/gin-gonic/gin"
)

var urlMap = make(map[string]string)

func main() {
	rand.Seed(time.Now().UnixNano())
	r := gin.Default()
	r.POST("/shorten", shortenURL)
	r.GET("/:shortURL", redirectURL)
	r.Run(":8080")
}

func shortenURL(c *gin.Context) {
	longURL := c.PostForm("url")
	shortURL := generateShortURL()
	urlMap[shortURL] = longURL
	c.JSON(http.StatusOK, gin.H{"shortURL": shortURL})
}

func redirectURL(c *gin.Context) {
	shortURL := c.Param("shortURL")
	longURL, ok := urlMap[shortURL]
	if !ok {
		c.JSON(http.StatusNotFound, gin.H{"message": "Short URL not found"})
		return
	}
	c.Redirect(http.StatusMovedPermanently, longURL)
}

func generateShortURL() string {
	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	shortURL := make([]byte, 6)
	for i := range shortURL {
		shortURL[i] = charset[rand.Intn(len(charset))]
	}
	return string(shortURL)
}

이 예에서는 다음과 같습니다.

  • POST /shorten: 긴 URL을 허용하고 이에 대한 짧은 URL을 생성합니다.
  • GET /:shortURL: 단축 URL로 접속 시 해당 긴 URL로 리디렉션됩니다.

이 코드는 짧은 URL을 나타내는 임의의 6자 문자열을 생성합니다. 단순화를 위해 짧은 URL과 해당하는 긴 URL이 맵에 저장됩니다.

 

명령줄 인터페이스(CLI) 도구

텍스트 기반 인터페이스를 통해 실행되도록 의도적으로 만들어진 명령줄 인터페이스(CLI) 도구라는 소프트웨어가 있습니다. 이를 통해 개인은 그래픽을 사용하지 않고도 컴퓨터나 프로그램에 연결할 수 있습니다. 사용자가 터미널 프롬프트나 명령줄에 입력한 명령이 허용되며, CLI 도구는 기본 파일 조작부터 복잡한 시스템 관리 작업까지 다양한 작업을 실행할 수 있습니다. 따라서 CLI 도구는 고급 사용자와 개발자가 시스템 리소스를 완전히 제어하고 그래픽 사용자 인터페이스를 사용하지 않고도 작업을 빠르게 자동화하고 실행할 수 있도록 지원합니다. CLI 도구는 효율성, 적응성, 스크립팅 및 자동화 워크플로와의 원활한 통합으로 인해 컴퓨터 시스템에서 흔히 볼 수 있습니다.

 

파일 시스템 유틸리티

Golang에서 파일 시스템 유틸리티 CLI 도구를 생성하려면 표준 라이브러리의 os 및 path/filepath 패키지를 사용하여 파일 나열, 디렉터리 생성, 파일 이동 등의 작업을 수행해야 합니다. 아래 예는 Golang의 매우 기본적인 파일 시스템 유틸리티 CLI 도구에 대한 것입니다.

package main

import (
	"bufio"
	"fmt"
	"os"
	"path/filepath"
)

func main() {
	fmt.Println("Welcome to File System Utility CLI Tool!")
	reader := bufio.NewReader(os.Stdin)
	
    for {
		fmt.Print("\nEnter command (ls, mkdir, mv, exit): ")
		command, _ := reader.ReadString('\n')
		command = trimNewline(command)
		switch command {
		case "ls":
			listFiles()
		case "mkdir":
			makeDirectory(reader)
		case "mv":
			moveFile(reader)
		case "exit":
			fmt.Println("Exiting...")
			return
		default:
			fmt.Println("Invalid command. Please try again.")
		}
	}
}

func listFiles() {
	files, err := filepath.Glob("*")
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("Files in the current directory:")
	for _, file := range files {
		fmt.Println("-", file)
	}
}

func makeDirectory(reader *bufio.Reader) {
	fmt.Print("Enter directory name: ")
	dirName, _ := reader.ReadString('\n')
	dirName = trimNewline(dirName)
	err := os.Mkdir(dirName, 0755)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Directory created successfully:", dirName)
}

func moveFile(reader *bufio.Reader) {
	fmt.Print("Enter source file name: ")
	srcFileName, _ := reader.ReadString('\n')
	srcFileName = trimNewline(srcFileName)
	fmt.Print("Enter destination directory: ")
	destDir, _ := reader.ReadString('\n')
	destDir = trimNewline(destDir)

	err := os.Rename(srcFileName, filepath.Join(destDir, srcFileName))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	fmt.Println("File moved successfully.")
}

func trimNewline(s string) string {
	return s[:len(s)-1]
}

 

이 CLI 도구는 현재 디렉터리( ls 명령), 디렉토리 생성( mkdir 명령), 파일을 다른 디렉터리로 이동( mv명령). 사용자는 터미널을 통해 대화형으로 명령을 입력할 수 있습니다.

 

텍스트 처리 도구

텍스트를 처리하기 위해 Golang 기반의 CLI 도구를 설계하려면 어려운 작업과 관련된 정규식과 관련된 문자열 값을 포함하여 문자열 값을 변경하는 함수를 사용하는 것이 포함됩니다.

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	fmt.Println("Welcome to Text Processing CLI Tool!")
	reader := bufio.NewReader(os.Stdin)

	for {
		fmt.Print("\nEnter command (count, reverse, uppercase, lowercase, exit):")
		command, _ := reader.ReadString('\n')
		command = trimNewline(command)

		switch command {
		case "count":
			countWords(reader)
		case "reverse":
			reverseText(reader)
		case "uppercase":
			convertCase(reader, strings.ToUpper)
		case "lowercase":
			convertCase(reader, strings.ToLower)
		case "exit":
			fmt.Println("Exiting...")
			return
		default:
			fmt.Println("Invalid command. Please try again.")
		}
	}
}

func countWords(reader *bufio.Reader) {
	fmt.Print("Enter text: ")
	text, _ := reader.ReadString('\n')
	text = trimNewline(text)
	words := strings.Fields(text)
	fmt.Println("Number of words:", len(words))
}

func reverseText(reader *bufio.Reader) {
	fmt.Print("Enter text: ")
	text, _ := reader.ReadString('\n')
	text = trimNewline(text)

	reversed := reverseString(text)
	fmt.Println("Reversed text:", reversed)
}

func convertCase(reader *bufio.Reader, convertFunc func(string) string) {
	fmt.Print("Enter text: ")
	text, _ := reader.ReadString('\n')
	text = trimNewline(text)
    
	converted := convertFunc(text)
	fmt.Println("Converted text:", converted)
}

func trimNewline(s string) string {
	return strings.TrimSuffix(s, "\n")
}

func reverseString(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

 

데이터 기반 애플리케이션

데이터 기반 애플리케이션은 데이터를 주요 자산으로 활용하여 의사 결정을 알리고, 사용자 경험을 개선하고, 비즈니스 결과를 도출하는 소프트웨어 프로그램입니다. 이러한 애플리케이션은 의미 있는 방식으로 데이터를 수집, 처리, 분석하여 사용자나 다른 시스템에 제공합니다. 데이터 기반 애플리케이션은 데이터베이스, API, 센서 또는 사용자 상호 작용과 같은 다양한 소스의 데이터를 활용하여 조직이 통찰력을 얻고 프로세스를 최적화하며 개인화된 서비스를 제공할 수 있도록 지원합니다. 그들은 종종 데이터 시각화, 기계 학습, 예측 분석과 같은 기술을 사용하여 귀중한 통찰력을 추출하고 정보에 입각한 조치를 취함으로써 기업이 데이터 기반 결정을 내리고 오늘날의 디지털 환경에서 경쟁력을 유지할 수 있도록 지원합니다.

 

실시간 데이터 스트림 처리

우선, 실시간 데이터 스트림 처리는 생성되는 연속적인 데이터 스트림을 처리하여 즉각적인 분석, 처리 및 대응을 제공하는 방법입니다. 위한 Go 채널과 같은 다양한 라이브러리 및 프레임워크를 사용할 수 있습니다. 웹 소켓 연결을 위한 Gorilla WebSocket, 동시성을 그리고 카프카 또는 Go에서 실시간 데이터 스트림 처리를 구현하기 위한 메시지 중개용 NATS입니다. 다음은 Go를 사용하여 간단한 애플리케이션을 구축하는 방법을 보여주는 기본 예입니다.

 

package main

import (
	"fmt"
	"log"
	"net/http"
	"time"
	"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("Error upgrading to WebSocket:", err)
		return
	}
	defer conn.Close()

	for {
		// Simulate real-time data stream
		message := "New data: " + time.Now().Format(time.RFC3339)
		if err := conn.WriteMessage(websocket.TextMessage, []byte(message)); err != nil {
			log.Println("Error writing message to WebSocket:", err)
			return
		}
		time.Sleep(1 * time.Second) // Simulate data stream frequency
	}
}

func main() {
	http.HandleFunc("/ws", handleWebSocket)
	fmt.Println("Starting server on port 8080...")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		log.Fatal("Error starting server:", err)
	}
}

 

이 예에서는:

  1. /ws를 통해 WebSocket 연결을 수신하는 HTTP 서버가 설치되었습니다.
  2. 연결이 설정되면 서버는 항상 매초마다 실시간 데이터를 클라이언트에 보냅니다.
  3. 실시간 데이터가 도착하면 클라이언트에서 이를 처리하고 처리할 수 있습니다.

이는 Go에서 실시간 데이터 스트림 처리를 수행하는 방법을 보여주는 간단한 예입니다. 실제로는 이를 실제 데이터 소스, 처리 논리 및 확장성과 안정성을 위한 메시지 브로커와 통합할 수 있습니다.

 

데이터 분석 및 시각화 도구

Go에서 데이터 분석 및 시각화 도구를 개발하기 위해 개발자는 데이터 조작, 분석 및 시각화용 라이브러리를 사용할 수 있습니다. Go에서 데이터 조작에 널리 사용되는 패키지는 다음과 같습니다. gonum.org/v1/gonum다양한 수학적 함수와 데이터 구조를 가지고 있습니다. 플롯과 차트를 만들려면 다음을 사용하는 것이 강력합니다. github.com/gonum/plot시각화를 위한 라이브러리로. Go에서 데이터 분석 및 시각화 도구를 작성하는 간단한 예를 보여드리겠습니다.

 

package main

import (
	"fmt"
	"log"
	"math/rand"
	"os"

	"gonum.org/v1/gonum/stat"
	"gonum.org/v1/plot"
	"gonum.org/v1/plot/plotter"
	"gonum.org/v1/plot/vg"
)

func main() {
	// Generate sample data
	data := make([]float64, 100)
	for i := range data {
		data[i] = rand.NormFloat64()
	}

	// Calculate mean and standard deviation
	mean := stat.Mean(data, nil)
	stdDev := stat.StdDev(data, nil)

	fmt.Printf("Mean: %.2f\n", mean)
	fmt.Printf("Standard Deviation: %.2f\n", stdDev)

	// Create histogram
	hist := plotter.Values(data)
	p, err := plot.New()
	if err != nil {
		log.Fatal(err)
	}
	p.Title.Text = "Histogram"
	p.X.Label.Text = "Value"
	p.Y.Label.Text = "Frequency"
	histogram, err := plotter.NewHist(hist, 16)
	if err != nil {
		log.Fatal(err)
	}
	p.Add(histogram)

	// Save histogram to a file
	if err := p.Save(8*vg.Inch, 4*vg.Inch, "histogram.png"); err != nil {
		log.Fatal(err)
	}

	fmt.Println("Histogram saved as histogram.png")
}

 

이 예에서는 다음과 같습니다.

  1. 예를 들어, rand.NormFloat64() 함수를 적용하여 무작위 샘플 데이터를 생성합니다.
  2. 다음의 기능을 사용하여 gonum.org/v1/gonum/stat 패키지에서는 데이터의 평균과 표준편차가 계산됩니다.
  3. 데이터 히스토그램은 다음을 사용하여 생성됩니다. gonum.org/v1/plot 패키지.
  4. 히스토그램을 이미지 파일(histogram.png)로 저장합니다.

이는 Go 프로그래밍 언어로 데이터를 분석하고 표시하는 방법을 보여주는 간단한 예입니다. 개발에 관심이 있을 수 있는 고급 분석 기술 및 다양한 유형의 시각화 측면에서 특정 요구 사항에 따라 이 예를 자유롭게 확장하십시오.

 

DevOps 살펴보기

소프트웨어 개발(Dev)과 IT 운영(Ops)의 통합은 DevOps 탐색을 특징으로 하며 이는 전체 소프트웨어 제공 주기를 더 단순하게 만드는 것을 목표로 합니다. 프로세스 자동화, 팀워크 강화, 효율성 향상을 강조하여 개발 프로세스 및 배포 속도를 높이는 데 도움이 됩니다. 다른 DevOps 방식에는 모니터링, 코드형 인프라, 지속적인 제공, 지속적인 통합 등이 포함됩니다. 개발자와 시스템 프로그래머 사이의 장벽이 제거되면 릴리스 주기가 빨라지고, 생산된 소프트웨어 제품의 신뢰성이 향상되며, IT 조직이 고객 요구 사항을 훨씬 쉽게 충족할 수 있습니다. 이러한 사고방식은 현재 디지털 시대의 고속 비즈니스 환경 개선을 촉진하는 혁신적인 협업 문화를 촉진합니다.

 

Golang용 CI/CD 파이프라인

CI/CD 파이프라인을 Go와 통합하려면 자동 빌드, 테스트 및 배포 프로세스가 필요합니다. 그러나 Jenkins, GitLab CI/CD 또는 GitHub Actions와 같은 다양한 도구를 사용하여 파이프라인을 조정할 수 있습니다. 다음은 GitHub Actions를 사용하여 Go 애플리케이션을 빌드하고 테스트하는 기본 CI/CD 파이프라인의 예입니다.

name: Go CI/CD Pipeline

on:
  push:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout repository
      uses: actions/checkout@v2
    - name: Set up Go
      uses: actions/setup-go@v2
      with:
        go-version: 1.17
    - name: Build
      run: go build -v ./...
    - name: Test
      run: go test -v ./...
  deploy:
    runs-on: ubuntu-latest
    needs: build
    if: github.ref == 'refs/heads/main'
    steps:
    - name: Deploy to server
      run: |
        # Add deployment script here

 

예를 들면 다음과 같습니다.

  1. 기본 분기에 푸시가 이루어질 때마다 파이프라인이 트리거됩니다.
  2. 빌드 작업에는 저장소 체크아웃, Go 설정, 애플리케이션 빌드 및 테스트 실행이 포함됩니다.
  3. 배포 작업은 빌드 작업에 따라 달라지며, 기본 분기에 푸시하는 경우 애플리케이션에 대한 배포를 적용합니다.

 

구성 관리도

이 파이프라인을 사용자 정의하려면 서버 또는 클라우드 플랫폼 배포를 활성화하는 단계를 추가해야 합니다. 또한 컨테이너화를 위한 Docker 또는 오케스트레이션을 위한 Kubernetes와 같은 다른 도구와 통합하여 Go 애플리케이션을 위한 엔드투엔드 CI/CD 파이프라인을 생성할 수 있습니다.

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
)

// Config represents the configuration settings
type Config struct {
	Database struct {
		Host     string `json:"host"`
		Port     int    `json:"port"`
		Username string `json:"username"`
		Password string `json:"password"`
	} `json:"database"`
	Server struct {
		Port int `json:"port"`
	} `json:"server"`
}

func main() {
	// Load configuration from file
	config, err := loadConfig("config.json")
	if err != nil {
		log.Fatal("Error loading configuration:", err)
	}

	// Print configuration settings
	fmt.Println("Database Configuration:")
	fmt.Println("Host:", config.Database.Host)
	fmt.Println("Port:", config.Database.Port)
	fmt.Println("Username:", config.Database.Username)
	fmt.Println("Password:", config.Database.Password)

	fmt.Println("\nServer Configuration:")
	fmt.Println("Port:", config.Server.Port)
}

func loadConfig(filename string) (*Config, error) {
	// Read configuration file
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

	// Unmarshal JSON data into Config struct
	var config Config
	if err := json.Unmarshal(data, &config); err != nil {
		return nil, err
	}

	return &config, nil
}
  1. 이 인스턴스는 데이터베이스 및 서버 구성을 포함하여 필요한 모든 정보를 보유하는 구성 구조체를 정의합니다.
  2. 또한 loadConfig 함수는 JSON 파일에서 구성을 읽고 이를 Config 구조에서 역마샬링합니다.
  3. config.json 파일에서 구성을 로드한 후 기본은 데이터베이스 및 서버의 구성을 포함하는 일부를 인쇄합니다.

이 모든 것 외에도 이 도구가 YAML 또는 TOML과 같은 다른 구성 형식을 지원하거나 환경 변수에서 구성을 읽도록 할 수 있습니다. 또한 구성 가능한 설정을 원격 서비스에서 로드할 수도 있습니다. 또한 구성에 대한 데이터 입력을 검증하는 데 도움이 되는 오류 처리와 검사가 이루어져야 합니다.

 

WebSocket을 사용하여 채팅 애플리케이션 구축

사용하여 채팅 애플리케이션을 구축하는 경우 WebSocket을 Go에서는 WebSocket 연결을 처리하는 서버와 연결하여 메시지를 주고받는 클라이언트를 생성해야 합니다. 기본 채팅 애플리케이션을 보여주는 간단한 예는 다음과 같습니다.

 

chat_server.go

package main

import (
	"log"
	"net/http"
	"github.com/gorilla/websocket"
)

var (
	upgrader = websocket.Upgrader{
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
	}
)

func main() {
	http.HandleFunc("/ws", handleWebSocket)
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Println("Error upgrading to WebSocket:", err)
		return
	}
	defer conn.Close()

	for {
		messageType, msg, err := conn.ReadMessage()
		if err != nil {
			log.Println("Error reading message:", err)
			break
		}

		if err := conn.WriteMessage(messageType, msg); err != nil {
			log.Println("Error writing message:", err)
			break
		}
	}
}

 

 

chat_client.go

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"time"
	"github.com/gorilla/websocket"
)

func main() {
	conn, _, err := websocket.DefaultDialer.Dial("ws://localhost:8080/ws", nil)
	if err != nil {
		log.Fatal("Error connecting to WebSocket:", err)
	}
	defer conn.Close()

	go func() {
		for {
			_, msg, err := conn.ReadMessage()
			if err != nil {
				log.Println("Error reading message:", err)
				return
			}
			fmt.Println("Received:", string(msg))
		}
	}()
	reader := bufio.NewReader(os.Stdin)
	for {
		fmt.Print("Enter message: ")
		message, _ := reader.ReadString('\n')
		message = message[:len(message)-1]

		err := conn.WriteMessage(websocket.TextMessage, []byte(message))
		if err != nil {
			log.Println("Error writing message:", err)
			return
		}

		time.Sleep(time.Second) // Delay to allow reading messages
	}

}

 

위의 예제를 실행하려면:

  1. 이름이 지정된 서버 코드를 저장합니다. chat_server.go 클라이언트 코드 이름은 chat_client.go.
  2. 두 개의 터미널 창을 열고 파일을 저장한 위치로 이동합니다.
  3. 한 터미널에서 다음을 입력하십시오. go run chat_server.go 서버를 시작합니다.
  4. 다른 터미널에서 다음을 입력하십시오. go run chat_client.go 클라이언트를 시작합니다.
  5. 클라이언트 터미널에서 메시지를 입력하고 서버로 보내면 다시 에코됩니다.

클라이언트로부터 받은 모든 메시지가 서버에 의해 다시 에코되는 간단한 채팅 프로그램의 한 예가 여기에 나와 있습니다. 필요한 경우 여러 클라이언트, 사용자 인증, 메시지 브로드캐스팅 또는 필요할 수 있는 기타 고급 기능을 지원하도록 확장할 수 있습니다.

 

 

Golang을 사용한 이미지 처리 및 컴퓨터 비전

GoCV 유명한 컴퓨터 비전 라이브러리인 OpenCV에 대한 Go 바인딩을 제공함으로써 이미지 처리 및 컴퓨터 비전과 관련된 작업을 수행하는 데 사용할 수 있는 대체 Go 라이브러리입니다. 다음은 GoCV를 사용한 기본 이미지 처리 시연입니다.

 

package main

import (
	"gocv.io/x/gocv"
)

func main() {
	// Read an image from file
	img := gocv.IMRead("input.jpg", gocv.IMReadColor)
	if img.Empty() {
		panic("Error reading image")
	}
	defer img.Close()

	// Convert the image to grayscale
	gray := gocv.NewMat()
	defer gray.Close()
	gocv.CvtColor(img, &gray, gocv.ColorBGRToGray)

	// Display the original and grayscale images
	window := gocv.NewWindow("Original")
	defer window.Close()
	window.IMShow(img)

	grayWindow := gocv.NewWindow("Grayscale")
	defer grayWindow.Close()
	grayWindow.IMShow(gray)

	// Wait for a key press to close the windows
	gocv.WaitKey(0)
}

 

 

위의 예에는 다음이 있습니다.

  1. GoCV를 사용하여 파일(input.jpg)에서 이미지를 로드하고 이를 회색조로 변환했습니다.
  2. 원본 이미지와 회색조 이미지를 별도의 창에 표시합니다.
  3. 프로그램은 키를 눌러 창을 닫을 때까지 기다립니다.

이 예제를 실행하려면 GoCV 시스템에 OpenCV를 설치해야 하며 OpenCV를 먼저 종속 항목으로 설치해야 합니다. 그런 다음 이 코드를 파일(예: image_processing.go)에 저장하고 go run 명령을 사용하여 실행합니다.

이것은 이미지 처리를 위한 Go 프로그래밍 언어에 대한 기본적인 소개일 뿐입니다. 언급된 작업을 해결하기 위해 객체 감지, 얼굴 인식 또는 이미지 분할과 같은 GoCV 및 OpenCV의 고급 속성을 사용해 볼 수도 있습니다.

 

출처: https://golang.withcodeexample.com/blog/golang-project-ideas/
728x90
반응형

'Programing > Go' 카테고리의 다른 글

[GoLang] Go에서 JSON 데이터를 구문 분석하는 방법  (0) 2024.06.10
[GoLang] 다양한 작업을 위한 10가지 일반적인 Go(Golang) 코드 조각  (0) 2024.06.10
[GoLang] Go의 go mod init 명령 이해  (0) 2024.06.10
[GoLang] Go 1.22에는 무엇이 들어있나요?  (0) 2024.06.10
[GoLang] "hello world" 출력  (0) 2024.06.08

관련글

댓글

티스토리툴바