mirror of
https://github.com/xiaoqidun/ofdgo.git
synced 2026-10-30 01:27:26 +08:00
230 lines
7.9 KiB
Go
230 lines
7.9 KiB
Go
// 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 pdf
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/zlib"
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"math"
|
|
|
|
baseimage "github.com/xiaoqidun/ofdgo/internal/base/image"
|
|
"github.com/xiaoqidun/pdfgo"
|
|
)
|
|
|
|
// EncodeCMYKTIFF 将直接四色图像保存为十六位无损TIFF，不经过显示颜色转换
|
|
// 入参: ctx 取消上下文, source PDF源图像
|
|
// 返回: []byte 含ICC和非预乘透明度的TIFF，非四色图像为nil, error 解码或编码错误
|
|
func EncodeCMYKTIFF(ctx context.Context, source *pdfgo.Image) ([]byte, error) {
|
|
if ctx == nil || source == nil {
|
|
return nil, fmt.Errorf("missing CMYK image context or source")
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
if source.ImageMask {
|
|
return nil, nil
|
|
}
|
|
family, err := source.ColorSpaceFamily()
|
|
if err != nil || family != "DeviceCMYK" && family != "ICCBased" {
|
|
return nil, err
|
|
}
|
|
if family == "ICCBased" {
|
|
count, err := source.ColorSpaceComponents()
|
|
if err != nil || count != 4 {
|
|
return nil, err
|
|
}
|
|
}
|
|
components, err := source.DecodeComponentsViewContext(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if components.Space == nil || components.Space.Model != "DeviceCMYK" || components.Space.Components() != 4 || components.ColorantSpace != nil {
|
|
return nil, nil
|
|
}
|
|
bounds := components.Rect
|
|
width, height := bounds.Dx(), bounds.Dy()
|
|
if width <= 0 || height <= 0 || width > int(^uint(0)>>1)/10 || uint64(width) > uint64(^uint32(0))/10 || uint64(height) > uint64(^uint32(0)) {
|
|
return nil, fmt.Errorf("invalid CMYK TIFF dimensions")
|
|
}
|
|
profile := components.Space.ICCProfile(source.Intent)
|
|
count := 12
|
|
if len(profile) != 0 {
|
|
count++
|
|
}
|
|
bitsOffset := uint64(8 + 2 + count*12 + 4)
|
|
profileOffset := bitsOffset + 10
|
|
stripOffset := (profileOffset + uint64(len(profile)) + 1) &^ uint64(1)
|
|
if stripOffset > uint64(^uint32(0)) {
|
|
return nil, fmt.Errorf("CMYK TIFF profile exceeds size limit")
|
|
}
|
|
var compressed bytes.Buffer
|
|
writer := zlib.NewWriter(&compressed)
|
|
row := make([]byte, width*10)
|
|
for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
|
|
for x := bounds.Min.X; x < bounds.Max.X; x++ {
|
|
if (x-bounds.Min.X)%1024 == 0 {
|
|
if err := ctx.Err(); err != nil {
|
|
writer.Close()
|
|
return nil, err
|
|
}
|
|
}
|
|
values, alpha := components.ValuesAt(x, y)
|
|
pixel := row[(x-bounds.Min.X)*10:]
|
|
for channel, value := range [5]float64{values[0], values[1], values[2], values[3], alpha} {
|
|
if math.IsNaN(value) || math.IsInf(value, 0) || value < 0 || value > 1 {
|
|
writer.Close()
|
|
return nil, fmt.Errorf("invalid CMYK TIFF component")
|
|
}
|
|
binary.LittleEndian.PutUint16(pixel[channel*2:], uint16(math.Round(value*65535)))
|
|
}
|
|
}
|
|
if _, err := writer.Write(row); err != nil {
|
|
writer.Close()
|
|
return nil, err
|
|
}
|
|
if stripOffset+uint64(compressed.Len()) > uint64(^uint32(0)) {
|
|
writer.Close()
|
|
return nil, fmt.Errorf("CMYK TIFF exceeds size limit")
|
|
}
|
|
}
|
|
if err := writer.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := ctx.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
total := stripOffset + uint64(compressed.Len())
|
|
if total > uint64(^uint32(0)) || total > uint64(int(^uint(0)>>1)) {
|
|
return nil, fmt.Errorf("CMYK TIFF exceeds size limit")
|
|
}
|
|
data := make([]byte, int(total))
|
|
copy(data, "II")
|
|
binary.LittleEndian.PutUint16(data[2:], 42)
|
|
binary.LittleEndian.PutUint32(data[4:], 8)
|
|
binary.LittleEndian.PutUint16(data[8:], uint16(count))
|
|
entries := [][4]uint32{
|
|
{256, 4, 1, uint32(width)}, {257, 4, 1, uint32(height)},
|
|
{258, 3, 5, uint32(bitsOffset)}, {259, 3, 1, 8}, {262, 3, 1, 5},
|
|
{273, 4, 1, uint32(stripOffset)}, {277, 3, 1, 5}, {278, 4, 1, uint32(height)},
|
|
{279, 4, 1, uint32(compressed.Len())}, {284, 3, 1, 1}, {332, 3, 1, 1}, {338, 3, 1, 2},
|
|
}
|
|
if len(profile) != 0 {
|
|
entries = append(entries, [4]uint32{34675, 7, uint32(len(profile)), uint32(profileOffset)})
|
|
}
|
|
for i, entry := range entries {
|
|
p := data[10+i*12:]
|
|
binary.LittleEndian.PutUint16(p, uint16(entry[0]))
|
|
binary.LittleEndian.PutUint16(p[2:], uint16(entry[1]))
|
|
binary.LittleEndian.PutUint32(p[4:], entry[2])
|
|
binary.LittleEndian.PutUint32(p[8:], entry[3])
|
|
}
|
|
for i := range 5 {
|
|
binary.LittleEndian.PutUint16(data[int(bitsOffset)+2*i:], 16)
|
|
}
|
|
copy(data[int(profileOffset):], profile)
|
|
copy(data[int(stripOffset):], compressed.Bytes())
|
|
return data, nil
|
|
}
|
|
|
|
// StencilImage 按当前填充色读取模板图像，不分配整幅彩色样本
|
|
type StencilImage struct {
|
|
Source image.Image
|
|
Fill color.NRGBA64
|
|
}
|
|
|
|
// NativeImage 按源像素输出原生过程色，不分配完整显示颜色缓冲
|
|
type NativeImage struct {
|
|
Source *pdfgo.ImageProcess
|
|
Space *pdfgo.ColorSpace
|
|
}
|
|
|
|
// ColorModel 保留填充色和模板的有效采样精度
|
|
// 返回: color.Model 非预乘颜色模型
|
|
func (s *StencilImage) ColorModel() color.Model {
|
|
model := s.Source.ColorModel()
|
|
if s.Fill.R%257 == 0 && s.Fill.G%257 == 0 && s.Fill.B%257 == 0 && (model == color.GrayModel || model == color.NRGBAModel || model == color.RGBAModel) {
|
|
return color.NRGBAModel
|
|
}
|
|
return color.NRGBA64Model
|
|
}
|
|
|
|
// Bounds 返回模板图像的采样边界
|
|
// 返回: image.Rectangle 图像边界
|
|
func (s *StencilImage) Bounds() image.Rectangle { return s.Source.Bounds() }
|
|
|
|
// At 以模板灰度计算填充覆盖率，不重复变换颜色
|
|
// 入参: x 横向坐标, y 纵向坐标
|
|
// 返回: color.Color 非预乘颜色
|
|
func (s *StencilImage) At(x, y int) color.Color {
|
|
return s.NRGBA64At(x, y)
|
|
}
|
|
|
|
// NRGBA64At 直接读取模板覆盖率，保留填充色的有效精度
|
|
// 入参: x 横向坐标, y 纵向坐标
|
|
// 返回: color.NRGBA64 非预乘颜色
|
|
func (s *StencilImage) NRGBA64At(x, y int) color.NRGBA64 {
|
|
if !image.Pt(x, y).In(s.Bounds()) {
|
|
return color.NRGBA64{}
|
|
}
|
|
gray := baseimage.NRGBA64At(s.Source, x, y)
|
|
pixel := s.Fill
|
|
pixel.A = uint16(65535 - gray.R)
|
|
return pixel
|
|
}
|
|
|
|
// ColorModel 保留16位原生分量与源透明度
|
|
// 返回: color.Model 非预乘颜色模型
|
|
func (s *NativeImage) ColorModel() color.Model { return color.NRGBA64Model }
|
|
|
|
// Bounds 返回源图像的完整采样边界
|
|
// 返回: image.Rectangle 原始像素边界
|
|
func (s *NativeImage) Bounds() image.Rectangle { return s.Source.Bounds() }
|
|
|
|
// At 获取按OFD输出映射的原生颜色
|
|
// 入参: x 横坐标, y 纵坐标
|
|
// 返回: color.Color 非预乘颜色
|
|
func (s *NativeImage) At(x, y int) color.Color { return s.NRGBA64At(x, y) }
|
|
|
|
// NRGBA64At 按原始精度转换设备过程色，不进行页面采样或备用变换
|
|
// 入参: x 横坐标, y 纵坐标
|
|
// 返回: color.NRGBA64 非预乘颜色
|
|
func (s *NativeImage) NRGBA64At(x, y int) color.NRGBA64 {
|
|
if !image.Pt(x, y).In(s.Bounds()) {
|
|
return color.NRGBA64{}
|
|
}
|
|
values, alpha := s.Source.ValuesAt(x, y)
|
|
rgb, _ := OutputColor(s.Space, values)
|
|
return color.NRGBA64{R: uint16(math.Round(rgb[0] * 65535)), G: uint16(math.Round(rgb[1] * 65535)), B: uint16(math.Round(rgb[2] * 65535)), A: uint16(math.Round(alpha * 65535))}
|
|
}
|
|
|
|
// ImageProcessColorants 识别可在四色设备上直接绘制的专色色料
|
|
// 入参: image PDF图像
|
|
// 返回: [4]bool 参与绘制的四色通道, bool 是否全部属于印刷原色, error 色空间错误
|
|
func ImageProcessColorants(image *pdfgo.Image) ([4]bool, bool, error) {
|
|
source, err := image.ColorantSpace()
|
|
if err != nil {
|
|
return [4]bool{}, false, err
|
|
}
|
|
space := &pdfgo.ColorSpace{Model: "DeviceCMYK"}
|
|
process := source.PrepareProcess(&pdfgo.ColorantDevice{Space: space}, space, false)
|
|
mask := process.Mask()
|
|
return mask, mask != ([4]bool{}), nil
|
|
}
|