GamutCompress.fuse

--[[--
-----------------------------

Gamut Compress is a tool to compress out of gamut colors back into gamut.
Written by Jed Smith with lots of help from the ACES Gamut Mapping Virtual Working Group
https://github.com/jedypod/gamut-compress
https://community.acescentral.com/t/rgb-saturation-gamut-mapping-approach-and-a-comp-vfx-perspective
https://community.acescentral.com/c/aces-development-acesnext/vwg-aces-gamut-mapping-working-group

Initial version of this Fuse written by Jacob Danell. Thank you! :D


------------------
Documenation

Threshold
Percentage of the gamut to affect. 
If threshold is 0.2, the inner 80% of the gamut will be unaffected 
and out of gamut values will be compressed into the outer 20% of the gamuts color volume.

Max Distance
Per color component control to specify what distance will be compressed to the gamut boundary. 
For example, a value of d_c=0.2 will map colors with a distance of 
red=1.2 from the achromatic axis to red=1.0, which is the gamut boundary.

Direction
Specifies whether to apply or inverse the gamut compression operation.


-------------------------
Installation

To install this fuse for Blackmagic Fusion Studio, copy the file to your UserData Path Map folder:

Linux:
  ~/.fusion/BlackmagicDesign/Fusion/Fuses
OSX: 
  ~/Library/Application Support/Blackmagic Design/Fusion
Windows:
  %appdata%\Blackmagic Design\Fusion\Fuses


For the Fusion page in Resolve Lite or Resolve Studio use these UserData folders:

Linux: 
  ~/.local/share/DaVinciResolve/Fusion/Fuses
OSX:
  ~/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion
Windows:
  %appdata%\Blackmagic Design\DaVinci Resolve\Fusion\Fuses


--]]--


FuRegisterClass("GamutCompress", CT_Tool, {
  REGS_Name = "Gamut Compress",
  REGS_Category = "Color",
  REGS_OpIconString = "",
  REGS_OpDescription = "Compress out of gamut colors back into gamut.",
  REG_Fuse_NoEdit = false,
  REG_Fuse_NoReload = false,
  REG_SupportsDoD = false,
})


function Create()
  InThresholdR = self:AddInput("thr c", "thr c", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.15,
    INP_MinAllowed = 0.0001,
    INP_MaxScale = 0.3,
  })

  InThresholdG = self:AddInput("thr m", "thr m", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.15,
    INP_MinAllowed = 0.0001,
    INP_MaxScale = 0.3,
  })

  InThresholdB = self:AddInput("thr y", "thr y", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.15,
    INP_MinAllowed = 0.0001,
    INP_MaxScale = 0.3,
  })

  self:BeginControlNest("max distance limits", "max distance limits", true, {})
  
  InCyan = self:AddInput("dist c", "dist c", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.1,
    INP_MinAllowed = 0.0,
    INP_MaxScale = 0.4,
  })
  
  InMagenta = self:AddInput("dist m", "dist m", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.2,
    INP_MinAllowed = 0.0,
    INP_MaxScale = 0.4,
  })
  
  InYellow = self:AddInput("dist y", "dist y", {
    LINKID_DataType = "Number",
    INPID_InputControl = "SliderControl",
    INP_Default = 0.1,
    INP_MinAllowed = 0.0,
    INP_MaxScale = 0.4,
  })
  
  self:EndControlNest()

  InInvert = self:AddInput("invert", "invert", {
    LINKID_DataType = "Number",
    INPID_InputControl = "CheckboxControl",
    INP_MinAllowed = 0.0,
    INP_MaxAllowed = 1.0,
    INP_Default = 0.0,
  })

  InImage = self:AddInput("Input", "Input", {
    LINKID_DataType = "Image",
    LINK_Main = 1,
  })

  OutImage = self:AddOutput("Output", "Output", {
   LINKID_DataType = "Image",
   LINK_Main = 1,
  })
end

local lastreqtime = -2

