The clipboard_comy operator is affected by rendering properties #75

New Issue

Triager-bot · 2026-04-13T15:45:27Z

Triager-bot commented

2026-04-13 15:45:27 +00:00

Original bug report: https://projects.blender.org/blender/blender/issues/157279

System Information
Operating system: Windows-10-10.0.19045-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 3070 Laptop GPU/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 591.86 Opengl Backend

Blender Version
Broken: version: 5.1.0, branch: blender-v5.1-release, commit date: 2026-03-16 18:50, hash: adfe2921d5f3
Worked: (newest version of Blender that worked as expected)

Short description of error
This problem has been bothering me for several days. Could you please fix it

When using the operator bpy.ops.image.clipboard_compy() to copy transparent images, it will be affected by the bpy.context.scene.render.image_dettings.color_made attribute
Causing the copied image to have no transparent channel

Exact steps for others to reproduce the error

You just need to open a transparent image in the image editor
This issue is triggered when using the bpy.ops.image.clipboard_comy() operator in the image menu
bpy.context.scene.render.image_dettings.color_made is normal when set to RGBA
Transparent channels cannot be copied for BW or RGB

You can view the demonstration video

Original bug report: https://projects.blender.org/blender/blender/issues/157279 **System Information** Operating system: Windows-10-10.0.19045-SP0 64 Bits Graphics card: NVIDIA GeForce RTX 3070 Laptop GPU/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 591.86 Opengl Backend **Blender Version** Broken: version: 5.1.0, branch: blender-v5.1-release, commit date: 2026-03-16 18:50, hash: `adfe2921d5f3` Worked: (newest version of Blender that worked as expected) **Short description of error** This problem has been bothering me for several days. Could you please fix it When using the operator `bpy.ops.image.clipboard_compy()` to copy transparent images, it will be affected by the `bpy.context.scene.render.image_dettings.color_made` attribute Causing the copied image to have no transparent channel **Exact steps for others to reproduce the error** You just need to open a transparent image in the image editor This issue is triggered when using the `bpy.ops.image.clipboard_comy()` operator in the image menu bpy.context.scene.render.image_dettings.color_made is normal when set to `RGBA` Transparent channels cannot be copied for `BW` or `RGB` You can view the demonstration video

20260413-182910.mp4

4.1 MiB

Gen_20260411182506_color_grade.png

613 KiB

Triager-bot added the

Status

Needs review

label 2026-04-13 15:45:27 +00:00

Triager-bot commented

2026-04-13 15:45:58 +00:00

Report is clear

LLM Reasoning

Got it, let's analyze this bug report. The question is whether it clearly describes the issue. First, check the clarity of the text and steps to reproduce.

The title mentions "clipboard_comy operator" (maybe a typo, but the body says clipboard_compy). The short description explains that using bpy.ops.image.clipboard_compy() for transparent images is affected by render settings, causing loss of transparency. The steps: open a transparent image in image editor, use the operator, and when color_made is BW or RGB (instead of RGBA), transparency isn't copied.

Wait, but are the steps clear? Let's see: "You just need to open a transparent image in the image editor" – that's a step. Then "This issue is triggered when using the bpy.ops.image.clipboard_comy() operator in the image menu" – another step. Then mention color_made settings. The video is there but we ignore that.

Is the description clear? The error is about the clipboard copy operator being affected by render properties, leading to no transparent channel. The steps are present, even if some typos (like "clipboard_comy" vs "clipboard_compy", "image_dettings" maybe a typo for "image_settings"). But the main points: what the operator does, how it's affected, and steps to reproduce.

But wait, the user is asking if the bug report clearly describes the issue. Let's check: Does it state what the problem is (clipboard copy of transparent images loses transparency due to render settings), and steps to reproduce? Yes, even with minor typos, the core info is there. So the answer should be 'Yes'? Wait, no, wait. Wait, let's recheck.

Wait, the bug report says "Could you please fix it" – that's a request, but the description of the error: when using clipboard_compy to copy transparent images, affected by render.image_dettings.color_made (maybe color_mode), causing copied image to have no transparent channel. Steps: open transparent image, use operator, check when color_mode is BW/RGB vs RGBA.

Is that clear? Yes, because it explains the problem (loss of transparency) and how to reproduce (open transparent image, use operator, check render settings). So the clarity is there. So the answer is 'Yes'? Wait, but maybe I'm missing something. Let me think again.

Wait, the user's question: "Does this bug report clearly describes the issue?" The key is whether the text description and steps are clear. The body has a short description of error (problem with clipboard copy losing transparency due to render settings) and exact steps (open transparent image, use operator, check color_mode). So yes, it's clear. So the answer is 'Yes'.

JSON Data

{
"llm_judgement": true,
"processing_time": 28.842617
}

### Report is clear <details> <summary>LLM Reasoning</summary> Got it, let's analyze this bug report. The question is whether it clearly describes the issue. First, check the clarity of the text and steps to reproduce. The title mentions "clipboard_comy operator" (maybe a typo, but the body says clipboard_compy). The short description explains that using bpy.ops.image.clipboard_compy() for transparent images is affected by render settings, causing loss of transparency. The steps: open a transparent image in image editor, use the operator, and when color_made is BW or RGB (instead of RGBA), transparency isn't copied. Wait, but are the steps clear? Let's see: "You just need to open a transparent image in the image editor" – that's a step. Then "This issue is triggered when using the bpy.ops.image.clipboard_comy() operator in the image menu" – another step. Then mention color_made settings. The video is there but we ignore that. Is the description clear? The error is about the clipboard copy operator being affected by render properties, leading to no transparent channel. The steps are present, even if some typos (like "clipboard_comy" vs "clipboard_compy", "image_dettings" maybe a typo for "image_settings"). But the main points: what the operator does, how it's affected, and steps to reproduce. But wait, the user is asking if the bug report clearly describes the issue. Let's check: Does it state what the problem is (clipboard copy of transparent images loses transparency due to render settings), and steps to reproduce? Yes, even with minor typos, the core info is there. So the answer should be 'Yes'? Wait, no, wait. Wait, let's recheck. Wait, the bug report says "Could you please fix it" – that's a request, but the description of the error: when using clipboard_compy to copy transparent images, affected by render.image_dettings.color_made (maybe color_mode), causing copied image to have no transparent channel. Steps: open transparent image, use operator, check when color_mode is BW/RGB vs RGBA. Is that clear? Yes, because it explains the problem (loss of transparency) and how to reproduce (open transparent image, use operator, check render settings). So the clarity is there. So the answer is 'Yes'? Wait, but maybe I'm missing something. Let me think again. Wait, the user's question: "Does this bug report clearly describes the issue?" The key is whether the text description and steps are clear. The body has a short description of error (problem with clipboard copy losing transparency due to render settings) and exact steps (open transparent image, use operator, check color_mode). So yes, it's clear. So the answer is 'Yes'. </details> <details> <summary>JSON Data</summary> { "llm_judgement": true, "processing_time": 28.842617 } </details>

