How to create heatmaps and density maps from image data in Go?

To create heatmaps and density maps from image data in Go, you can use third-party libraries like gocv and gonum.

Here is an example code that demonstrates how to create a heatmap and density map using the mentioned libraries:

package main

import (
	"fmt"
	"image"
	"image/color"
	"log"
	"math"
	"os"

	"github.com/gonum/matrix/mat64"
	"gocv.io/x/gocv"
)

func main() {
	// Load the image
	imgPath := "path_to_your_image.jpg"
	img := gocv.IMRead(imgPath, gocv.IMReadColor)
	if img.Empty() {
		log.Fatal("Cannot read the image: ", imgPath)
	}

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

	// Convert image to float64 matrix
	mat := mat64.NewDense(gray.Cols(), gray.Rows(), nil)
	for i := 0; i < gray.Rows(); i++ {
		for j := 0; j < gray.Cols(); j++ {
			val := float64(gray.GetUCharAt(i, j))
			mat.Set(j, i, val)
		}
	}

	// Normalize the matrix
	minVal, maxVal := mat.Min(), mat.Max()
	mat.Apply(func(i, j int, v float64) float64 {
		return (v - minVal) / (maxVal - minVal)
	}, mat)

	// Create heatmap
	heatmap := gocv.NewMatWithSize(len(mat.RawMatrix().Data), len(mat.RawMatrix().Data[0]), gocv.MatTypeCV8UC3)
	for i := 0; i < len(mat.RawMatrix().Data); i++ {
		for j := 0; j < len(mat.RawMatrix().Data[0]); j++ {
			pixelValue := uint8(mat.RawMatrix().Data[i][j] * 255)
			heatmap.SetUCharAt(i, j, pixelValue)
		}
	}

	// Create density map
	densityMap := image.NewGray(image.Rect(0, 0, img.Cols(), img.Rows()))
	for i := 0; i < img.Rows(); i++ {
		for j := 0; j < img.Cols(); j++ {
			val := mat.At(j, i)
			density := uint8(math.Sqrt(val) * 255)
			densityMap.Set(j, i, color.Gray{density})
		}
	}

	// Save the heatmap and density map
	heatmapPath := "path_to_save_heatmap.jpg"
	densityMapPath := "path_to_save_density_map.jpg"
	if ok := gocv.IMWrite(heatmapPath, heatmap); !ok {
		log.Fatal("Failed to save the heatmap")
	}
	if err := saveImage(densityMap, densityMapPath); err != nil {
		log.Fatal("Failed to save the density map: ", err)
	}

	fmt.Println("Heatmap and density map created successfully.")
}

func saveImage(img image.Image, path string) error {
	file, err := os.Create(path)
	if err != nil {
		return err
	}
	defer file.Close()
	return gocv.IMWrite(path, gocv.NewMatFromBytes(img.Bounds().Dx(), img.Bounds().Dy(), gocv.MatTypeCV8U, img.Pix))
}

Make sure to replace path_to_your_image.jpg, path_to_save_heatmap.jpg, and path_to_save_density_map.jpg with actual file paths.

This code loads the image, converts it to grayscale, normalizes it, and then creates a heatmap image and a density map. The heatmap assigns color values based on the normalized intensity values of the image. The density map uses the square root of the normalized intensity values to determine the pixel density.

You will need to have the gocv and gonum packages installed in your project to run this code. You can use the following commands to install them:

go get -u -d github.com/hybridgroup/gocv
cd $GOPATH/src/github.com/hybridgroup/gocv
make install

go get gonum.org/v1/gonum/...

After installing the dependencies, you can run the code and it will generate the heatmap and density map images.