function Process(req)
  local src = InImage:GetValue(req)
  local dst = Image{ IMG_Like = src, IMG_DeferAlloc = true }

  if not req:IsPreCalc() then
    local node = DVIPComputeNode(req, "SolidKernel", SolidKernel, "SolidParams", SolidParams)
    
    local params
    if (lastreqtime ~= req.Time - 1) then
        params = node:GetParamBlock(SolidParams)
    end
    lastreqtime = req.Time

    params.th_c = InThresholdR:GetValue(req).Value
    params.th_m = InThresholdG:GetValue(req).Value
    params.th_y = InThresholdB:GetValue(req).Value
    params.d_c = InCyan:GetValue(req).Value
    params.d_m = InMagenta:GetValue(req).Value
    params.d_y = InYellow:GetValue(req).Value
    params.invert = InInvert:GetValue(req).Value
    params.srcCompOrder = src:IsMask() and 1 or 15
 
    node:SetParamBlock(params)
 
    node:AddInput("src", src)
    node:AddOutput("dst", dst)
 
    local ok = node:RunSession(req)
 
    if not ok then
        dst = nil
    end

  end

  OutImage:Set(req, dst)
end


SolidParams = [[
  float th_c;
  float th_m;
  float th_y;
  float d_c;
  float d_m;
  float d_y;
  int invert;
  int srcCompOrder;
]]

 
SolidKernel = [[

__KERNEL__ void SolidKernel(__CONSTANTREF__ SolidParams *params, __TEXTURE2D__ src, __TEXTURE2D_WRITE__ dst)
{
  DEFINE_KERNEL_ITERATORS_XY(x, y);
  float4 rgba = _tex2DVecN(src, x, y, params->srcCompOrder);
  float3 rgb = make_float3(rgba.x, rgba.y, rgba.z);

  // Amount of outer gamut to affect
  float3 th = 1.0f-make_float3(params->th_c, params->th_m, params->th_y);

  // Distance limit: How far beyond the gamut boundary to compress
  float3 dl = 1.0f+make_float3(params->d_c, params->d_m, params->d_y);

  // Calculate scale so compression function passes through distance limit: (x=dl, y=1)
  float3 s;
  s.x = (1.0f-th.x)/_sqrtf(_fmaxf(1.001f, dl.x)-1.0f);
  s.y = (1.0f-th.y)/_sqrtf(_fmaxf(1.001f, dl.y)-1.0f);
  s.z = (1.0f-th.z)/_sqrtf(_fmaxf(1.001f, dl.z)-1.0f);
  
  // Achromatic axis
  float ac = _fmaxf(rgb.x, _fmaxf(rgb.y, rgb.z));

  // Inverse RGB Ratios: distance from achromatic axis
  float3 d = ac == 0.0f ? make_float3(0.0f) : (ac-rgb)/_fabs(ac);

  float3 cd; // Compressed distance
  // Parabolic compression function: https://www.desmos.com/calculator/nvhp63hmtj
  if (params->invert == 0) {
    cd.x = d.x<th.x?d.x:s.x*_sqrtf(d.x-th.x+s.x*s.x/4.0f)-s.x*_sqrtf(s.x*s.x/4.0f)+th.x;
    cd.y = d.y<th.y?d.y:s.y*_sqrtf(d.y-th.y+s.y*s.y/4.0f)-s.y*_sqrtf(s.y*s.y/4.0f)+th.y;
    cd.z = d.z<th.z?d.z:s.z*_sqrtf(d.z-th.z+s.z*s.z/4.0f)-s.z*_sqrtf(s.z*s.z/4.0f)+th.z;
  } else {
    cd.x = d.x<th.x?d.x:_powf(d.x-th.x+s.x*_sqrtf(s.x*s.x/4.0f),2.0f)/(s.x*s.x)-s.x*s.x/4.0f+th.x;
    cd.y = d.y<th.y?d.y:_powf(d.y-th.y+s.y*_sqrtf(s.y*s.y/4.0f),2.0f)/(s.y*s.y)-s.y*s.y/4.0f+th.y;
    cd.z = d.z<th.z?d.z:_powf(d.z-th.z+s.z*_sqrtf(s.z*s.z/4.0f),2.0f)/(s.z*s.z)-s.z*s.z/4.0f+th.z;
  }

  // Inverse RGB Ratios to RGB
  rgb = ac-cd*_fabs(ac);

  rgba = make_float4(rgb.x, rgb.y, rgb.z, rgba.w);
  _tex2DVec4Write(dst, x, y, rgba);
}

]]