mirror of
https://github.com/xiaoqidun/ofdgo.git
synced 2026-10-29 17:27:08 +08:00
xiaoqidun committed
1 parent
d07972346b
commit
70003486b8
37 files changed
+2386
-2509
No files matched your search
@@ -20,8 +20,20 @@ import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
"image"
|
||||
"math"
|
||||
"math/big"
|
||||
)
|
||||
|
||||
// PNGDensityChunkSize 为PNG像素密度块占用的字节数
|
||||
const PNGDensityChunkSize = 21
|
||||
|
||||
// Density 保存横纵像素密度，Unit为0表示比例、1表示每米像素数
|
||||
type Density struct {
|
||||
X, Y float64
|
||||
Unit byte
|
||||
}
|
||||
|
||||
// PageInfo 图片方向与像素密度，不改变原始编码
|
||||
type PageInfo struct {
|
||||
Orientation int
|
||||
@@ -232,3 +244,179 @@ func imageExifMetadata(data []byte, dpi float64, directory uint32) (int, float64
|
||||
}
|
||||
return orientation, x, y, nil
|
||||
}
|
||||
|
||||
// BMPDensity 提取已校验BMP头中的每米像素数
|
||||
// 入参: data 含至少40字节信息头的BMP编码
|
||||
// 返回: Density 像素密度, bool 密度是否可保留
|
||||
func BMPDensity(data []byte) (Density, bool) {
|
||||
xdpi, ydpi := int32(binary.LittleEndian.Uint32(data[38:42])), int32(binary.LittleEndian.Uint32(data[42:46]))
|
||||
if xdpi < 0 || ydpi < 0 {
|
||||
return Density{}, false
|
||||
}
|
||||
return Density{X: float64(xdpi), Y: float64(ydpi), Unit: 1}, true
|
||||
}
|
||||
|
||||
// TIFFConversionDensity 校验可转换的TIFF字段并提取规范化后的像素密度
|
||||
// 色彩配置、预乘透明度、扩展字段及其他目录需保留原始编码
|
||||
// 入参: data TIFF编码, layout 已校验的主图布局
|
||||
// 返回: Density PNG像素密度, bool 是否可完整转换
|
||||
func TIFFConversionDensity(data []byte, layout TIFFLayout) (Density, bool) {
|
||||
var density Density
|
||||
var order binary.ByteOrder = binary.LittleEndian
|
||||
if data[0] == 'M' {
|
||||
order = binary.BigEndian
|
||||
}
|
||||
if layout.Next != 0 || layout.Offset != order.Uint32(data[4:]) || layout.Reduced {
|
||||
return density, false
|
||||
}
|
||||
offset := int(layout.Offset)
|
||||
count := int(order.Uint16(data[offset:]))
|
||||
unit := uint32(2)
|
||||
var resolutions [2][2]uint32
|
||||
for i := range count {
|
||||
entry := data[offset+2+i*12 : offset+14+i*12]
|
||||
tag, kind, number := order.Uint16(entry), order.Uint16(entry[2:]), order.Uint32(entry[4:])
|
||||
value := order.Uint32(entry[8:])
|
||||
if kind == 3 && number == 1 {
|
||||
value = uint32(order.Uint16(entry[8:]))
|
||||
}
|
||||
switch tag {
|
||||
case 256, 257, 258, 259, 273, 274, 277, 278, 279, 320, 322, 323, 324, 325:
|
||||
case 262:
|
||||
if value == 5 {
|
||||
return density, false
|
||||
}
|
||||
case 254:
|
||||
if value != 0 {
|
||||
return density, false
|
||||
}
|
||||
case 255:
|
||||
if value != 1 {
|
||||
return density, false
|
||||
}
|
||||
case 266:
|
||||
if kind != 3 || number != 1 || value != 1 && value != 2 {
|
||||
return density, false
|
||||
}
|
||||
case 284:
|
||||
if kind != 3 || number != 1 || value != 1 && value != 2 {
|
||||
return density, false
|
||||
}
|
||||
case 292, 293:
|
||||
mask := uint32(7)
|
||||
if tag == 293 {
|
||||
mask = 2
|
||||
}
|
||||
if kind != 4 || number != 1 || value & ^mask != 0 {
|
||||
return density, false
|
||||
}
|
||||
case 317:
|
||||
if kind != 3 || number != 1 || value != 1 && value != 2 {
|
||||
return density, false
|
||||
}
|
||||
case 338:
|
||||
if kind != 3 || number != 1 || value != 2 {
|
||||
return density, false
|
||||
}
|
||||
case 339:
|
||||
if kind != 3 || number == 0 || number > 4 {
|
||||
return density, false
|
||||
}
|
||||
values := entry[8:]
|
||||
if number > 2 {
|
||||
if uint64(value)+uint64(number)*2 > uint64(len(data)) {
|
||||
return density, false
|
||||
}
|
||||
values = data[value:]
|
||||
}
|
||||
for j := uint32(0); j < number; j++ {
|
||||
if order.Uint16(values[j*2:]) != 1 {
|
||||
return density, false
|
||||
}
|
||||
}
|
||||
case 282, 283:
|
||||
if kind != 5 || number != 1 || uint64(value)+8 > uint64(len(data)) {
|
||||
return density, false
|
||||
}
|
||||
resolutions[tag-282] = [2]uint32{order.Uint32(data[value:]), order.Uint32(data[value+4:])}
|
||||
case 296:
|
||||
if kind != 3 || number != 1 || value < 1 || value > 3 {
|
||||
return density, false
|
||||
}
|
||||
unit = value
|
||||
default:
|
||||
return density, false
|
||||
}
|
||||
}
|
||||
if resolutions == [2][2]uint32{} {
|
||||
return density, true
|
||||
}
|
||||
x, y := resolutions[0], resolutions[1]
|
||||
if x[0] == 0 || x[1] == 0 || y[0] == 0 || y[1] == 0 {
|
||||
return density, false
|
||||
}
|
||||
if unit == 1 {
|
||||
a, b := uint64(x[0])*uint64(y[1]), uint64(y[0])*uint64(x[1])
|
||||
divisor, next := a, b
|
||||
for next != 0 {
|
||||
divisor, next = next, divisor%next
|
||||
}
|
||||
density.X, density.Y = float64(a/divisor), float64(b/divisor)
|
||||
} else {
|
||||
factor := 1 / 0.0254
|
||||
if unit == 3 {
|
||||
factor = 100
|
||||
}
|
||||
density = Density{X: float64(x[0]) / float64(x[1]) * factor, Y: float64(y[0]) / float64(y[1]) * factor, Unit: 1}
|
||||
}
|
||||
if math.Round(density.X) < 1 || math.Round(density.Y) < 1 || math.Round(density.X) > math.MaxInt32 || math.Round(density.Y) > math.MaxInt32 {
|
||||
return density, false
|
||||
}
|
||||
if layout.Orientation >= 5 {
|
||||
density.X, density.Y = density.Y, density.X
|
||||
}
|
||||
return density, true
|
||||
}
|
||||
|
||||
// Scale 按最终像素尺寸保留绝对密度或精确相对比例
|
||||
// 入参: before 原始像素尺寸, after 最终像素尺寸
|
||||
// 返回: Density 缩放后密度, bool 相对比例是否可完整保留
|
||||
func (density Density) Scale(before, after image.Point) (Density, bool) {
|
||||
hasDensity := density.X != 0 || density.Y != 0
|
||||
if hasDensity && before != after {
|
||||
if density.Unit == 0 {
|
||||
ratio := new(big.Rat).SetFrac64(int64(density.X)*int64(after.X), int64(density.Y)*int64(after.Y))
|
||||
ratio.Mul(ratio, new(big.Rat).SetFrac64(int64(before.Y), int64(before.X)))
|
||||
if ratio.Num().BitLen() > 31 || ratio.Denom().BitLen() > 31 {
|
||||
return density, false
|
||||
}
|
||||
density.X, density.Y = float64(ratio.Num().Int64()), float64(ratio.Denom().Int64())
|
||||
} else {
|
||||
density.X *= float64(after.X) / float64(before.X)
|
||||
density.Y *= float64(after.Y) / float64(before.Y)
|
||||
}
|
||||
}
|
||||
return density, true
|
||||
}
|
||||
|
||||
// WithPNGDensity 在无密度块的PNG头后插入pHYs，保留源编码不变
|
||||
// 入参: data 完整PNG编码, density 像素密度
|
||||
// 返回: []byte 带密度的编码, bool 密度是否可完整保留
|
||||
func WithPNGDensity(data []byte, density Density) ([]byte, bool) {
|
||||
x, y := math.Round(density.X), math.Round(density.Y)
|
||||
if x > math.MaxInt32 || y > math.MaxInt32 || density.X > 0 && x < 1 || density.Y > 0 && y < 1 {
|
||||
return nil, false
|
||||
}
|
||||
chunk := make([]byte, 21)
|
||||
binary.BigEndian.PutUint32(chunk, 9)
|
||||
copy(chunk[4:], "pHYs")
|
||||
binary.BigEndian.PutUint32(chunk[8:], uint32(x))
|
||||
binary.BigEndian.PutUint32(chunk[12:], uint32(y))
|
||||
chunk[16] = density.Unit
|
||||
binary.BigEndian.PutUint32(chunk[17:], crc32.ChecksumIEEE(chunk[4:17]))
|
||||
output := make([]byte, 0, len(data)+PNGDensityChunkSize)
|
||||
output = append(output, data[:33]...)
|
||||
output = append(output, chunk...)
|
||||
output = append(output, data[33:]...)
|
||||
return output, true
|
||||
}
|
||||
@@ -0,0 +1,285 @@
|
||||
// Copyright 2025-2026 肖其顿 (XIAO QI DUN)
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package image
|
||||
|
||||
import (
|
||||
"image"
|
||||
"image/color"
|
||||
"math"
|
||||
"slices"
|
||||
|
||||
"golang.org/x/image/draw"
|
||||
"golang.org/x/image/math/f64"
|
||||
)
|
||||
|
||||
// rasterScaleBufferLimit 限制整像素缩放器的浮点中间缓冲，超出时使用逐行采样
|
||||
const rasterScaleBufferLimit = 8 << 20
|
||||
|
||||
// rasterAxisSample 保存目标像素及其归一化源采样权重
|
||||
type rasterAxisSample struct {
|
||||
pixel int
|
||||
first int
|
||||
weights []float64
|
||||
}
|
||||
|
||||
// rasterImagePixel 保存未取整或裁切的预乘颜色累积值
|
||||
type rasterImagePixel struct {
|
||||
r, g, b, a float64
|
||||
}
|
||||
|
||||
// rasterImageRow 保存正在累积的目标行
|
||||
type rasterImageRow struct {
|
||||
sample rasterAxisSample
|
||||
values []rasterImagePixel
|
||||
}
|
||||
|
||||
// rasterImageSource 为通用图片提供预乘十六位采样
|
||||
type rasterImageSource struct{ image.Image }
|
||||
|
||||
// RGBA64At 读取通用颜色的原始预乘分量
|
||||
// 入参: x 横向坐标, y 纵向坐标
|
||||
// 返回: color.RGBA64 预乘颜色
|
||||
func (s rasterImageSource) RGBA64At(x, y int) color.RGBA64 {
|
||||
r, g, b, a := s.At(x, y).RGBA()
|
||||
return color.RGBA64{R: uint16(r), G: uint16(g), B: uint16(b), A: uint16(a)}
|
||||
}
|
||||
|
||||
// drawRasterAxisImage 按像素中心进行轴向缩小，逐行复用横向采样并保留镜像与小数坐标
|
||||
// 入参: dst 目标图像, src 源图像, m 像素变换, op 合成操作
|
||||
// 返回: bool 是否使用轴向采样
|
||||
func drawRasterAxisImage(dst draw.Image, src image.Image, m [6]float64, op draw.Op) bool {
|
||||
sx, sy := math.Abs(m[0]), math.Abs(m[3])
|
||||
if m[1] != 0 || m[2] != 0 || sx == 0 || sy == 0 || sx > 1 || sy > 1 || sx == 1 && sy == 1 {
|
||||
return false
|
||||
}
|
||||
for _, v := range m {
|
||||
if math.IsNaN(v) || math.IsInf(v, 0) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
b := src.Bounds()
|
||||
if b.Empty() {
|
||||
return true
|
||||
}
|
||||
r := TransformBounds(b, m, dst.Bounds())
|
||||
if r.Empty() {
|
||||
return true
|
||||
}
|
||||
xs := rasterImageAxis(r.Min.X, r.Max.X, b.Min.X, b.Max.X, m[0], m[4])
|
||||
ys := rasterImageAxis(r.Min.Y, r.Max.Y, b.Min.Y, b.Max.Y, m[3], m[5])
|
||||
if len(xs) == 0 || len(ys) == 0 {
|
||||
return true
|
||||
}
|
||||
if m[3] < 0 {
|
||||
slices.Reverse(ys)
|
||||
}
|
||||
pixels, ok := src.(image.RGBA64Image)
|
||||
if !ok {
|
||||
pixels = rasterImageSource{src}
|
||||
}
|
||||
width := len(xs)
|
||||
horizontal := make([]rasterImagePixel, width)
|
||||
columns := make([]int, width)
|
||||
output := image.NewRGBA64(image.Rect(0, 0, width, 1))
|
||||
var active []rasterImageRow
|
||||
var free [][]rasterImagePixel
|
||||
next := 0
|
||||
for y := ys[0].first; next < len(ys) || len(active) != 0; y++ {
|
||||
if len(active) == 0 && y < ys[next].first {
|
||||
y = ys[next].first
|
||||
}
|
||||
for next < len(ys) && ys[next].first == y {
|
||||
var row []rasterImagePixel
|
||||
if n := len(free); n != 0 {
|
||||
row, free = free[n-1], free[:n-1]
|
||||
clear(row)
|
||||
} else {
|
||||
row = make([]rasterImagePixel, width)
|
||||
}
|
||||
active = append(active, rasterImageRow{sample: ys[next], values: row})
|
||||
next++
|
||||
}
|
||||
rasterImageHorizontal(horizontal, pixels, xs, y, columns)
|
||||
n := 0
|
||||
for _, row := range active {
|
||||
weight := row.sample.weights[y-row.sample.first]
|
||||
if weight != 0 {
|
||||
for x, value := range horizontal {
|
||||
p := &row.values[x]
|
||||
p.r += value.r * weight
|
||||
p.g += value.g * weight
|
||||
p.b += value.b * weight
|
||||
p.a += value.a * weight
|
||||
}
|
||||
}
|
||||
if y+1 == row.sample.first+len(row.sample.weights) {
|
||||
rasterImageWriteRow(dst, output, row.values, xs[0].pixel, row.sample.pixel, op)
|
||||
free = append(free, row.values)
|
||||
} else {
|
||||
active[n] = row
|
||||
n++
|
||||
}
|
||||
}
|
||||
active = active[:n]
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// rasterImageAxis 按连续源坐标生成CatmullRom权重，不对图像几何边界取整
|
||||
// 入参: first 目标起点, end 目标终点, source 源起点, limit 源终点, scale 缩放比例, offset 平移距离
|
||||
// 返回: []rasterAxisSample 轴向采样表
|
||||
func rasterImageAxis(first, end, source, limit int, scale, offset float64) []rasterAxisSample {
|
||||
result := make([]rasterAxisSample, 0, end-first)
|
||||
argument := math.Abs(scale)
|
||||
support := draw.CatmullRom.Support / argument
|
||||
for pixel := first; pixel < end; pixel++ {
|
||||
center := (float64(pixel) + .5 - offset) / scale
|
||||
if center < float64(source) || center >= float64(limit) {
|
||||
continue
|
||||
}
|
||||
center -= .5
|
||||
start := int(max(float64(source), math.Floor(center-support)))
|
||||
stop := int(min(float64(limit), math.Ceil(center+support)))
|
||||
weights := make([]float64, stop-start)
|
||||
total := 0.0
|
||||
for i := range weights {
|
||||
distance := math.Abs((float64(start+i) - center) * argument)
|
||||
if distance < draw.CatmullRom.Support {
|
||||
weights[i] = draw.CatmullRom.At(distance)
|
||||
total += weights[i]
|
||||
}
|
||||
}
|
||||
for i := range weights {
|
||||
weights[i] /= total
|
||||
}
|
||||
result = append(result, rasterAxisSample{pixel: pixel, first: start, weights: weights})
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// rasterImageHorizontal 按源列复用像素，保留各目标像素的权重累加顺序与中间精度
|
||||
// 入参: row 横向缓冲, src 源像素, samples 采样表, y 源行坐标, columns 活动列缓冲
|
||||
func rasterImageHorizontal(row []rasterImagePixel, src image.RGBA64Image, samples []rasterAxisSample, y int, columns []int) {
|
||||
clear(row)
|
||||
reversed := samples[0].first > samples[len(samples)-1].first
|
||||
start, end := samples[0].first, samples[0].first+len(samples[0].weights)
|
||||
for _, sample := range samples[1:] {
|
||||
start = min(start, sample.first)
|
||||
end = max(end, sample.first+len(sample.weights))
|
||||
}
|
||||
next, count := 0, 0
|
||||
for x := start; x < end; x++ {
|
||||
for next < len(samples) {
|
||||
index := next
|
||||
if reversed {
|
||||
index = len(samples) - next - 1
|
||||
}
|
||||
if samples[index].first > x {
|
||||
break
|
||||
}
|
||||
columns[count] = index
|
||||
count++
|
||||
next++
|
||||
}
|
||||
p := src.RGBA64At(x, y)
|
||||
n := 0
|
||||
for _, index := range columns[:count] {
|
||||
sample := samples[index]
|
||||
weight := sample.weights[x-sample.first]
|
||||
if weight != 0 {
|
||||
value := &row[index]
|
||||
value.r += float64(p.R) * weight
|
||||
value.g += float64(p.G) * weight
|
||||
value.b += float64(p.B) * weight
|
||||
value.a += float64(p.A) * weight
|
||||
}
|
||||
if x+1 < sample.first+len(sample.weights) {
|
||||
columns[n] = index
|
||||
n++
|
||||
}
|
||||
}
|
||||
count = n
|
||||
}
|
||||
}
|
||||
|
||||
// rasterImageWriteRow 在两轴采样完成后取整并使用标准预乘合成
|
||||
// 入参: dst 目标图像, output 行像素缓冲, values 累积颜色, x 横向起点, y 目标行坐标, op 合成操作
|
||||
func rasterImageWriteRow(dst draw.Image, output *image.RGBA64, values []rasterImagePixel, x, y int, op draw.Op) {
|
||||
for i, value := range values {
|
||||
output.SetRGBA64(i, 0, color.RGBA64{
|
||||
R: uint16(min(max(min(value.r, value.a)+.5, 0), 65535)),
|
||||
G: uint16(min(max(min(value.g, value.a)+.5, 0), 65535)),
|
||||
B: uint16(min(max(min(value.b, value.a)+.5, 0), 65535)),
|
||||
A: uint16(min(max(value.a+.5, 0), 65535)),
|
||||
})
|
||||
}
|
||||
draw.Draw(dst, image.Rect(x, y, x+len(values), y+1), output, image.Point{}, op)
|
||||
}
|
||||
|
||||
// DrawPixels 对轴向缩小使用可分离采样，其余变换保留通用路径
|
||||
// 入参: dst 目标图像, src 源图像, m 按a、b、c、d、e、f排列的像素变换, op 合成操作
|
||||
func DrawPixels(dst draw.Image, src image.Image, m [6]float64, op draw.Op) {
|
||||
b := src.Bounds()
|
||||
if dr, ok := rasterScaleBounds(b, m); ok {
|
||||
if dr.Intersect(dst.Bounds()).Empty() {
|
||||
return
|
||||
}
|
||||
draw.CatmullRom.Scale(dst, dr, src, b, op, nil)
|
||||
return
|
||||
}
|
||||
if drawRasterAxisImage(dst, src, m, op) {
|
||||
return
|
||||
}
|
||||
draw.CatmullRom.Transform(dst, f64.Aff3{m[0], m[2], m[4], m[1], m[3], m[5]}, src, b, op, nil)
|
||||
}
|
||||
|
||||
// rasterScaleBounds 检查变换是否可无几何取整地使用缩放器，并限制其中间缓冲
|
||||
// 入参: b 源边界, m 像素变换
|
||||
// 返回: image.Rectangle 缩放边界, bool 是否适用
|
||||
func rasterScaleBounds(b image.Rectangle, m [6]float64) (image.Rectangle, bool) {
|
||||
if b.Empty() || m[1] != 0 || m[2] != 0 || m[0] <= 0 || m[0] > 1 || m[3] <= 0 || m[3] > 1 || m[0] == 1 && m[3] == 1 {
|
||||
return image.Rectangle{}, false
|
||||
}
|
||||
x0, y0 := float64(m[0]*float64(b.Min.X))+m[4], float64(m[3]*float64(b.Min.Y))+m[5]
|
||||
x1, y1 := float64(m[0]*float64(b.Max.X))+m[4], float64(m[3]*float64(b.Max.Y))+m[5]
|
||||
for _, v := range [4]float64{x0, y0, x1, y1} {
|
||||
if v != math.Floor(v) || v < math.MinInt32 || v > math.MaxInt32 {
|
||||
return image.Rectangle{}, false
|
||||
}
|
||||
}
|
||||
if x1 <= x0 || y1 <= y0 || b.Dx() > math.MaxInt32 || b.Dy() > math.MaxInt32 || (x1-x0)*float64(b.Dy()) > rasterScaleBufferLimit/32 {
|
||||
return image.Rectangle{}, false
|
||||
}
|
||||
return image.Rect(int(x0), int(y0), int(x1), int(y1)), true
|
||||
}
|
||||
|
||||
// TransformBounds 计算采样器可能写入的像素范围，并在整数转换前裁至目标边界
|
||||
// 入参: source 原始像素边界, m 像素变换, target 目标边界
|
||||
// 返回: image.Rectangle 受影响的目标像素区域
|
||||
func TransformBounds(source image.Rectangle, m [6]float64, target image.Rectangle) image.Rectangle {
|
||||
minX, minY, maxX, maxY := math.Inf(1), math.Inf(1), math.Inf(-1), math.Inf(-1)
|
||||
for _, p := range [4]image.Point{source.Min, {X: source.Max.X, Y: source.Min.Y}, {X: source.Min.X, Y: source.Max.Y}, source.Max} {
|
||||
x := math.Floor(float64(m[0]*float64(p.X)) + float64(m[2]*float64(p.Y)) + m[4])
|
||||
y := math.Floor(float64(m[1]*float64(p.X)) + float64(m[3]*float64(p.Y)) + m[5])
|
||||
minX, minY = math.Min(minX, x), math.Min(minY, y)
|
||||
maxX, maxY = math.Max(maxX, x+1), math.Max(maxY, y+1)
|
||||
}
|
||||
minX, minY = math.Max(minX, float64(target.Min.X)), math.Max(minY, float64(target.Min.Y))
|
||||
maxX, maxY = math.Min(maxX, float64(target.Max.X)), math.Min(maxY, float64(target.Max.Y))
|
||||
if minX >= maxX || minY >= maxY {
|
||||
return image.Rectangle{}
|
||||
}
|
||||
return image.Rect(int(minX), int(minY), int(maxX), int(maxY))
|
||||
}
|
||||
Reference in new issue
Block a user