Triager-bot commented

2026-04-13 15:46:06 +00:00

Report is specific

LLM Reasoning

Got it, let's analyze this bug report. The title mentions a specific operator: "clipboard_comy" (probably a typo but still specific). The body talks about using that operator and how it's affected by rendering properties like color_made. The steps to reproduce are detailed: open a transparent image, use the operator, check when color_made is RGBA vs BW/RGB. So this is about a specific issue with a particular operator and its interaction with rendering settings. Therefore, it's a Specific bug report.

JSON Data

{
"llm_judgement": true,
"processing_time": 7.648588
}

### Report is specific <details> <summary>LLM Reasoning</summary> Got it, let's analyze this bug report. The title mentions a specific operator: "clipboard_comy" (probably a typo but still specific). The body talks about using that operator and how it's affected by rendering properties like color_made. The steps to reproduce are detailed: open a transparent image, use the operator, check when color_made is RGBA vs BW/RGB. So this is about a specific issue with a particular operator and its interaction with rendering settings. Therefore, it's a Specific bug report. </details> <details> <summary>JSON Data</summary> { "llm_judgement": true, "processing_time": 7.648588 } </details>

Triager-bot commented

2026-04-13 15:47:32 +00:00

Report flagged as NOT a duplicate by LLM

Copying a render to clipboard from image editor doesn't respect color management

https://projects.blender.org/blender/blender/issues/112689

System Information
Operating system: Windows 11 Home
Graphics card: NVIDIA GeForce RTX 3060

Blender Version
Broken: 3.6
Currently in Blender 3.6.2, hash e53e55951e7a. Don't know of a previous version where this worked.

Short description of error
bpy.ops.image.clipboard_copy() doesn't respect the color management render panel when copying renders.

Exact steps for others to reproduce the error
Using the startup file with the default cube:

in Render properties -> Color Management, change the exposure to something ridiculous (I used 10)
render
in the Image editor menu, select "Image" -> "Copy"
paste into any image editor

This is a screenshot from Blender:

This is the copy operator's result in the clipboard, pasted into Window's Paint:

LLM Reasoning

Got it, let's analyze these two bug reports. First, look at the key parts: description and steps to reproduce.

Bug report 1 is about clipboard_comy (probably a typo for clipboard_copy) operator being affected by rendering properties like color_made (maybe color management settings), causing transparent images to lose transparency when using certain render settings (BW or RGB instead of RGBA). The steps involve opening a transparent image and using the operator, with issues based on render settings.

Bug report 2 is about clipboard_copy not respecting color management in the render panel. Steps: change exposure in Color Management, render, copy from Image editor, paste. The issue is that the copied image doesn't respect those color management settings (like exposure).

Now, check if they're the same. Both are about the clipboard_copy operator and how it interacts with rendering/color management settings. But wait, bug 1 mentions transparent channels being lost based on render settings (color_made), while bug 2 is about color management (exposure) not being respected. Are these related? Let's see: both involve the same operator (clipboard_copy or similar) and issues with how rendering properties affect the copied image. But are they the exact same issue?

Wait, bug 1's description says "affected by rendering properties" like color_made, causing transparent channels to be lost. Bug 2 says "doesn't respect color management". So both are about the clipboard copy operator not handling render settings correctly. But are they duplicates? Let's check the steps:

Bug 1 steps: open transparent image, use clipboard_comy (copy) operator, issue when render settings are BW/RGB.

Bug 2 steps: change exposure in Color Management, render, copy from Image editor, paste—result doesn't respect exposure.

So both are about the clipboard copy operator and how it interacts with rendering properties. But is that the same underlying issue? Maybe, but let's see if the core problem is the same. The first is about transparency loss due to color mode (RGBA vs BW/RGB), the second is about color management (exposure) not being applied. Are these two different aspects of the same bug, or separate?

Wait, the question is whether they are the same issue. Let's check the operator: both use bpy.ops.image.clipboard_copy (bug 1 has a typo "clipboard_comy" but likely same). Both involve rendering properties affecting the copied image. But the specific issues: one is transparency loss due to color mode, the other is exposure not being respected. Are these two different bugs or the same?

Alternatively, maybe they are duplicates because both are about the clipboard copy operator not handling render settings correctly. But let's think: if the first bug is that when using certain color modes (BW/RGB) the transparency is lost, and the second is that exposure isn't applied, are these two different manifestations of the same underlying problem with how the clipboard copy handles render settings? Or are they separate?

Wait, the user says to focus on Description and Steps. Let's compare:

Description 1: "When using the operator bpy.ops.image.clipboard_comy()... it will be affected by the bpy.context.scene.render.image_dettings.color_made attribute Causing the copied image to have no transparent channel" — so color mode (RGBA vs BW/RGB) affects transparency.

