1092 lines
31 KiB
JavaScript
1092 lines
31 KiB
JavaScript
import { fabric } from "fabric-with-all";
|
||
import { findObjectById } from "../utils/helper";
|
||
import { createRasterizedImage } from "../utils/selectionToImage";
|
||
import { OperationType, SpecialLayerId } from "../utils/layerHelper";
|
||
|
||
/**
|
||
* 图片导出管理器
|
||
* 负责处理画布的图片导出功能，支持多种导出选项和图层过滤
|
||
*/
|
||
export class ExportManager {
|
||
constructor(canvasManager, layerManager) {
|
||
this.canvasManager = canvasManager;
|
||
this.layerManager = layerManager;
|
||
this.canvas = canvasManager.canvas;
|
||
}
|
||
|
||
/**
|
||
* 导出图片
|
||
* @param {Object} options 导出选项
|
||
* @param {Boolean} options.isContainBg 是否包含背景图层
|
||
* @param {Boolean} options.isContainFixed 是否包含固定图层
|
||
* @param {Boolean} options.isContainFixedOther 是否包含其他固定图层
|
||
* @param {Boolean} options.isContainNormalLayer 是否包含普通图层
|
||
* @param {Boolean} options.isCropByBg 是否使用背景大小裁剪
|
||
* @param {String} options.layerId 导出具体图层ID
|
||
* @param {Array} options.layerIdArray 导出多个图层ID数组
|
||
* @param {Array} options.layerIdArray2 导出多个图层ID数组2
|
||
* @param {String} options.expPicType 导出图片类型 (png/jpg/svg)
|
||
* @param {Boolean} options.restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @param {Boolean} options.isEnhanceImg 是否是增强图片
|
||
* @param {Array} options.excludedLayers 排除的图层ID数组
|
||
* @returns {String} 导出的图片数据URL
|
||
*/
|
||
async exportImage(options = {}) {
|
||
const {
|
||
isContainBg = false,
|
||
isContainFixed = false,
|
||
isContainFixedOther = false, // 是否包含其他固定图层
|
||
isContainNormalLayer = true, // 是否包含普通图层
|
||
isCropByBg = false, // 是否使用背景大小裁剪
|
||
layerId = "",
|
||
layerIdArray = [],
|
||
layerIdArray2 = null,
|
||
expPicType = "png",
|
||
restoreOpacityInRedGreen = true,
|
||
isEnhanceImg, // 是否是增强图片
|
||
excludedLayers = [], // 排除的图层ID数组
|
||
} = options;
|
||
try {
|
||
|
||
// 检查是否为红绿图模式
|
||
const isRedGreenMode = this.layerManager?.isInRedGreenMode?.() || false;
|
||
// 如果指定了具体图层ID，导出指定图层
|
||
if (layerId) {
|
||
return this._exportSpecificLayer(
|
||
layerId,
|
||
expPicType,
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg,
|
||
isEnhanceImg, // 是否是增强图片
|
||
);
|
||
}
|
||
|
||
// 如果指定了多个图层ID，导出多个图层
|
||
if (layerIdArray && layerIdArray.length > 0) {
|
||
return this._exportMultipleLayers(
|
||
layerIdArray,
|
||
expPicType,
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer, // 是否包含普通图层
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg,
|
||
isEnhanceImg, // 是否是增强图片
|
||
);
|
||
}
|
||
|
||
// 默认导出所有可见图层
|
||
return this._exportAllLayers(
|
||
expPicType,
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer, // 是否包含普通图层
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg,
|
||
isEnhanceImg, // 是否是增强图片
|
||
layerIdArray2,
|
||
excludedLayers, // 排除的图层ID数组
|
||
);
|
||
} catch (error) {
|
||
console.error("导出图片失败:", error);
|
||
throw new Error(`图片导出失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 导出指定单个图层
|
||
* @param {String} layerId 图层ID
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @param {Boolean} isCropByBg 是否使用背景大小裁剪
|
||
* @param {Boolean} isEnhanceImg 是否是增强图片
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportSpecificLayer(
|
||
layerId,
|
||
expPicType,
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
) {
|
||
if (!this.layerManager) {
|
||
throw new Error("图层管理器未初始化");
|
||
}
|
||
|
||
const layer = this._getLayerById(layerId);
|
||
if (!layer) {
|
||
throw new Error(`未找到ID为 ${layerId} 的图层`);
|
||
}
|
||
|
||
if (!layer.visible) {
|
||
console.warn(`图层 ${layer.name} 不可见，将导出空白图片`);
|
||
}
|
||
|
||
// 收集所有需要导出的对象
|
||
const objectsToExport = this._collectObjectsFromLayer(layer);
|
||
|
||
if (objectsToExport.length === 0) {
|
||
console.warn(`图层 ${layer.name} 没有可导出的对象`);
|
||
return this._generateEmptyImage(expPicType);
|
||
}
|
||
|
||
// 红绿图模式下使用固定尺寸和裁剪
|
||
if (isRedGreenMode) {
|
||
return this._exportWithRedGreenMode(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
);
|
||
}
|
||
|
||
// 普通模式使用画布尺寸
|
||
return await this._exportWithCanvasSize(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 导出多个指定图层
|
||
* @param {Array} layerIdArray 图层ID数组
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} isContainBg 是否包含背景图层
|
||
* @param {Boolean} isContainFixed 是否包含固定图层
|
||
* @param {Boolean} isContainFixedOther 是否包含其他固定图层
|
||
* @param {Boolean} isContainNormalLayer 是否包含普通图层
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @param {Boolean} isCropByBg 是否使用背景大小裁剪
|
||
* @param {Boolean} isEnhanceImg 是否是增强图片
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportMultipleLayers(
|
||
layerIdArray,
|
||
expPicType,
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer = true, // 是否包含普通图层
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
) {
|
||
if (!this.layerManager) {
|
||
throw new Error("图层管理器未初始化");
|
||
}
|
||
|
||
// 按图层顺序收集对象（从底到顶）
|
||
const objectsToExport = this._collectObjectsByLayerOrder(
|
||
layerIdArray,
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer, // 是否包含普通图层
|
||
);
|
||
|
||
if (objectsToExport.length === 0) {
|
||
console.warn("没有可导出的对象");
|
||
return this._generateEmptyImage(expPicType);
|
||
}
|
||
|
||
// 红绿图模式下使用固定尺寸和裁剪
|
||
if (isRedGreenMode) {
|
||
return this._exportWithRedGreenMode(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen
|
||
);
|
||
}
|
||
|
||
// 普通模式使用画布尺寸
|
||
return await this._exportWithCanvasSize(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 导出所有图层
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} isContainBg 是否包含背景图层
|
||
* @param {Boolean} isContainFixed 是否包含固定图层
|
||
* @param {Boolean} isContainFixedOther 是否包含其他固定图层
|
||
* @param {Boolean} isContainNormalLayer 是否包含普通图层
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @param {Boolean} isCropByBg 是否使用背景大小裁剪
|
||
* @param {Boolean} isEnhanceImg 是否是增强图片
|
||
* @param {Array} layerIdArray 导出多个图层ID数组2
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportAllLayers(
|
||
expPicType,
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer, // 是否包含普通图层
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
layerIdArray, // 导出所有图层
|
||
excludedLayers, // 排除的图层ID数组
|
||
) {
|
||
// 按图层顺序收集对象（从底到顶）
|
||
const objectsToExport = this._collectObjectsByLayerOrder(
|
||
layerIdArray, // 导出所有图层
|
||
isContainBg,
|
||
isContainFixed,
|
||
isContainFixedOther, // 是否包含其他固定图层
|
||
isContainNormalLayer, // 是否包含普通图层
|
||
excludedLayers,
|
||
);
|
||
|
||
if (objectsToExport.length === 0) {
|
||
console.warn("没有可导出的对象");
|
||
return this._generateEmptyImage(expPicType);
|
||
}
|
||
|
||
// 红绿图模式下使用固定尺寸和裁剪
|
||
if (isRedGreenMode) {
|
||
return this._exportWithRedGreenMode(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen
|
||
);
|
||
}
|
||
let canvasClipPath = this.canvas.clipPath;
|
||
if (isCropByBg) {
|
||
const cropWidth =
|
||
this.canvasManager?.canvasWidth?.value ||
|
||
this.canvas?.canvasWidth ||
|
||
this.canvas.width;
|
||
const cropHeight =
|
||
this.canvasManager?.canvasHeight?.value ||
|
||
this.canvas?.canvasHeight ||
|
||
this.canvas.height;
|
||
canvasClipPath = new fabric.Rect({
|
||
left: this.canvas.width / 2,
|
||
top: this.canvas.height / 2,
|
||
width: cropWidth,
|
||
height: cropHeight,
|
||
originX: "center",
|
||
originY: "center",
|
||
fill: "#fff",
|
||
stroke: "transparent",
|
||
strokeWidth: 0,
|
||
});
|
||
canvasClipPath.set({
|
||
absolutePositioned: true,
|
||
});
|
||
canvasClipPath.setCoords();
|
||
}
|
||
// 普通模式使用画布尺寸
|
||
return await this._exportWithCanvasSize(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
canvasClipPath,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 从图层收集对象（优化版本 - 通过ID查找画布中的真实对象）
|
||
* @param {Object} layer 图层对象
|
||
* @param {Boolean} isChildren 是否递归收集子图层的对象
|
||
* @returns {Array} 画布中的真实对象数组
|
||
* @private
|
||
*/
|
||
_collectObjectsFromLayer(layer, isChildren = true) {
|
||
if (!layer) {
|
||
return [];
|
||
}
|
||
|
||
const realObjects = [];
|
||
|
||
// 收集当前图层的对象
|
||
if (layer.fabricObjects && layer.fabricObjects.length > 0) {
|
||
for (const layerObj of layer.fabricObjects) {
|
||
if (!layerObj || !layerObj.id) continue;
|
||
|
||
// 通过ID在画布中查找真实对象
|
||
const realObj = this._findRealObjectById(layerObj.id);
|
||
if (realObj && realObj.visible !== false) {
|
||
realObjects.push(realObj);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (layer.fabricObject) {
|
||
// 通过ID在画布中查找真实对象
|
||
const realObj = this._findRealObjectById(layer.fabricObject.id);
|
||
if (realObj && realObj.visible !== false) {
|
||
realObjects.push(realObj);
|
||
}
|
||
}
|
||
|
||
// 递归收集子图层的对象
|
||
if (isChildren && layer.children && layer.children.length > 0) {
|
||
for (let i = layer.children.length - 1; i >= 0; i--) {
|
||
const childLayer = layer.children[i];
|
||
const childObjects = this._collectObjectsFromLayer(childLayer, isChildren);
|
||
realObjects.push(...childObjects);
|
||
}
|
||
}
|
||
|
||
return realObjects;
|
||
}
|
||
|
||
/**
|
||
* 通过ID在画布中查找真实对象
|
||
* @param {String} objectId 对象ID
|
||
* @returns {Object|null} 画布中的真实对象
|
||
* @private
|
||
*/
|
||
_findRealObjectById(objectId) {
|
||
if (!objectId || !this.canvas) {
|
||
return null;
|
||
}
|
||
|
||
try {
|
||
// 使用helper工具查找对象
|
||
const result = findObjectById(this.canvas, objectId);
|
||
return result?.object || null;
|
||
} catch (error) {
|
||
console.warn(`查找对象 ${objectId} 失败:`, error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 导出对象
|
||
* @param {Object} obj fabric对象
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportObject(
|
||
obj,
|
||
expPicType,
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen
|
||
) {
|
||
// 红绿图模式下使用固定尺寸和裁剪
|
||
if (isRedGreenMode) {
|
||
return this._exportWithRedGreenMode(
|
||
[obj],
|
||
expPicType,
|
||
restoreOpacityInRedGreen
|
||
);
|
||
}
|
||
|
||
// 普通模式使用画布尺寸
|
||
return await this._exportWithCanvasSize(
|
||
[obj],
|
||
expPicType,
|
||
restoreOpacityInRedGreen
|
||
);
|
||
}
|
||
|
||
/**
|
||
* 按图层顺序收集对象（优化版本 - 从底到顶）
|
||
* @param {Array|null} layerIdArray 图层ID数组，null表示所有图层
|
||
* @param {Boolean} isContainBg 是否包含背景图层
|
||
* @param {Boolean} isContainFixed 是否包含固定图层
|
||
* @param {Boolean} isContainFixedOther 是否包含其他固定图层
|
||
* @param {Boolean} isContainNormalLayer 是否包含普通图层
|
||
* @param {Array} excludedLayers 排除的图层ID数组
|
||
* @returns {Array} 按正确顺序排列的真实对象数组
|
||
* @private
|
||
*/
|
||
_collectObjectsByLayerOrder(layerIdArray, isContainBg, isContainFixed, isContainFixedOther, isContainNormalLayer, excludedLayers) {
|
||
const objectsToExport = [];
|
||
const allLayers = this._getAllLayersFlattened(excludedLayers); // 获取扁平化的图层列表
|
||
|
||
// 图层数组是从顶到底的顺序，需要反向遍历以获得从底到顶的渲染顺序
|
||
for (let i = allLayers.length - 1; i >= 0; i--) {
|
||
const layer = allLayers[i];
|
||
|
||
// 如果指定了图层ID数组，只处理指定的图层
|
||
if (layerIdArray && !layerIdArray.includes(layer.id)) continue;
|
||
|
||
// 检查图层类型过滤条件
|
||
if (!this._shouldIncludeLayer(layer, isContainBg, isContainFixed, isContainFixedOther, isContainNormalLayer))
|
||
continue;
|
||
|
||
if (layer.visible) {
|
||
const layerObjects = this._collectObjectsFromLayer(layer, false);
|
||
objectsToExport.push(...layerObjects);
|
||
}
|
||
}
|
||
|
||
return objectsToExport;
|
||
}
|
||
|
||
/**
|
||
* 获取扁平化的图层列表（包含子图层），排除指定的图层
|
||
* @param {Array} excludedLayers 排除的图层ID数组
|
||
* @returns {Array} 扁平化的图层数组
|
||
* @private
|
||
*/
|
||
_getAllLayersFlattened(excludedLayers) {
|
||
const flattenedLayers = [];
|
||
const rootLayers = this._getAllLayers();
|
||
|
||
const flattenLayer = (layer) => {
|
||
// 检查是否在排除列表中
|
||
if (excludedLayers && excludedLayers.includes(layer.id)) return;
|
||
|
||
flattenedLayers.push(layer);
|
||
|
||
// 递归处理子图层
|
||
if (layer.children && layer.children.length > 0) {
|
||
for (const childLayer of layer.children) {
|
||
flattenLayer(childLayer);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 处理所有根图层
|
||
for (const layer of rootLayers) {
|
||
flattenLayer(layer);
|
||
}
|
||
return flattenedLayers;
|
||
}
|
||
|
||
/**
|
||
* 计算对象组的边界
|
||
* @param {Array} objects 对象数组
|
||
* @returns {Object} 边界信息 {left, top, width, height}
|
||
* @private
|
||
*/
|
||
_calculateGroupBounds(objects) {
|
||
if (!objects || objects.length === 0) {
|
||
return { left: 0, top: 0, width: 1, height: 1 };
|
||
}
|
||
|
||
let minX = Infinity;
|
||
let minY = Infinity;
|
||
let maxX = -Infinity;
|
||
let maxY = -Infinity;
|
||
|
||
objects.forEach((obj) => {
|
||
if (!obj || typeof obj.getBoundingRect !== "function") {
|
||
return;
|
||
}
|
||
|
||
const bounds = obj.getBoundingRect();
|
||
minX = Math.min(minX, bounds.left);
|
||
minY = Math.min(minY, bounds.top);
|
||
maxX = Math.max(maxX, bounds.left + bounds.width);
|
||
maxY = Math.max(maxY, bounds.top + bounds.height);
|
||
});
|
||
|
||
if (minX === Infinity || minY === Infinity) {
|
||
return { left: 0, top: 0, width: 1, height: 1 };
|
||
}
|
||
|
||
// 添加小量边距避免边缘裁切
|
||
const padding = 2;
|
||
return {
|
||
left: minX - padding,
|
||
top: minY - padding,
|
||
width: maxX - minX + padding * 2,
|
||
height: maxY - minY + padding * 2,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 克隆对象并添加到临时画布，调整位置偏移
|
||
* @param {fabric.Canvas} tempCanvas 临时画布
|
||
* @param {Object} obj 要克隆的对象
|
||
* @param {Object} bounds 边界信息
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 是否恢复透明度
|
||
* @returns {Promise<Object>} 克隆的对象
|
||
* @private
|
||
*/
|
||
async _cloneAndAddObjectWithOffset(
|
||
tempCanvas,
|
||
obj,
|
||
bounds,
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen
|
||
) {
|
||
try {
|
||
const cloned = await this._cloneObjectForExport(
|
||
obj,
|
||
isRedGreenMode && restoreOpacityInRedGreen
|
||
);
|
||
|
||
if (cloned) {
|
||
// 获取对象当前边界
|
||
const objBounds = obj.getBoundingRect();
|
||
|
||
// 计算相对于组边界的偏移
|
||
const offsetX = objBounds.left - bounds.left;
|
||
const offsetY = objBounds.top - bounds.top;
|
||
|
||
// 设置新位置（相对于临时画布的原点）
|
||
cloned.set({
|
||
left: offsetX + objBounds.width / 2,
|
||
top: offsetY + objBounds.height / 2,
|
||
originX: "center",
|
||
originY: "center",
|
||
});
|
||
|
||
cloned.setCoords();
|
||
tempCanvas.add(cloned);
|
||
return cloned;
|
||
}
|
||
} catch (error) {
|
||
console.warn(`克隆对象失败: ${obj?.id || "未知"}`, error);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 红绿图模式导出（使用固定图层底图作为画布尺寸和裁剪区域）
|
||
* @param {Array} objectsToExport 要导出的对象数组
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} restoreOpacityInRedGreen 是否恢复透明度为1
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportWithRedGreenMode(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen
|
||
) {
|
||
// 获取固定图层对象（衣服底图）作为参考
|
||
const fixedLayerObject =
|
||
this._getFixedLayerObject() ?? this.canvas.clipPath;
|
||
if (!fixedLayerObject) {
|
||
console.warn("红绿图模式下未找到固定图层对象，使用画布尺寸");
|
||
return await this._exportWithCanvasSize(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
);
|
||
}
|
||
|
||
// 使用固定图层的实际显示尺寸作为导出画布尺寸
|
||
const canvasWidth = (fixedLayerObject.width);
|
||
const canvasHeight = (fixedLayerObject.height);
|
||
|
||
console.log(`红绿图模式导出，画布尺寸: ${canvasWidth}x${canvasHeight}`);
|
||
const tempFabricCanvas = new fabric.StaticCanvas()
|
||
tempFabricCanvas.setDimensions({
|
||
width: canvasWidth,
|
||
height: canvasHeight,
|
||
backgroundColor: null,
|
||
// enableRetinaScaling: true,
|
||
imageSmoothingEnabled: true,
|
||
});
|
||
// tempFabricCanvas.setZoom(1);
|
||
const ox = fixedLayerObject.left - fixedLayerObject.width * fixedLayerObject.scaleX / 2
|
||
const oy = fixedLayerObject.top - fixedLayerObject.height * fixedLayerObject.scaleY / 2
|
||
// console.log("==========", fixedLayerObject, ox, oy)
|
||
try {
|
||
// 克隆并添加所有对象到临时画布，需要调整位置相对于固定图层
|
||
for (let i = 0; i < objectsToExport.length; i++) {
|
||
const obj = objectsToExport[i];
|
||
const cloned = await this._cloneObjectForExport(
|
||
obj,
|
||
restoreOpacityInRedGreen && true
|
||
);
|
||
if (cloned) {
|
||
let scaleX = cloned.scaleX / fixedLayerObject.scaleX
|
||
let scaleY = cloned.scaleY / fixedLayerObject.scaleY
|
||
let top = (cloned.top - oy) * scaleY
|
||
let left = (cloned.left - ox) * scaleX
|
||
if (cloned.originX === "center" && cloned.originY === "center") {
|
||
top = canvasHeight / 2
|
||
left = canvasWidth / 2
|
||
}
|
||
cloned.set({
|
||
left: left,
|
||
top: top,
|
||
scaleX: scaleX,
|
||
scaleY: scaleY,
|
||
});
|
||
// 更新对象坐标
|
||
cloned.setCoords();
|
||
tempFabricCanvas.add(cloned);
|
||
}
|
||
}
|
||
|
||
// 渲染画布
|
||
tempFabricCanvas.renderAll();
|
||
|
||
// 生成图片
|
||
return this._generateHighQualityDataURL(tempFabricCanvas, expPicType);
|
||
} finally {
|
||
this._cleanupTempCanvas(tempFabricCanvas);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 普通模式导出（使用画布尺寸）
|
||
* @param {Array} objectsToExport 要导出的对象数组
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} restoreOpacityInRedGreen 是否恢复透明度为1
|
||
* @param {Object} maskObject 裁剪对象
|
||
* @param {Boolean} isCropByBg 是否使用背景大小裁剪
|
||
* @param {Boolean} isEnhanceImg 是否是增强图片
|
||
* @returns {String} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportWithCanvasSize(
|
||
objectsToExport,
|
||
expPicType,
|
||
restoreOpacityInRedGreen,
|
||
maskObject, // 裁剪对象
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
) {
|
||
// 使用当前画布尺寸
|
||
// const canvasWidth =
|
||
// this.canvasManager?.canvasWidth?.value || this.canvas.width;
|
||
// const canvasHeight =
|
||
// this.canvasManager?.canvasHeight?.value || this.canvas.height;
|
||
|
||
// console.log(`普通模式导出，画布尺寸: ${canvasWidth}x${canvasHeight}`);
|
||
// 使用图层栅格化的方法导出图片
|
||
const dataURL = await createRasterizedImage({
|
||
canvas: this.canvas,
|
||
fabricObjects: objectsToExport,
|
||
format: expPicType, // 导出格式
|
||
isReturenDataURL: true, // 返回数据URL
|
||
maskObject: maskObject ?? null, // 使用裁剪对象
|
||
trimWhitespace: true, // 裁剪空白
|
||
trimPadding: 0, // 裁剪边距
|
||
restoreOpacityInRedGreen,
|
||
isCropByBg, // 是否使用背景大小裁剪
|
||
isEnhanceImg, // 是否是增强图片
|
||
});
|
||
|
||
// console.log("导出图片数据URL:", dataURL);
|
||
return dataURL;
|
||
|
||
// // 创建与画布相同尺寸的临时画布
|
||
// const scaleFactor = 2; // 高清导出
|
||
// const tempCanvas = document.createElement("canvas");
|
||
// tempCanvas.width = canvasWidth * scaleFactor;
|
||
// tempCanvas.height = canvasHeight * scaleFactor;
|
||
// tempCanvas.style.width = canvasWidth + "px";
|
||
// tempCanvas.style.height = canvasHeight + "px";
|
||
|
||
// const tempFabricCanvas = new fabric.StaticCanvas(tempCanvas, {
|
||
// width: canvasWidth,
|
||
// height: canvasHeight,
|
||
// backgroundColor: null,
|
||
// });
|
||
|
||
// tempFabricCanvas.enableRetinaScaling = true;
|
||
// tempFabricCanvas.imageSmoothingEnabled = true;
|
||
// tempFabricCanvas.setZoom(1);
|
||
|
||
// try {
|
||
// // 克隆并添加所有对象到临时画布
|
||
// for (const obj of objectsToExport) {
|
||
// const cloned = await this._cloneObjectForExport(
|
||
// obj,
|
||
// restoreOpacityInRedGreen && false, // 普通模式不强制恢复透明度
|
||
// );
|
||
// if (cloned) {
|
||
// tempFabricCanvas.add(cloned);
|
||
// }
|
||
// }
|
||
|
||
// // 渲染画布
|
||
// tempFabricCanvas.renderAll();
|
||
|
||
// // 生成图片
|
||
// return this._generateHighQualityDataURL(tempCanvas, expPicType);
|
||
// } finally {
|
||
// this._cleanupTempCanvas(tempFabricCanvas);
|
||
// }
|
||
}
|
||
|
||
/**
|
||
* 获取固定图层对象
|
||
* @returns {Object|null} 固定图层对象
|
||
* @private
|
||
*/
|
||
_getFixedLayerObject() {
|
||
const allLayers = this._getAllLayers();
|
||
const fixedLayer = allLayers.find((layer) => layer.isFixed);
|
||
|
||
if (!fixedLayer || !fixedLayer.fabricObject) {
|
||
return null;
|
||
}
|
||
|
||
// 如果有ID，通过ID查找画布中的实际对象
|
||
if (fixedLayer.fabricObject.id) {
|
||
const result = findObjectById(this.canvas, fixedLayer.fabricObject.id);
|
||
return result.object || fixedLayer.fabricObject;
|
||
}
|
||
|
||
return fixedLayer.fabricObject;
|
||
}
|
||
|
||
/**
|
||
* 异步克隆fabric对象（参照createRasterizedImage的方法）
|
||
* @param {fabric.Object} obj 要克隆的对象
|
||
* @param {Array} propertiesToInclude 要包含的属性
|
||
* @returns {Promise<fabric.Object>} 克隆的对象
|
||
* @private
|
||
*/
|
||
_cloneObjectAsync(
|
||
obj,
|
||
propertiesToInclude = ["id", "layerId", "layerName", "name", "scaleX", "scaleY"]
|
||
) {
|
||
return new Promise((resolve, reject) => {
|
||
if (!obj) {
|
||
resolve(null);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
obj.clone((cloned) => {
|
||
if (cloned) {
|
||
resolve(cloned);
|
||
} else {
|
||
reject(new Error("对象克隆失败"));
|
||
}
|
||
}, propertiesToInclude);
|
||
} catch (error) {
|
||
console.warn("克隆对象失败:", error);
|
||
resolve(null);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 克隆对象用于导出（优化版本）
|
||
* @param {Object} obj fabric对象
|
||
* @param {Boolean} forceRestoreOpacity 是否强制恢复透明度为1
|
||
* @param {Boolean} removeClipPath 是否移除裁剪路径
|
||
* @returns {Promise<Object>} 克隆的对象
|
||
* @private
|
||
*/
|
||
async _cloneObjectForExport(
|
||
obj,
|
||
forceRestoreOpacity = false,
|
||
removeClipPath = true
|
||
) {
|
||
if (!obj) return null;
|
||
|
||
try {
|
||
// 使用异步克隆方法
|
||
const cloned = await this._cloneObjectAsync(obj);
|
||
|
||
if (cloned) {
|
||
// 保持原始位置和属性
|
||
cloned.set({
|
||
selectable: false,
|
||
evented: false,
|
||
visible: true,
|
||
});
|
||
|
||
// 如果需要恢复透明度
|
||
if (forceRestoreOpacity) {
|
||
cloned.set({ opacity: 1 });
|
||
}
|
||
|
||
// 移除裁剪路径以避免绝对路径问题
|
||
if (removeClipPath && cloned.clipPath) {
|
||
console.log(`移除对象 ${cloned.id || "未知"} 的裁剪路径`);
|
||
cloned.clipPath = null;
|
||
}
|
||
|
||
return cloned;
|
||
}
|
||
} catch (error) {
|
||
console.warn("克隆对象失败:", error);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 导出对象组
|
||
* @param {Array} objectsToExport 要导出的对象数组
|
||
* @param {String} expPicType 导出类型
|
||
* @param {Boolean} isRedGreenMode 是否为红绿图模式
|
||
* @param {Boolean} restoreOpacityInRedGreen 红绿图模式下是否恢复透明度为1
|
||
* @returns {Promise<String>} 图片数据URL
|
||
* @private
|
||
*/
|
||
async _exportObjectsAsGroup(
|
||
objectsToExport,
|
||
expPicType,
|
||
isRedGreenMode = false,
|
||
restoreOpacityInRedGreen = true
|
||
) {
|
||
if (!objectsToExport || objectsToExport.length === 0) {
|
||
throw new Error("没有可导出的对象");
|
||
}
|
||
|
||
// 计算所有对象的边界
|
||
const bounds = this._calculateGroupBounds(objectsToExport);
|
||
console.log("导出边界:", bounds);
|
||
|
||
// 创建高质量临时画布
|
||
const scaleFactor = 2; // 高清导出
|
||
const tempCanvas = document.createElement("canvas");
|
||
tempCanvas.width = bounds.width * scaleFactor;
|
||
tempCanvas.height = bounds.height * scaleFactor;
|
||
tempCanvas.style.width = bounds.width + "px";
|
||
tempCanvas.style.height = bounds.height + "px";
|
||
|
||
const tempFabricCanvas = new fabric.StaticCanvas(tempCanvas, {
|
||
width: bounds.width,
|
||
height: bounds.height,
|
||
backgroundColor: null, // 透明背景
|
||
});
|
||
|
||
// 启用高清缩放和图像平滑
|
||
tempFabricCanvas.enableRetinaScaling = true;
|
||
tempFabricCanvas.imageSmoothingEnabled = true;
|
||
tempFabricCanvas.setZoom(scaleFactor);
|
||
|
||
try {
|
||
// 克隆所有对象并添加到临时画布
|
||
const clonedObjects = [];
|
||
for (const obj of objectsToExport) {
|
||
const cloned = await this._cloneAndAddObjectWithOffset(
|
||
tempFabricCanvas,
|
||
obj,
|
||
bounds,
|
||
isRedGreenMode,
|
||
restoreOpacityInRedGreen
|
||
);
|
||
if (cloned) {
|
||
clonedObjects.push(cloned);
|
||
}
|
||
}
|
||
|
||
console.log(`成功克隆 ${clonedObjects.length} 个对象进行导出`);
|
||
|
||
// 渲染画布
|
||
tempFabricCanvas.renderAll();
|
||
|
||
// 生成高质量数据URL
|
||
return this._generateHighQualityDataURL(tempCanvas, expPicType);
|
||
} finally {
|
||
this._cleanupTempCanvas(tempFabricCanvas);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取裁剪路径对象（优化版本）
|
||
* @param {Object} fixedBounds 固定图层边界
|
||
* @returns {Promise<Object|null>} 裁剪路径对象
|
||
* @private
|
||
*/
|
||
async _getClipPathObject(fixedBounds) {
|
||
try {
|
||
// const allLayers = this._getAllLayers();
|
||
|
||
// // 查找第一个有裁剪遮罩的图层
|
||
// let clipObject = null;
|
||
|
||
// for (const layer of allLayers) {
|
||
// if (layer.clippingMask?.id) {
|
||
// const result = findObjectById(this.canvas, layer.clippingMask.id);
|
||
// if (result?.object) {
|
||
// clipObject = result.object;
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
const clipObject = this.canvas?.clipPath;
|
||
if (!clipObject) {
|
||
console.warn("未找到可用的裁剪对象");
|
||
return null;
|
||
}
|
||
|
||
// 克隆对象作为裁剪路径
|
||
const clonedClipPath = await this._cloneObjectForExport(
|
||
clipObject,
|
||
false,
|
||
false
|
||
);
|
||
|
||
if (!clonedClipPath) {
|
||
console.warn("无法克隆裁剪对象");
|
||
return null;
|
||
}
|
||
|
||
// 调整裁剪路径的位置相对于固定图层
|
||
clonedClipPath.set({
|
||
left: clonedClipPath.left - fixedBounds.left,
|
||
top: clonedClipPath.top - fixedBounds.top,
|
||
absolutePositioned: true, // 使用绝对定位
|
||
});
|
||
|
||
// 更新坐标
|
||
clonedClipPath.setCoords();
|
||
|
||
console.log("成功创建裁剪路径:", {
|
||
objectType: clonedClipPath.type,
|
||
position: { left: clonedClipPath.left, top: clonedClipPath.top },
|
||
size: { width: clonedClipPath.width, height: clonedClipPath.height },
|
||
});
|
||
|
||
return clonedClipPath;
|
||
} catch (error) {
|
||
console.error("获取裁剪路径失败:", error);
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成高质量数据URL
|
||
* @param {HTMLCanvasElement} canvas 画布元素
|
||
* @param {String} expPicType 导出类型
|
||
* @returns {String} 数据URL
|
||
* @private
|
||
*/
|
||
_generateHighQualityDataURL(canvas, expPicType) {
|
||
const format = expPicType.toLowerCase();
|
||
|
||
switch (format) {
|
||
case "jpg":
|
||
case "jpeg":
|
||
// 对于JPEG，使用较高质量，但JPEG不支持透明背景
|
||
return canvas.toDataURL("image/jpeg", 0.95);
|
||
case "svg":
|
||
// SVG导出需要特殊处理，这里先返回高质量PNG
|
||
console.warn("SVG导出暂未实现，返回高质量PNG格式");
|
||
return canvas.toDataURL("image/png", 1.0);
|
||
case "png":
|
||
default:
|
||
// PNG使用最高质量，支持透明背景
|
||
return canvas.toDataURL("image/png", 1.0);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成空白图片
|
||
* @param {String} expPicType 导出类型
|
||
* @returns {String} 空白图片数据URL
|
||
* @private
|
||
*/
|
||
_generateEmptyImage(expPicType) {
|
||
const emptyCanvas = document.createElement("canvas");
|
||
emptyCanvas.width = 1;
|
||
emptyCanvas.height = 1;
|
||
|
||
// 确保透明背景
|
||
const ctx = emptyCanvas.getContext("2d");
|
||
ctx.clearRect(0, 0, 1, 1);
|
||
|
||
return this._generateHighQualityDataURL(emptyCanvas, expPicType);
|
||
}
|
||
|
||
/**
|
||
* 清理临时画布资源
|
||
* @param {fabric.StaticCanvas} tempFabricCanvas 临时Fabric画布
|
||
* @private
|
||
*/
|
||
_cleanupTempCanvas(tempFabricCanvas) {
|
||
if (tempFabricCanvas) {
|
||
try {
|
||
tempFabricCanvas.dispose();
|
||
} catch (error) {
|
||
console.warn("清理临时画布失败:", error);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取所有图层
|
||
* @returns {Array} 图层数组
|
||
* @private
|
||
*/
|
||
_getAllLayers() {
|
||
if (this.layerManager && this.layerManager.layers) {
|
||
return this.layerManager.layers.value || [];
|
||
}
|
||
return [];
|
||
}
|
||
|
||
/**
|
||
* 根据ID获取图层
|
||
* @param {String} layerId 图层ID
|
||
* @returns {Object|null} 图层对象
|
||
* @private
|
||
*/
|
||
_getLayerById(layerId) {
|
||
if (this.layerManager && this.layerManager.getLayerById) {
|
||
return this.layerManager.getLayerById(layerId);
|
||
}
|
||
|
||
// 备用方法：直接从图层数组中查找
|
||
const allLayers = this._getAllLayers();
|
||
return allLayers.find((layer) => layer.id === layerId) || null;
|
||
}
|
||
|
||
/**
|
||
* 检查图层是否应该包含在导出中
|
||
* @param {Object} layer 图层对象
|
||
* @param {Boolean} isContainBg 是否包含背景图层
|
||
* @param {Boolean} isContainFixed 是否包含固定图层
|
||
* @param {Boolean} isContainFixedOther 是否包含其他固定图层
|
||
* @param {Boolean} isContainNormalLayer 是否包含普通图层
|
||
* @returns {Boolean} 是否应该包含
|
||
* @private
|
||
*/
|
||
_shouldIncludeLayer(layer, isContainBg, isContainFixed, isContainFixedOther, isContainNormalLayer) {
|
||
if (!layer) return false;
|
||
|
||
// 检查背景图层
|
||
if (layer.isBackground) {
|
||
return isContainBg;
|
||
}
|
||
|
||
// 检查固定图层
|
||
if (layer.isFixed) {
|
||
return isContainFixed;
|
||
}
|
||
|
||
// 检查其他固定图层
|
||
if (layer.isFixedOther) {
|
||
return isContainFixedOther;
|
||
}
|
||
|
||
// 印花图层始终导出
|
||
if (layer.isPrintTrims || layer.isPrintTrimsGroup) {
|
||
return true;
|
||
}
|
||
|
||
// 普通图层
|
||
return isContainNormalLayer;
|
||
}
|
||
}
|