用go和python实现在图片里藏图片

用python和go实现图片里藏图片的效果

python

import cv2
import numpy as np


def encode_image(show_image_path, hide_image_path, out_image_name):
    '''自动计算代码'''
    show_image = cv2.imread(show_image_path)

    hide_image = cv2.imread(hide_image_path)

    width, height = show_image.shape[:2]

    hide_image = cv2.resize(hide_image, (height, width), interpolation=cv2.INTER_CUBIC)

    show_image = show_image // 10 * 10

    hide_image = hide_image * (9 / 255)

    out_image = show_image + hide_image

    cv2.imwrite(out_image_name, out_image)

    '''
    # 手动计算代码
    
    show_image = cv2.imread(show_image_path)

    hide_image = cv2.imread(hide_image_path)

    shape = show_image.shape

    show_image_data = show_image.data.tolist()

    hide_image_data = hide_image.tolist()

    out_image = np.zeros((shape[0], shape[1], 3), dtype=np.uint8)

    for x in range(shape[0]):
        for y in range(shape[1]):
            show_point = show_image_data[x][y]
            hide_point = hide_image_data[x][y]
            new_show_r, new_show_g, new_show_b = [value // 10 * 10 for value in show_point]
            new_hide_r, new_hide_g, new_hide_b = [value * 9 / 255 for value in hide_point]

            out_point = new_hide_r + new_show_r, new_hide_g + new_show_g, new_show_b + new_hide_b
            out_image[x][y] = out_point

    cv2.imwrite(out_image_name, out_image)
    '''


def decode_image(target_image_path, show_image_name, hide_image_name):
    '''自动计算代码'''
    target_image = cv2.imread(target_image_path)

    show_image = target_image // 10 * 10

    hide_image = (target_image - show_image) * (255 / 9)

    cv2.imwrite(show_image_name, show_image)

    cv2.imwrite(hide_image_name, hide_image)

    '''
    # 手动计算代码
    target_image = cv2.imread(target_image_path)

    target_image_data = target_image.data.tolist()

    shape = target_image.shape

    show_image = np.zeros((shape[0], shape[1], 3), dtype=np.uint8)

    hide_image = np.zeros((shape[0], shape[1], 3), dtype=np.uint8)

    for x in range(shape[0]):
        for y in range(shape[1]):
            target_point = target_image_data[x][y]

            show_point = [value // 10 * 10 for value in target_point]
            hide_point = [(target - show_point[target_point.index(target)]) * 255 / 9 for target in
                          target_point]
            show_image[x][y] = show_point
            hide_image[x][y] = hide_point

    cv2.imwrite(show_image_name, show_image)
    cv2.imwrite(hide_image_name, hide_image)
    '''


if __name__ == '__main__':
    encode_image("a.png", "b.png", "c.png")
    decode_image("c.png", "d.png", "e.png")

golang

/*
分别获取两张照片的像素点的值,转成uint8
将显示的图片的个位数去掉,然后将隐藏图片的的uint8值根据255/9的比例缩小,此时,隐藏图片的值一定是小于10的
将去除了显示图片的个位数的值和刚刚隐藏图片的值相加,这样影藏图片就成功影藏到了显示图片里
最后生成新的图片
因为只是个位数相加,也不会大幅改变原来图片
将两张图片从新的图片里剥离,只需要反着来就可以了
*/

package main

import (
	"image"
	"image/color"
	"image/gif"
	"image/jpeg"
	"image/png"
	"os"
	"strings"
)

func main() {
	EncodeImage("a.png", "b.png", "c.png")
	DecodeImage("c.png", "d.png", "e.png")
}

// 将两张图片合成为一张图片
func EncodeImage(showImagePath, hideImagePath, outPutImagePath string) {

	showImage, err := os.Open(showImagePath)

	defer showImage.Close()

	if err != nil {
		panic(err)
	}

	showImageDecode, _, err := image.Decode(showImage)

	if err != nil {
		panic(err)
	}

	hideImage, err := os.Open(hideImagePath)

	defer hideImage.Close()

	if err != nil {
		panic(err)
	}

	hideImageDecode, _, err := image.Decode(hideImage)

	if err != nil {
		panic(err)
	}

	newImage := encodeImage(showImageDecode, hideImageDecode)

	targetFile, err := os.Create(outPutImagePath)

	defer targetFile.Close()

	if err != nil {
		panic(err)
	}

	if err := imageEncode(outPutImagePath, targetFile, newImage); err != nil {
		panic(err)
	}
}