Description 2: "bpy.ops.image.clipboard_copy() doesn't respect the color management render panel when copying renders." — exposure (color management) not respected.

Steps 1: open transparent image, use operator, issue with color mode.

Steps 2: change exposure in Color Management, render, copy, paste—issue with exposure.

So are these two different issues? Or same? Let's see if the core problem is that the clipboard copy doesn't handle render settings properly. But the specific symptoms differ (transparency vs exposure). However, maybe they are duplicates because both are about the same operator and how it interacts with rendering properties. But wait, the first bug is about color mode (RGBA/BW/RGB) affecting transparency, the second is about color management (exposure) not being applied. Are these two different bugs?

Alternatively, maybe the first bug's "color_made" is a typo for "color_management", and both are about color management settings affecting the copied image. If that's the case, then they could be duplicates. But without knowing if "color_made" is a typo, it's hard. But given that both involve the clipboard copy operator and issues with rendering properties (color mode or color management), maybe they are the same issue.

Wait, but let's think: the first bug says transparent channels can't be copied for BW or RGB. The second says exposure isn't respected. Are these two different aspects? For example, if you set the render to BW, then copy, transparency is lost (bug 1). If you set exposure high, then copy, the image is overexposed (bug 2). So those are two different symptoms but maybe caused by the same underlying issue: the clipboard copy operator not properly handling render settings when copying.

But the question is whether they are the same issue. The answer would be "Yes" if they are duplicates, "No" otherwise. Let's see: both are about the clipboard copy operator and how it interacts with rendering properties. So maybe yes? Wait, but let's check the operator names: bug 1 has "clipboard_comy" (probably typo for "clipboard_copy"), bug 2 has "clipboard_copy". So same operator.

Alternatively, maybe they are different because one is about transparency loss due to color mode, the other is about exposure not being applied. But perhaps they are duplicates because both are issues with the clipboard copy not respecting render settings. Let's see: if the first bug is that when using certain color modes (BW/RGB) the transparency is lost, and the second is that exposure isn't respected, maybe those are two different bugs. But the user says to focus on Description and Steps.

Wait, let's re-examine:

Bug 1 description: affected by color_made (maybe color mode) causing transparent channel loss.

Bug 2 description: doesn't respect color management (exposure).

Steps 1: open transparent image, use operator, issue with color mode.

Steps 2: change exposure, render, copy, paste—issue with exposure.

So the core problem in both is that the clipboard copy operator is affected by rendering properties. But the specific properties differ (color mode vs exposure). Are these two different issues or same?

Alternatively, maybe "color_made" is a typo for "color_management", so both are about color management settings. If that's the case, then they are duplicates. But without knowing, it's hard. However, given that both involve the same operator and issues with rendering properties affecting the copied image, perhaps they are duplicates.

But wait, let's think: if you have a transparent image, and set render to BW, then copy—transparency lost (bug 1). If you set exposure high, render, then copy—image is overexposed (bug 2). These are two different symptoms. So maybe they are not the same issue.

Alternatively, maybe the first bug's "color_made" is a typo for "color_management", so both are about color management. Then yes, duplicates.

But since we don't know if it's a typo, and the steps are different (one involves transparent images and color mode, the other involves exposure), perhaps they are not the same. So the answer would be No? Wait, but let's check again.

Wait, bug 1 says "transparent channels cannot be copied for BW or RGB". Bug 2 says "doesn't respect the color management render panel when copying renders". So one is about transparency loss due to color mode, the other is about exposure not being applied. These are two different issues. Therefore, they are not duplicates. So answer is No.

JSON Data

{
"llm_judgement": false,
"processing_time": 86.053913,
"duplicate_report_number": "112689"
}

