GO, le langage de Google qui mise sur la simplicité et l’efficacité

Comprendre Go avec un exemple de code

Comment savoir si une image contient un passage piéton ? Cette tâche peut-être réalisée simplement par un code Go. Pour comprendre la structure du code, il faut avoir quelques bases présentées rapidement ici :

Langage orienté objet

Un langage orienté objet est un langage de programmation qui permet de structurer et d’organiser un programme en utilisant des concepts d’objets et de classes. Ces concepts sont basés sur le paradigme de la programmation orientée objet (POO), qui est une approche de développement logiciel largement utilisée.

L’idée fondamentale de la programmation orientée objet est de modéliser le monde réel en utilisant des entités appelées objets. Un objet est une instance d’une classe, qui est une structure de données définissant les attributs (variables) et les comportements (méthodes) de l’objet. Par exemple, vous pourriez avoir une classe « Voiture » qui définit les attributs tels que la couleur, le modèle et la marque de la voiture, ainsi que les comportements tels que « démarrer » et « arrêter ».

Les objets interagissent entre eux en échangeant des messages. Par exemple, vous pourriez envoyer un message à un objet de la classe « Voiture » pour lui demander de démarrer en appelant la méthode « démarrer ». L’objet répondra alors en exécutant le code associé à cette méthode.

La programmation orientée objet offre plusieurs avantages. Elle permet une meilleure organisation du code en regroupant les données et les fonctionnalités associées dans des entités logiques. Elle favorise également la réutilisation du code, car les classes peuvent être héritées et étendues pour créer de nouvelles classes. De plus, elle permet de gérer la complexité des applications en divisant le code en petits modules interconnectés.

De nombreux langages de programmation populaires, tels que Java, C++, Python et Ruby, sont orientés objet et utilisent les concepts de classes et d’objets. La programmation orientée objet offre une approche flexible et modulaire pour développer des logiciels, permettant aux développeurs de créer des applications robustes et maintenables.

Un langage orienté objet est un langage de programmation qui facilite la modélisation du monde réel en utilisant des objets et des classes. Ces concepts permettent une meilleure organisation du code, une réutilisation facilitée et une gestion de la complexité plus efficace dans le développement logiciel.

Langage Go

Le code GO présenté en exemple commence par l’importation des packages nécessaires pour le traitement des images, la manipulation des fichiers et l’affichage des résultats. Ensuite, la fonction main() est définie, qui sera le point d’entrée du programme.

La fonction main() commence par ouvrir l’image à analyser à l’aide de la fonction os.Open(), en spécifiant le chemin du fichier image. Si une erreur se produit lors de l’ouverture du fichier, elle est gérée et une erreur est affichée. La fonction defer est utilisée pour s’assurer que le fichier est fermé à la fin de la fonction, quelle que soit l’issue.

Ensuite, l’image est lue à l’aide de la fonction jpeg.Decode(), qui prend le fichier ouvert en paramètre. Si une erreur se produit lors de la lecture de l’image, elle est gérée et une erreur est affichée.

Après avoir lu l’image, la fonction containsPedestrianCrossing() est appelée pour analyser l’image et déterminer si elle contient un passage piéton. Le résultat est ensuite affiché à l’écran.

La fonction containsPedestrianCrossing() prend l’image en tant que paramètre et effectue une boucle sur tous les pixels de l’image. La taille de l’image est déterminée à l’aide de la méthode Bounds(), qui renvoie les limites de l’image. Les dimensions de l’image (largeur et hauteur) sont ensuite extraites à partir des limites.

À l’aide de deux boucles imbriquées, chaque pixel de l’image est parcouru. La fonction img.At(x, y) est utilisée pour obtenir la couleur du pixel à la position (x, y). Les composantes de couleur rouge (R), verte (G) et bleue (B) sont extraites à l’aide de la fonction RGBA().

Chaque pixel est ensuite vérifié à l’aide de la fonction isPedestrianCrossingColor() pour déterminer s’il correspond à la couleur d’un passage piéton. Cette fonction prend les valeurs RVB du pixel en tant que paramètres et vérifie si elles se situent dans les plages de valeurs spécifiées pour la couleur d’un passage piéton. Si la couleur correspond, la fonction renvoie true, indiquant qu’un passage piéton a été détecté.

La fonction isPedestrianCrossingColor() compare les valeurs RVB du pixel avec les plages de valeurs spécifiées pour le passage piéton. Si les valeurs de chaque composante de couleur se situent dans les plages spécifiées, la fonction renvoie true, sinon elle renvoie false.

Finalement, si la fonction containsPedestrianCrossing() renvoie true, cela signifie qu’un passage piéton a été détecté dans l’image, et un message correspondant est affiché à l’écran. Sinon, si la fonction renvoie false, cela signifie qu’aucun passage piéton n’a été détecté.

package main

import (
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"log"
	"os"
)

func main() {
	// Ouvrir l'image
	file, err := os.Open("chemin/vers/votre/image.jpg")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// Lire l'image
	img, err := jpeg.Decode(file)
	if err != nil {
		log.Fatal(err)
	}

	// Analyser l'image pour détecter le passage piéton
	if containsPedestrianCrossing(img) {
		fmt.Println("L'image contient un passage piéton.")
	} else {
		fmt.Println("L'image ne contient pas de passage piéton.")
	}
}

func containsPedestrianCrossing(img image.Image) bool {
	bounds := img.Bounds()
	width, height := bounds.Max.X, bounds.Max.Y

	// Parcourir tous les pixels de l'image
	for y := 0; y < height; y++ {
		for x := 0; x < width; x++ { // Obtenir la couleur du pixel r, g, b, _ := img.At(x, y).RGBA() // Vérifier si le pixel correspond à la couleur d'un passage piéton if isPedestrianCrossingColor(r, g, b) { return true } } } return false } func isPedestrianCrossingColor(r, g, b, _ uint32) bool { // Définir les plages de valeurs RVB pour la couleur du passage piéton minR, maxR := 180, 255 minG, maxG := 180, 255 minB, maxB := 180, 255 // Vérifier si la couleur du pixel correspond à un passage piéton if int(r>>8) >= minR && int(r>>8) <= maxR && int(g>>8) >= minG && int(g>>8) <= maxG && int(b>>8) >= minB && int(b>>8) <= maxB {
		return true
	}

	return false
}

  

Note : Ces quelques lignes de code permettent de résoudre une opération complexe.

Ce code en Go permet donc d’ouvrir une image, de parcourir chaque pixel, de vérifier la couleur de chaque pixel pour détecter la présence d’un passage piéton et d’afficher le résultat de la détection. Il peut être utilisé comme point de départ pour développer des fonctionnalités plus avancées de détection de passage piéton dans des applications ou des systèmes de vision par ordinateur.