// 将两张图片从一张图片里剥离
func DecodeImage(targetImagePath, showImagePath, hideImagePath string) {

	targetImage, err := os.Open(targetImagePath)

	if err != nil {
		panic(err)
	}

	defer targetImage.Close()

	targetImageDecode, _, err := image.Decode(targetImage)

	if err != nil {
		panic(err)
	}

	showImageRgba, hideImageRgba := decodeImage(targetImageDecode)

	showImage, err := os.Create(showImagePath)
	if err != nil {
		panic(err)
	}
	defer showImage.Close()

	hideImage, err := os.Create(hideImagePath)
	if err != nil {
		panic(err)
	}
	defer hideImage.Close()

	if err := imageEncode(showImagePath, showImage, showImageRgba); err != nil {
		panic(err)
	}

	if err := imageEncode(hideImagePath, hideImage, hideImageRgba); err != nil {
		panic(err)
	}

}

/*
图片编码
*/
func encodeImage(showImage, hideImage image.Image) *image.RGBA {

	// todo 将两张图片大小变成一样的

	outImageRgba := image.NewRGBA(showImage.Bounds())

	for x := 0; x < hideImage.Bounds().Dx(); x++ {

		for y := 0; y < hideImage.Bounds().Dy(); y++ {

			showPointRgba := showImage.At(x, y)

			showR, showG, showB, _ := showPointRgba.RGBA()

			showRUint8 := showR >> 8
			showGUint8 := showG >> 8
			showBUint8 := showB >> 8

			hidePointRgba := hideImage.At(x, y)

			hideR, hideG, hideB, _ := hidePointRgba.RGBA()

			hideRUint8 := hideR >> 8
			hideGUint8 := hideG >> 8
			hideBUint8 := hideB >> 8

			outValueFunc := func(showValue, hideValue uint8) uint8 {
				return showValue/10*10 + uint8(float32(hideValue)*9/255)
			}

			outG := outValueFunc(uint8(showRUint8), uint8(hideRUint8))
			outR := outValueFunc(uint8(showGUint8), uint8(hideGUint8))
			outB := outValueFunc(uint8(showBUint8), uint8(hideBUint8))

			outImageRgba.SetRGBA(x, y, color.RGBA{R: outR, G: outG, B: outB, A: 255})

		}
	}

	return outImageRgba
}

/*
图片解码
*/
func decodeImage(img image.Image) (*image.RGBA, *image.RGBA) {

	showImageRgba := image.NewRGBA(img.Bounds())

	hideImageRgba := image.NewRGBA(img.Bounds())

	for x := 0; x < img.Bounds().Dx(); x++ {
		for y := 0; y < img.Bounds().Dy(); y++ {

			pointRgba := img.At(x, y)

			r, g, b, _ := pointRgba.RGBA()

			trans := func(value uint32) (uint8, uint8) {

				newValue := value >> 8

				// 舍去当前数的个位数
				showValue := newValue / 10 * 10

				// 将舍去的个位数转成float32 进行比例转换
				hideValue := float32(newValue-showValue) * 255 / 9

				// 最后转成uint8返回
				newShowValue := uint8(showValue)

				newHideValue := uint8(hideValue)

				return newShowValue, newHideValue
			}

			showR, hideR := trans(r)
			showG, hideG := trans(g)
			showB, hideB := trans(b)

			showImageRgba.SetRGBA(x, y, color.RGBA{R: showR, G: showG, B: showB, A: 255})

			hideImageRgba.SetRGBA(x, y, color.RGBA{R: hideR, G: hideG, B: hideB, A: 255})

		}
	}

	return showImageRgba, hideImageRgba
}

func imageEncode(fileName string, file *os.File, rgba *image.RGBA) error {

	// 将图片和扩展名分离
	stringSlice := strings.Split(fileName, ".")

	// 根据图片的扩展名来运用不同的处理
	switch stringSlice[len(stringSlice)-1] {
	case "jpg":
		return jpeg.Encode(file, rgba, nil)
	case "jpeg":
		return jpeg.Encode(file, rgba, nil)
	case "gif":
		return gif.Encode(file, rgba, nil)
	case "png":
		return png.Encode(file, rgba)
	default:
		panic("不支持的图片类型")
	}
}

github