### Report flagged as NOT a duplicate by LLM <details> <summary>Copying a render to clipboard from image editor doesn't respect color management</summary> https://projects.blender.org/blender/blender/issues/112689 **System Information** Operating system: Windows 11 Home Graphics card: NVIDIA GeForce RTX 3060 **Blender Version** Broken: 3.6 Currently in Blender 3.6.2, hash e53e55951e7a. Don't know of a previous version where this worked. **Short description of error** `bpy.ops.image.clipboard_copy()` doesn't respect the color management render panel when copying renders. **Exact steps for others to reproduce the error** Using the startup file with the default cube: - in Render properties -> Color Management, change the exposure to something ridiculous (I used 10) - render - in the Image editor menu, select "Image" -> "Copy" - paste into any image editor This is a screenshot from Blender: ![image](/attachments/14a6543b-e708-4eae-8f09-86a2e85ac9df) This is the copy operator's result in the clipboard, pasted into Window's Paint: ![image](/attachments/996505b1-b87f-4551-9a3b-6571cf68d751) </details> <details> <summary>LLM Reasoning</summary> Got it, let's analyze these two bug reports. First, look at the key parts: description and steps to reproduce. Bug report 1 is about `clipboard_comy` (probably a typo for clipboard_copy) operator being affected by rendering properties like color_made (maybe color management settings), causing transparent images to lose transparency when using certain render settings (BW or RGB instead of RGBA). The steps involve opening a transparent image and using the operator, with issues based on render settings. Bug report 2 is about `clipboard_copy` not respecting color management in the render panel. Steps: change exposure in Color Management, render, copy from Image editor, paste. The issue is that the copied image doesn't respect those color management settings (like exposure). Now, check if they're the same. Both are about the clipboard_copy operator and how it interacts with rendering/color management settings. But wait, bug 1 mentions transparent channels being lost based on render settings (color_made), while bug 2 is about color management (exposure) not being respected. Are these related? Let's see: both involve the same operator (`clipboard_copy` or similar) and issues with how rendering properties affect the copied image. But are they the exact same issue? Wait, bug 1's description says "affected by rendering properties" like `color_made`, causing transparent channels to be lost. Bug 2 says "doesn't respect color management". So both are about the clipboard copy operator not handling render settings correctly. But are they duplicates? Let's check the steps: Bug 1 steps: open transparent image, use clipboard_comy (copy) operator, issue when render settings are BW/RGB. Bug 2 steps: change exposure in Color Management, render, copy from Image editor, paste—result doesn't respect exposure. So both are about the clipboard copy operator and how it interacts with rendering properties. But is that the same underlying issue? Maybe, but let's see if the core problem is the same. The first is about transparency loss due to color mode (RGBA vs BW/RGB), the second is about color management (exposure) not being applied. Are these two different aspects of the same bug, or separate? Wait, the question is whether they are the same issue. Let's check the operator: both use `bpy.ops.image.clipboard_copy` (bug 1 has a typo "clipboard_comy" but likely same). Both involve rendering properties affecting the copied image. But the specific issues: one is transparency loss due to color mode, the other is exposure not being respected. Are these two different bugs or the same? Alternatively, maybe they are duplicates because both are about the clipboard copy operator not handling render settings correctly. But let's think: if the first bug is that when using certain color modes (BW/RGB) the transparency is lost, and the second is that exposure isn't applied, are these two different manifestations of the same underlying problem with how the clipboard copy handles render settings? Or are they separate? Wait, the user says to focus on Description and Steps. Let's compare: Description 1: "When using the operator `bpy.ops.image.clipboard_comy()`... it will be affected by the `bpy.context.scene.render.image_dettings.color_made` attribute Causing the copied image to have no transparent channel" — so color mode (RGBA vs BW/RGB) affects transparency. Description 2: "`bpy.ops.image.clipboard_copy()` doesn't respect the color management render panel when copying renders." — exposure (color management) not respected. Steps 1: open transparent image, use operator, issue with color mode. Steps 2: change exposure in Color Management, render, copy, paste—issue with exposure. So are these two different issues? Or same? Let's see if the core problem is that the clipboard copy doesn't handle render settings properly. But the specific symptoms differ (transparency vs exposure). However, maybe they are duplicates because both are about the same operator and how it interacts with rendering properties. But wait, the first bug is about color mode (RGBA/BW/RGB) affecting transparency, the second is about color management (exposure) not being applied. Are these two different bugs? Alternatively, maybe the first bug's "color_made" is a typo for "color_management", and both are about color management settings affecting the copied image. If that's the case, then they could be duplicates. But without knowing if "color_made" is a typo, it's hard. But given that both involve the clipboard copy operator and issues with rendering properties (color mode or color management), maybe they are the same issue. Wait, but let's think: the first bug says transparent channels can't be copied for BW or RGB. The second says exposure isn't respected. Are these two different aspects? For example, if you set the render to BW, then copy, transparency is lost (bug 1). If you set exposure high, then copy, the image is overexposed (bug 2). So those are two different symptoms but maybe caused by the same underlying issue: the clipboard copy operator not properly handling render settings when copying. But the question is whether they are the same issue. The answer would be "Yes" if they are duplicates, "No" otherwise. Let's see: both are about the clipboard copy operator and how it interacts with rendering properties. So maybe yes? Wait, but let's check the operator names: bug 1 has "clipboard_comy" (probably typo for "clipboard_copy"), bug 2 has "clipboard_copy". So same operator. Alternatively, maybe they are different because one is about transparency loss due to color mode, the other is about exposure not being applied. But perhaps they are duplicates because both are issues with the clipboard copy not respecting render settings. Let's see: if the first bug is that when using certain color modes (BW/RGB) the transparency is lost, and the second is that exposure isn't respected, maybe those are two different bugs. But the user says to focus on Description and Steps. Wait, let's re-examine: Bug 1 description: affected by `color_made` (maybe color mode) causing transparent channel loss. Bug 2 description: doesn't respect color management (exposure). Steps 1: open transparent image, use operator, issue with color mode. Steps 2: change exposure, render, copy, paste—issue with exposure. So the core problem in both is that the clipboard copy operator is affected by rendering properties. But the specific properties differ (color mode vs exposure). Are these two different issues or same? Alternatively, maybe "color_made" is a typo for "color_management", so both are about color management settings. If that's the case, then they are duplicates. But without knowing, it's hard. However, given that both involve the same operator and issues with rendering properties affecting the copied image, perhaps they are duplicates. But wait, let's think: if you have a transparent image, and set render to BW, then copy—transparency lost (bug 1). If you set exposure high, render, then copy—image is overexposed (bug 2). These are two different symptoms. So maybe they are not the same issue. Alternatively, maybe the first bug's "color_made" is a typo for "color_management", so both are about color management. Then yes, duplicates. But since we don't know if it's a typo, and the steps are different (one involves transparent images and color mode, the other involves exposure), perhaps they are not the same. So the answer would be No? Wait, but let's check again. Wait, bug 1 says "transparent channels cannot be copied for BW or RGB". Bug 2 says "doesn't respect the color management render panel when copying renders". So one is about transparency loss due to color mode, the other is about exposure not being applied. These are two different issues. Therefore, they are not duplicates. So answer is No. </details> <details> <summary>JSON Data</summary> { "llm_judgement": false, "processing_time": 86.053913, "duplicate_report_number": "112689" } </details>

Triager-bot commented

2026-04-13 15:48:30 +00:00

Report flagged as NOT a duplicate by LLM

Premultiplication issue when copying image from image editor

https://projects.blender.org/blender/blender/issues/145472

System Information
Operating system: macOS-15.6.1-arm64-arm-64bit 64 Bits
Graphics card: Metal API Apple M3 1.2

Blender Version
Broken: version: 4.5.2 LTS, branch: blender-v4.5-release, commit date: 2025-08-19 15:00, hash: ab25eae04993
Worked: (newest version of Blender that worked as expected)

Short description of error
Premultiplication issue when copying image with from image editor. The image copied in the clipboard gives white borders and transparency issues when pasted.

