Line data Source code
1 : import { IMAGE_WIDGET } from '@/renderer/extensions/maskEditor/composables/imageWidgetAdapter'
2 : import { getNodeWidgetValue } from '@/core/graph/widgets/nodeWidgetValues'
3 : import { useMaskEditorDataStore } from '@/renderer/extensions/maskEditor/stores/maskEditorDataStore'
4 : import type {
5 : ImageRef,
6 : LoadedImageLayer
7 : } from '@/renderer/extensions/maskEditor/stores/maskEditorDataStore'
8 : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
9 : import { useNodeOutputStore } from '@/stores/nodeOutputStore'
10 : import { isCloud } from '@/platform/distribution/types'
11 : import { api } from '@/scripts/api'
12 : import { useApp } from '@/scripts/appInstance'
13 : import { fullResolutionSrc } from '@/utils/hdrFormatUtil'
14 : import {
15 : extractWidgetStringValue,
16 : parseImageWidgetValue
17 : } from '@/utils/imageUtil'
18 :
19 : import { imageLayerFilenamesIfApplicable } from './layerFilenames'
20 :
21 : interface MaskLayersResponse {
22 : painted_masked?: string
23 : painted?: string
24 : paint?: string
25 : mask?: string
26 : }
27 :
28 2 : function toRef(filename: string, subfolder: string): ImageRef {
29 2 : return {
30 : filename,
31 : subfolder,
32 : type: 'input'
33 : }
34 : }
35 :
36 31 : function mkFileUrl(props: { ref: ImageRef; preview?: boolean }): string {
37 31 : const params = new URLSearchParams()
38 31 : params.set('filename', props.ref.filename)
39 31 : if (props.ref.subfolder) {
40 0 : params.set('subfolder', props.ref.subfolder)
41 : }
42 31 : if (props.ref.type) {
43 31 : params.set('type', props.ref.type)
44 : }
45 :
46 31 : const pathPlusQueryParams = api.apiURL(
47 : '/view?' +
48 : params.toString() +
49 : useApp().getPreviewFormatParam() +
50 : useApp().getRandParam()
51 : )
52 31 : const imageElement = new Image()
53 31 : imageElement.crossOrigin = 'anonymous'
54 31 : imageElement.src = pathPlusQueryParams
55 31 : return imageElement.src
56 : }
57 :
58 30 : export function useMaskEditorLoader() {
59 30 : const dataStore = useMaskEditorDataStore()
60 30 : const nodeOutputStore = useNodeOutputStore()
61 :
62 30 : const loadFromNode = async (
63 : node: LGraphNode,
64 : signal?: AbortSignal
65 : ): Promise<void> => {
66 30 : if (signal?.aborted) return
67 30 : dataStore.setLoading(true)
68 :
69 30 : try {
70 30 : validateNode(node)
71 :
72 30 : let nodeImageUrl = getNodeImageUrl(node)
73 :
74 30 : let nodeImageRef = parseImageRef(nodeImageUrl)
75 :
76 30 : const widgetFilename = extractWidgetStringValue(
77 : getNodeWidgetValue(node, IMAGE_WIDGET)
78 : )
79 :
80 30 : if (widgetFilename && !widgetFilename.startsWith('$')) {
81 29 : const parsed = parseImageWidgetValue(widgetFilename)
82 29 : nodeImageRef = {
83 : filename: parsed.filename,
84 : type: parsed.type || 'input',
85 : subfolder: parsed.subfolder || undefined
86 : }
87 29 : nodeImageUrl = mkFileUrl({ ref: nodeImageRef })
88 : }
89 :
90 30 : const fileToQuery = widgetFilename || nodeImageRef.filename
91 :
92 : let maskLayersFromApi: MaskLayersResponse | undefined
93 : if (isCloud) {
94 : try {
95 : const response = await api.fetchApi(
96 : `/files/mask-layers?filename=${fileToQuery}`
97 : )
98 : if (response.ok) {
99 : maskLayersFromApi = await response.json()
100 : }
101 : } catch {
102 : maskLayersFromApi = undefined
103 : }
104 : }
105 :
106 30 : let imageLayerFilenames = imageLayerFilenamesIfApplicable(
107 : nodeImageRef.filename
108 : )
109 :
110 : if (maskLayersFromApi) {
111 : const baseFile =
112 : maskLayersFromApi.painted_masked || maskLayersFromApi.painted
113 :
114 : if (baseFile) {
115 : imageLayerFilenames = {
116 : maskedImage: baseFile,
117 : paint: maskLayersFromApi.paint || '',
118 : paintedImage: maskLayersFromApi.painted || '',
119 : paintedMaskedImage: maskLayersFromApi.painted_masked || baseFile
120 : }
121 : }
122 : }
123 :
124 30 : const layerSubfolder = maskLayersFromApi
125 : ? 'clipspace'
126 : : (nodeImageRef.subfolder ?? '')
127 :
128 30 : const layeredBaseUrl = imageLayerFilenames?.maskedImage
129 : ? mkFileUrl({
130 : ref: toRef(imageLayerFilenames.maskedImage, layerSubfolder)
131 : })
132 : : undefined
133 30 : const baseImageUrl = layeredBaseUrl ?? nodeImageUrl
134 :
135 30 : let paintLayerUrl: string | null = null
136 : if (maskLayersFromApi?.paint) {
137 : paintLayerUrl = mkFileUrl({
138 : ref: toRef(maskLayersFromApi.paint, layerSubfolder)
139 : })
140 30 : } else if (imageLayerFilenames?.paint) {
141 1 : paintLayerUrl = mkFileUrl({
142 : ref: toRef(imageLayerFilenames.paint, layerSubfolder)
143 : })
144 : }
145 :
146 30 : const loadLayers = (baseUrl: string, paintUrl: string | null) =>
147 : Promise.all([
148 : loadImageLayer(baseUrl, 'rgb'),
149 : loadImageLayer(baseUrl, 'a'),
150 : paintUrl ? loadImageLayer(paintUrl) : Promise.resolve(undefined)
151 : ])
152 :
153 30 : const loadInputData = async () => {
154 30 : try {
155 30 : const [baseLayer, maskLayer, paintLayer] = await loadLayers(
156 : baseImageUrl,
157 : paintLayerUrl
158 : )
159 30 : return {
160 : baseLayer,
161 : maskLayer,
162 : paintLayer,
163 : sourceRef: layeredBaseUrl
164 : ? parseImageRef(baseImageUrl)
165 : : nodeImageRef
166 : }
167 : } catch (error) {
168 0 : if (!layeredBaseUrl) throw error
169 0 : console.warn(
170 : '[MaskEditorLoader] Failed to load editor layer files, falling back to the node image',
171 : error
172 : )
173 0 : const [baseLayer, maskLayer] = await loadLayers(nodeImageUrl, null)
174 0 : return {
175 : baseLayer,
176 : maskLayer,
177 : paintLayer: undefined,
178 : sourceRef: nodeImageRef
179 : }
180 : }
181 : }
182 :
183 30 : const inputData = await loadInputData()
184 30 : if (signal?.aborted) return
185 29 : dataStore.inputData = { ...inputData, nodeId: node.id }
186 29 : dataStore.sourceNode = node
187 29 : dataStore.setLoading(false)
188 : } catch (error) {
189 0 : if (signal?.aborted) return
190 0 : const errorMessage =
191 : error instanceof Error ? error.message : 'Failed to load from node'
192 0 : console.error('[MaskEditorLoader]', errorMessage, error)
193 0 : dataStore.setLoading(false, errorMessage)
194 0 : throw error
195 : }
196 : }
197 :
198 30 : function validateNode(node: LGraphNode): void {
199 : const hasImages = node.imgs?.length || node.previewMediaType === 'image'
200 30 : if (!hasImages) {
201 0 : throw new Error('Node has no images')
202 : }
203 : }
204 :
205 30 : function getNodeImageUrl(node: LGraphNode): string {
206 30 : const nodeImage = node.images?.[0]
207 30 : if (nodeImage?.filename) {
208 30 : const params = new URLSearchParams({
209 : filename: nodeImage.filename,
210 : type: nodeImage.type || 'output',
211 : subfolder: nodeImage.subfolder || ''
212 : })
213 30 : return api.apiURL(`/view?${params.toString()}`)
214 : }
215 :
216 0 : const outputs = nodeOutputStore.getNodeOutputs(node)
217 30 : if (outputs?.images?.[0]) {
218 0 : const img = outputs.images[0]
219 0 : if (!img.filename) {
220 0 : throw new Error('nodeOutputStore image missing filename')
221 : }
222 :
223 0 : const params = new URLSearchParams()
224 0 : params.set('filename', img.filename)
225 0 : params.set('type', img.type || 'output')
226 0 : params.set('subfolder', img.subfolder || '')
227 0 : return api.apiURL(`/view?${params.toString()}`)
228 : }
229 :
230 30 : if (node.imgs?.length) {
231 0 : const index = node.imageIndex ?? 0
232 0 : const imgSrc = fullResolutionSrc(node.imgs[index])
233 :
234 0 : if (imgSrc && !imgSrc.startsWith('data:')) {
235 0 : return imgSrc
236 : }
237 : }
238 :
239 0 : throw new Error('Unable to get image URL from node')
240 : }
241 :
242 31 : function parseImageRef(url: string): ImageRef {
243 31 : try {
244 31 : const urlObj = new URL(url)
245 31 : const filename = urlObj.searchParams.get('filename')
246 :
247 31 : if (!filename) {
248 0 : throw new Error('Image URL missing filename parameter')
249 : }
250 :
251 31 : return {
252 : filename,
253 : subfolder: urlObj.searchParams.get('subfolder') || undefined,
254 : type: urlObj.searchParams.get('type') || undefined
255 : }
256 : } catch (error) {
257 30 : try {
258 30 : const urlObj = new URL(url, window.location.origin)
259 30 : const filename = urlObj.searchParams.get('filename')
260 :
261 30 : if (!filename) {
262 0 : throw new Error('Image URL missing filename parameter', {
263 : cause: error
264 : })
265 : }
266 :
267 30 : return {
268 : filename,
269 : subfolder: urlObj.searchParams.get('subfolder') || undefined,
270 : type: urlObj.searchParams.get('type') || undefined
271 : }
272 : } catch (e) {
273 0 : throw new Error(`Invalid image URL: ${url}`, { cause: e })
274 : }
275 : }
276 : }
277 :
278 61 : async function loadImageLayer(
279 : url: string,
280 : channel?: 'rgb' | 'a'
281 : ): Promise<LoadedImageLayer> {
282 61 : let urlObj: URL
283 61 : try {
284 61 : urlObj = new URL(url)
285 : } catch {
286 2 : urlObj = new URL(url, window.location.origin)
287 : }
288 :
289 61 : if (channel) {
290 60 : urlObj.searchParams.delete('channel')
291 60 : urlObj.searchParams.set('channel', channel)
292 : }
293 :
294 61 : const finalUrl = urlObj.toString()
295 : const image = await loadImage(finalUrl)
296 :
297 61 : return { image, url: finalUrl }
298 : }
299 :
300 61 : function loadImage(url: string): Promise<HTMLImageElement> {
301 61 : return new Promise((resolve, reject) => {
302 61 : const img = new Image()
303 61 : img.crossOrigin = 'anonymous'
304 :
305 61 : img.onload = () => resolve(img)
306 61 : img.onerror = () => reject(new Error(`Failed to load image: ${url}`))
307 :
308 61 : img.src = url
309 : })
310 : }
311 :
312 30 : return {
313 : loadFromNode
314 : }
315 : }
|