Exact steps for others to reproduce the error
1 - Create a new scene and set the in the render properties Film->Transparent to have a transparent background.
2 - Render the image with F12
3- In the image editor -> Menu Image -> Copy. This saves the rendered image in the clipboard.
4 - Go to any application (Photoshop, Pixelmator, freeform, Pages, etc) then paste.
The image will have white borders and bad transparency as the premultiplication is wrong.

(The transparency is correct if you save the rendered image as PNG for exemple then import it.)

LLM Reasoning

Got it, let's analyze these two bug reports. First, look at the description and steps to reproduce.

Bug Report 1: Talks about clipboard_compy() operator affecting transparent images based on render settings (color_made attribute). The issue is that when using this operator, transparent channels aren't copied correctly if the setting is BW or RGB instead of RGBA. So it's about the clipboard copy operator in image editor being affected by render properties leading to transparency loss.

Bug Report 2: Describes a premultiplication issue when copying from image editor. Steps involve rendering with transparent background, then using Image->Copy (which is similar to the operator in report 1), and pasting gives white borders/transparency issues. The key here is that the copied image has premultiplication problems, leading to transparency errors.

Now, check if they're the same issue. Both are about copying images from Blender's image editor (using copy operators) resulting in transparency issues. Report 1 mentions render properties affecting the clipboard operator, report 2 mentions premultiplication when copying. But are these the same underlying problem? Let's see: both involve copying an image (with transparency) and having issues with how the transparency is handled. The steps in both involve using the image editor's copy function. However, the specific details differ—report 1 links to render settings (color_made), report 2 to premultiplication. But maybe they're related? Wait, but the question is if they are duplicates. Let's check the core issue: both are about copying transparent images from Blender and having transparency problems in the clipboard. But the descriptions are different—one is about render properties affecting the operator, the other about premultiplication. Are these the same? Maybe not exactly, but let's see. Wait, no—report 1 says the copied image has no transparent channel when using certain render settings, report 2 says white borders and bad transparency due to wrong premultiplication. These could be different manifestations of the same underlying issue (how Blender handles copying transparent images), but are they duplicates? The question is whether based on description and steps, they are the same. Let's check the steps: both involve using the image editor's copy function (report 1 uses bpy.ops.image.clipboard_comy(), report 2 uses Image->Copy). Both result in transparency issues when pasted. But the causes mentioned are different (render properties vs premultiplication). However, maybe they're the same bug with different symptoms. But the question is to determine if they are duplicates. Since the descriptions and steps have different focuses (one on render settings affecting the operator, the other on premultiplication), but both involve copying transparent images leading to transparency issues, I need to decide. Wait, the user says focus primarily on Description of issue and Steps to reproduce. Let's compare:

Report 1 description: "When using the operator bpy.ops.image.clipboard_compy() to copy transparent images, it will be affected by the bpy.context.scene.render.image_dettings.color_made attribute Causing the copied image to have no transparent channel"

Report 2 description: "Premultiplication issue when copying image with from image editor. The image copied in the clipboard gives white borders and transparency issues when pasted."

Steps:

Report 1 steps: Open transparent image, use bpy.ops.image.clipboard_comy() operator, affected by render settings (color_made).

Report 2 steps: Render with transparent background, Image->Copy, paste elsewhere—white borders/transparency.

Are these the same issue? The core is copying transparent images and having transparency problems. But the specific causes mentioned are different. However, maybe they're related but not duplicates. Wait, but maybe the "clipboard_compy" operator in report 1 is the same as "Image->Copy" in report 2 (since bpy.ops.image.clipboard_copy is the operator for copying to clipboard). Oh, right! The operator name in report 1 might be a typo ("clipboard_comy" vs actual "clipboard_copy"). So both are using the same operator. Then, report 1 says it's affected by render settings (color_made), report 2 says premultiplication issue. Are these two different aspects of the same bug? Or different bugs?

Wait, let's think: if you copy a transparent image, and the clipboard has issues with transparency, maybe the cause is either render settings affecting how the image is copied (report 1) or premultiplication (report 2). But are these the same issue? Let's see—if the problem in report 1 is that when using certain render settings (like BW/RGB instead of RGBA), the clipboard copy loses transparency, and report 2 is that even with transparent background, copying gives white borders due to premultiplication. These could be two different bugs, or the same bug with different symptoms. But the question is whether they are duplicates. Since the descriptions focus on different causes (render settings vs premultiplication) and slightly different symptoms (no transparency channel vs white borders), but both involve copying transparent images from image editor leading to clipboard issues, I need to decide. The user says if unsure, respond 'No'. So maybe they are not duplicates because the root cause mentioned is different. Therefore, the answer is No.

JSON Data

{
"llm_judgement": false,
"processing_time": 57.517538,
"duplicate_report_number": "145472"
}

### Report flagged as NOT a duplicate by LLM <details> <summary>Premultiplication issue when copying image from image editor</summary> https://projects.blender.org/blender/blender/issues/145472 **System Information** Operating system: macOS-15.6.1-arm64-arm-64bit 64 Bits Graphics card: Metal API Apple M3 1.2 **Blender Version** Broken: version: 4.5.2 LTS, branch: blender-v4.5-release, commit date: 2025-08-19 15:00, hash: `ab25eae04993` Worked: (newest version of Blender that worked as expected) **Short description of error** Premultiplication issue when copying image with from image editor. The image copied in the clipboard gives white borders and transparency issues when pasted. **Exact steps for others to reproduce the error** 1 - Create a new scene and set the in the render properties Film->Transparent to have a transparent background. 2 - Render the image with F12 3- In the image editor -> Menu Image -> Copy. This saves the rendered image in the clipboard. 4 - Go to any application (Photoshop, Pixelmator, freeform, Pages, etc) then paste. The image will have white borders and bad transparency as the premultiplication is wrong. (The transparency is correct if you save the rendered image as PNG for exemple then import it.) </details> <details> <summary>LLM Reasoning</summary> Got it, let's analyze these two bug reports. First, look at the description and steps to reproduce. Bug Report 1: Talks about `clipboard_compy()` operator affecting transparent images based on render settings (color_made attribute). The issue is that when using this operator, transparent channels aren't copied correctly if the setting is BW or RGB instead of RGBA. So it's about the clipboard copy operator in image editor being affected by render properties leading to transparency loss. Bug Report 2: Describes a premultiplication issue when copying from image editor. Steps involve rendering with transparent background, then using Image->Copy (which is similar to the operator in report 1), and pasting gives white borders/transparency issues. The key here is that the copied image has premultiplication problems, leading to transparency errors. Now, check if they're the same issue. Both are about copying images from Blender's image editor (using copy operators) resulting in transparency issues. Report 1 mentions render properties affecting the clipboard operator, report 2 mentions premultiplication when copying. But are these the same underlying problem? Let's see: both involve copying an image (with transparency) and having issues with how the transparency is handled. The steps in both involve using the image editor's copy function. However, the specific details differ—report 1 links to render settings (color_made), report 2 to premultiplication. But maybe they're related? Wait, but the question is if they are duplicates. Let's check the core issue: both are about copying transparent images from Blender and having transparency problems in the clipboard. But the descriptions are different—one is about render properties affecting the operator, the other about premultiplication. Are these the same? Maybe not exactly, but let's see. Wait, no—report 1 says the copied image has no transparent channel when using certain render settings, report 2 says white borders and bad transparency due to wrong premultiplication. These could be different manifestations of the same underlying issue (how Blender handles copying transparent images), but are they duplicates? The question is whether based on description and steps, they are the same. Let's check the steps: both involve using the image editor's copy function (report 1 uses `bpy.ops.image.clipboard_comy()`, report 2 uses Image->Copy). Both result in transparency issues when pasted. But the causes mentioned are different (render properties vs premultiplication). However, maybe they're the same bug with different symptoms. But the question is to determine if they are duplicates. Since the descriptions and steps have different focuses (one on render settings affecting the operator, the other on premultiplication), but both involve copying transparent images leading to transparency issues, I need to decide. Wait, the user says focus primarily on Description of issue and Steps to reproduce. Let's compare: Report 1 description: "When using the operator `bpy.ops.image.clipboard_compy()` to copy transparent images, it will be affected by the `bpy.context.scene.render.image_dettings.color_made` attribute Causing the copied image to have no transparent channel" Report 2 description: "Premultiplication issue when copying image with from image editor. The image copied in the clipboard gives white borders and transparency issues when pasted." Steps: Report 1 steps: Open transparent image, use `bpy.ops.image.clipboard_comy()` operator, affected by render settings (color_made). Report 2 steps: Render with transparent background, Image->Copy, paste elsewhere—white borders/transparency. Are these the same issue? The core is copying transparent images and having transparency problems. But the specific causes mentioned are different. However, maybe they're related but not duplicates. Wait, but maybe the "clipboard_compy" operator in report 1 is the same as "Image->Copy" in report 2 (since `bpy.ops.image.clipboard_copy` is the operator for copying to clipboard). Oh, right! The operator name in report 1 might be a typo ("clipboard_comy" vs actual "clipboard_copy"). So both are using the same operator. Then, report 1 says it's affected by render settings (color_made), report 2 says premultiplication issue. Are these two different aspects of the same bug? Or different bugs? Wait, let's think: if you copy a transparent image, and the clipboard has issues with transparency, maybe the cause is either render settings affecting how the image is copied (report 1) or premultiplication (report 2). But are these the same issue? Let's see—if the problem in report 1 is that when using certain render settings (like BW/RGB instead of RGBA), the clipboard copy loses transparency, and report 2 is that even with transparent background, copying gives white borders due to premultiplication. These could be two different bugs, or the same bug with different symptoms. But the question is whether they are duplicates. Since the descriptions focus on different causes (render settings vs premultiplication) and slightly different symptoms (no transparency channel vs white borders), but both involve copying transparent images from image editor leading to clipboard issues, I need to decide. The user says if unsure, respond 'No'. So maybe they are not duplicates because the root cause mentioned is different. Therefore, the answer is No. </details> <details> <summary>JSON Data</summary> { "llm_judgement": false, "processing_time": 57.517538, "duplicate_report_number": "145472" } </details>

Triager-bot commented

2026-04-13 15:48:45 +00:00

Report flagged as NOT a duplicate by LLM

popup_menu does not render color properties correctly

https://projects.blender.org/blender/blender/issues/152839

System Information
Operating system: Windows-10-10.0.26100-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 2060/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 572.16 Opengl Backend

Blender Versions
Broken: 4.5.5 LTS, branch: blender-v4.5-release, commit date: 2025-11-17 16:03, hash: 836beaaf597a
Broken: 5.0.1, branch: blender-v5.0-release, commit date: 2025-12-15 16:36, hash: a3db93c5b259

Short description of error

A popup menu invoked by bpy.context.window_manager.popup_menu(...) draws color properties as a gray box instead of a color preview.

Everything else seems to work correctly:

tooltip displays the correct color
clicking the gray box opens color picker popup that works correctly
drawn property contains the color set by the color picker popup

Invoking an operator props dialog with the same draw function draws the property correctly.

Exact steps for others to reproduce the error

Create a FloatVectorProperty with 'COLOR' subtype or choose an existing one
Call bpy.context.window_manager.popup_menu() with a draw function drawing the color property with layout.prop() function

You can use the following script inside Blender to test both the window_manager.popup_menu as well as an operator with props dialog.

import bpy

bpy.types.Scene.color_prop = bpy.props.FloatVectorProperty(subtype='COLOR', size=4, min=0, max=1)

class SetColor(bpy.types.Operator):
    bl_idname = "test.set_color"
    bl_label = "Set Color"
    bl_options = {'REGISTER', 'UNDO'}
    
    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)
    
    def execute(self, context):
        return {'FINISHED'}
    
    def draw(self, context):
        self.layout.prop(context.scene, "color_prop")
    
bpy.utils.register_class(SetColor)

def draw_popup(self, context):
    self.layout.prop(context.scene, "color_prop")

bpy.context.window_manager.popup_menu(draw_popup)
#bpy.ops.test.set_color('INVOKE_DEFAULT')

LLM Reasoning

Got it, let's analyze the two bug reports. First, look at the description and steps for each.

Bug Report 1 is about the clipboard_comy operator (probably a typo for clipboard_copy) being affected by rendering properties when copying transparent images. The issue is that the copied image loses transparency based on the render settings like color mode (RGBA vs BW/RGB). Steps involve using the operator in the image editor with different render settings.

Bug Report 2 is about popup_menu not rendering color properties correctly—they show as gray boxes instead of color previews, even though tooltips and pickers work. The steps involve creating a color property and using popup_menu to draw it, comparing to an operator's props dialog which works.

These are completely different issues: one is about clipboard copying of transparent images affected by render settings, the other is about popup menu rendering color properties incorrectly. So they're not duplicates.

JSON Data

{
"llm_judgement": false,
"processing_time": 14.957627,
"duplicate_report_number": "152839"
}

### Report flagged as NOT a duplicate by LLM <details> <summary>popup_menu does not render color properties correctly</summary> https://projects.blender.org/blender/blender/issues/152839 **System Information** Operating system: Windows-10-10.0.26100-SP0 64 Bits Graphics card: NVIDIA GeForce RTX 2060/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 572.16 Opengl Backend **Blender Versions** Broken: 4.5.5 LTS, branch: blender-v4.5-release, commit date: 2025-11-17 16:03, hash: `836beaaf597a` Broken: 5.0.1, branch: blender-v5.0-release, commit date: 2025-12-15 16:36, hash: `a3db93c5b259` **Short description of error** A popup menu invoked by `bpy.context.window_manager.popup_menu(...)` draws color properties as a gray box instead of a color preview. Everything else seems to work correctly: - tooltip displays the correct color - clicking the gray box opens color picker popup that works correctly - drawn property contains the color set by the color picker popup <img width="542" alt="image.png" src="attachments/4a835ba8-eb2f-4c99-9eaa-3a32e46f0eff"> Invoking an operator props dialog with the same draw function draws the property correctly. <img width="545" alt="image.png" src="attachments/21846f03-c1a2-4060-b655-1e6cb1fb027b"> **Exact steps for others to reproduce the error** 1. Create a `FloatVectorProperty` with 'COLOR' subtype or choose an existing one 2. Call `bpy.context.window_manager.popup_menu()` with a draw function drawing the color property with `layout.prop()` function You can use the following script inside Blender to test both the `window_manager.popup_menu` as well as an operator with props dialog. ```python import bpy bpy.types.Scene.color_prop = bpy.props.FloatVectorProperty(subtype='COLOR', size=4, min=0, max=1) class SetColor(bpy.types.Operator): bl_idname = "test.set_color" bl_label = "Set Color" bl_options = {'REGISTER', 'UNDO'} def invoke(self, context, event): return context.window_manager.invoke_props_dialog(self) def execute(self, context): return {'FINISHED'} def draw(self, context): self.layout.prop(context.scene, "color_prop") bpy.utils.register_class(SetColor) def draw_popup(self, context): self.layout.prop(context.scene, "color_prop") bpy.context.window_manager.popup_menu(draw_popup) #bpy.ops.test.set_color('INVOKE_DEFAULT') ``` </details> <details> <summary>LLM Reasoning</summary> Got it, let's analyze the two bug reports. First, look at the description and steps for each. Bug Report 1 is about the `clipboard_comy` operator (probably a typo for clipboard_copy) being affected by rendering properties when copying transparent images. The issue is that the copied image loses transparency based on the render settings like color mode (RGBA vs BW/RGB). Steps involve using the operator in the image editor with different render settings. Bug Report 2 is about `popup_menu` not rendering color properties correctly—they show as gray boxes instead of color previews, even though tooltips and pickers work. The steps involve creating a color property and using `popup_menu` to draw it, comparing to an operator's props dialog which works. These are completely different issues: one is about clipboard copying of transparent images affected by render settings, the other is about popup menu rendering color properties incorrectly. So they're not duplicates. </details> <details> <summary>JSON Data</summary> { "llm_judgement": false, "processing_time": 14.957627, "duplicate_report_number": "152839" } </details>

Triager-bot commented

2026-04-13 15:48:59 +00:00

Report flagged as NOT a duplicate by LLM

Patch to use system clipboard for copy/paste ops on buttons (text, colour, etc.)

https://projects.blender.org/blender/blender/issues/17370

%%%This patch allows text to be copied from buttons on to and from the system clipboard bringing together copy/paste ops and allowing text to be copied from buttons into the text editor. For multiline text pasted onto a button, the first line is extracted.

The only unsupported type is the ColorBand type which maintains its own clipboard as before. A side effect of having a global clipboard is that it is now possible to copy a number from one button and paste it as text in another button. Colours are represented as [r, g, b] making it easy to use in python scripts.
%%%

LLM Reasoning

Got it, let's analyze the two bug reports. First, look at the key sections: Description and Steps to Reproduce.

Bug Report 1 is about the clipboard_comy operator (probably a typo for clipboard_copy) affecting transparent images when using rendering properties like color_made. The issue is that copying transparent images loses transparency based on render settings.

Bug Report 2 is about a patch for system clipboard in copy/paste ops for buttons (text, color, etc.), mentioning unsupported types and global clipboard side effects. This is about implementing or modifying clipboard functionality for different UI elements, not about the existing operator's behavior with rendering properties.

The first report is about an existing operator's bug related to rendering settings affecting transparency. The second is about a proposed patch for system clipboard in various UI components. They're completely different issues—one is a bug in an existing feature, the other is a new implementation or modification. So they aren't duplicates.

JSON Data

{
"llm_judgement": false,
"processing_time": 13.209567999999999,
"duplicate_report_number": "17370"
}

### Report flagged as NOT a duplicate by LLM <details> <summary>Patch to use system clipboard for copy/paste ops on buttons (text, colour, etc.)</summary> https://projects.blender.org/blender/blender/issues/17370 %%%This patch allows text to be copied from buttons on to and from the system clipboard bringing together copy/paste ops and allowing text to be copied from buttons into the text editor. For multiline text pasted onto a button, the first line is extracted. The only unsupported type is the ColorBand type which maintains its own clipboard as before. A side effect of having a global clipboard is that it is now possible to copy a number from one button and paste it as text in another button. Colours are represented as [r, g, b] making it easy to use in python scripts. %%% </details> <details> <summary>LLM Reasoning</summary> Got it, let's analyze the two bug reports. First, look at the key sections: Description and Steps to Reproduce. Bug Report 1 is about the `clipboard_comy` operator (probably a typo for clipboard_copy) affecting transparent images when using rendering properties like color_made. The issue is that copying transparent images loses transparency based on render settings. Bug Report 2 is about a patch for system clipboard in copy/paste ops for buttons (text, color, etc.), mentioning unsupported types and global clipboard side effects. This is about implementing or modifying clipboard functionality for different UI elements, not about the existing operator's behavior with rendering properties. The first report is about an existing operator's bug related to rendering settings affecting transparency. The second is about a proposed patch for system clipboard in various UI components. They're completely different issues—one is a bug in an existing feature, the other is a new implementation or modification. So they aren't duplicates. </details> <details> <summary>JSON Data</summary> { "llm_judgement": false, "processing_time": 13.209567999999999, "duplicate_report_number": "17370" } </details>

Triager-bot commented

2026-04-13 15:49:12 +00:00

Report flagged as NOT a duplicate by LLM

Regression: VSE: Python traceback with Fade operator

https://projects.blender.org/blender/blender/issues/141652

System Information
Operating system: Windows-10-10.0.19042-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 3060 Laptop GPU/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 576.80 Opengl Backend

Blender Version
Broken: version: 4.5.0 Beta, branch: blender-v4.5-release, commit date: 2025-07-09 01:22, hash: 85ad73809fa9
Worked: 4.5, before 9e4c26574a

Short description of error
Python traceback when fade operator is executed

Python: Traceback (most recent call last):
  File "C:\Program Files\blender\4.5\scripts\startup\bl_operators\sequencer.py", line 248, in execute
    strip.invalidate_cache('COMPOSITE')
TypeError: ColorStrip.invalidate_cache(): error with argument 1, "type" -  enum "COMPOSITE" not found in ('RAW')

Exact steps for others to reproduce the error

Open Video editing template
Add image or solid color strip
RMB > fade - fade in and out

LLM Reasoning

Got it, let's analyze these two bug reports. First, look at the key sections: description and steps to reproduce.

Bug report 1 is about the clipboard_comy operator (probably a typo for clipboard_copy) being affected by rendering properties when copying transparent images. The issue is that the copied image loses transparency based on render settings like color_made (maybe a typo for color_mode). Steps involve opening a transparent image and using the operator, with issues in BW or RGB modes.

Bug report 2 is about a Python traceback in the VSE's Fade operator, specifically an error with ColorStrip.invalidate_cache. The steps are adding a strip in Video editing template and using RMB > fade.

These are completely different issues: one is about clipboard copying of transparent images affected by render settings, the other is a traceback in VSE's fade operator. So they're not duplicates.

JSON Data

{
"llm_judgement": false,
"processing_time": 13.291061,
"duplicate_report_number": "141652"
}

### Report flagged as NOT a duplicate by LLM <details> <summary>Regression: VSE: Python traceback with Fade operator</summary> https://projects.blender.org/blender/blender/issues/141652 **System Information** Operating system: Windows-10-10.0.19042-SP0 64 Bits Graphics card: NVIDIA GeForce RTX 3060 Laptop GPU/PCIe/SSE2 NVIDIA Corporation 4.6.0 NVIDIA 576.80 Opengl Backend **Blender Version** Broken: version: 4.5.0 Beta, branch: blender-v4.5-release, commit date: 2025-07-09 01:22, hash: `85ad73809fa9` Worked: 4.5, before 9e4c26574a **Short description of error** Python traceback when fade operator is executed ``` Python: Traceback (most recent call last): File "C:\Program Files\blender\4.5\scripts\startup\bl_operators\sequencer.py", line 248, in execute strip.invalidate_cache('COMPOSITE') TypeError: ColorStrip.invalidate_cache(): error with argument 1, "type" - enum "COMPOSITE" not found in ('RAW') ``` **Exact steps for others to reproduce the error** - Open Video editing template - Add image or solid color strip - RMB > fade - fade in and out </details> <details> <summary>LLM Reasoning</summary> Got it, let's analyze these two bug reports. First, look at the key sections: description and steps to reproduce. Bug report 1 is about the clipboard_comy operator (probably a typo for clipboard_copy) being affected by rendering properties when copying transparent images. The issue is that the copied image loses transparency based on render settings like color_made (maybe a typo for color_mode). Steps involve opening a transparent image and using the operator, with issues in BW or RGB modes. Bug report 2 is about a Python traceback in the VSE's Fade operator, specifically an error with ColorStrip.invalidate_cache. The steps are adding a strip in Video editing template and using RMB > fade. These are completely different issues: one is about clipboard copying of transparent images affected by render settings, the other is a traceback in VSE's fade operator. So they're not duplicates. </details> <details> <summary>JSON Data</summary> { "llm_judgement": false, "processing_time": 13.291061, "duplicate_report_number": "141652" } </details>

Sign in to join this conversation.

1 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: Triager-bot/blender-bug-reports#75