Frequency Separation Retouching

[GlenBarrington]

I saw an interesting technique on a Website (farbspiel-photo.com) called Frequency Separation Retouching where you separate the photo into two layers, one for fine details and one for tones and colors (which is rendered a bit blurry).

Then the PS tool "Apply Image" is used to subtract the blurred image from the fine detail leaving a sort of High Pass image that can be adjusted for detail. After that, the "Linear Light" blending mod is used to blend the details layer with the tones & color layer.

It seems to me, this ought to be able to be done with PSP and I've been trying to duplicate this technique with PSP X6, but I haven't figured out suitable substitutes for "Apply Image" tool (I'm not certain I even know what it does, completely It seems to be a sort of anti-blend mode) and the "Linear Light" blend mode.

Am I on a fool's errand?

[LeviFiction]

Well, if Apply Image works the way I think it does you might be able to use Image -> Arithmetic to do the same. But, I don't think PSP has a comparison to Linear Light blend mode.

On the positive side there is more than one way to do something.

Photodrawken has actually posted a frequency separation tutorial here on the forums. Maybe it'll give you a few ideas.

http://forum.corel.com/EN/viewtopic.php?f=29&t=48518

[GlenBarrington]

Wonderful! Thanks!

[photodrawken]

Argghh! Too bad the images aren't available on ImageShack anymore. Hope the description of the procedure still helps....

[Klossr]

The procedure still works
When you start with a 16 bits TIFF-file it doesn't work; the colors first have to be reduced to 8 bits. The shortcut for that: CTRL+SHIFT+R

I have made a script for this procedure. You can paste it in Notepad and save it in C:\Users\YOUR_USERNAME\Documents\Corel PaintShop Pro\16.0\Scripts - Trusted
It takes some time to run and you have to fill in the values as described in the procedure the first time.
You'll get 3 pictures as a result; the script will ask for the first one to save it as a photoshop-file (as it contains layers). The other ones are temp-files which can be discarded.

The script:
from PSPApp import *

def ScriptProperties():
return {
'Author': u'Joop Verdoorn',
'Copyright': u'',
'Description': u'',
'Host': u'PaintShop Pro',
'Host Version': u'16.00'
}

def Do(Environment):
# EnableOptimizedScriptUndo
App.Do( Environment, 'EnableOptimizedScriptUndo', {
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# LayerDuplicate
App.Do( Environment, 'LayerDuplicate', {
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# Eigenschappen laag
App.Do( Environment, 'LayerProperties', {
'General': {
'Opacity': None,
'Name': u'Colour',
'IsVisible': None,
'IsTransparencyLocked': None,
'LinkSet': None,
'UseHighlight': None,
'PaletteHighlightColor': None,
'GroupLink': None,
'BlendMode': None
},
'BlendRanges': None,
'Path': (0,0,[],False),
'ArtMediaTexture': None,
'Effects': None,
'BrightnessContrast': None,
'ChannelMixer': None,
'ColorBalance': None,
'CurveParams': None,
'HSL': None,
'Threshold': None,
'Levels': None,
'Posterize': None,
'Vibrancy': None,
'Overlay': None,
'LocalToneMapping': None,
'Invert': None,
'HistogramAdjustment': None,
'FillLightClarity': None,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Silent,
'AutoActionMode': App.Constants.AutoActionMode.Default,
'Version': ((16,0,0),1)
}
})

# Mediaan
App.Do( Environment, 'Median', {
'Aperture': 13,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# Copy
App.Do( Environment, 'Copy', {
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# PasteGraphicAsNewImage
App.Do( Environment, 'PasteGraphicAsNewImage', {
'CreateFromDropData': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# SelectDocument
App.Do( Environment, 'SelectDocument', {
'SelectedImage': 0,
'Strict': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# NegativeImage
App.Do( Environment, 'NegativeImage', {
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# SelectDocument
App.Do( Environment, 'SelectDocument', {
'SelectedImage': -1,
'Strict': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# LayerSetVisibility
App.Do( Environment, 'LayerSetVisibility', {
'Command': App.Constants.ShowCommands.Hide,
'Path': None,
'WorkingMode': 1,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Silent,
'AutoActionMode': App.Constants.AutoActionMode.Default,
'Version': ((16,0,0),1)
}
})

# Arithmetic
App.Do( Environment, 'Arithmetic', {
'AllChannels': True,
'Bias': -128,
'Channel1': 0,
'Channel2': 0,
'ClipColorValues': True,
'Divisor': 1,
'Function': App.Constants.ArithmeticFunctions.Add,
'SourceImage1': 0,
'SourceImage2': 1,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# SelectDocument
App.Do( Environment, 'SelectDocument', {
'SelectedImage': 2,
'Strict': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# Copy
App.Do( Environment, 'Copy', {
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# SelectDocument
App.Do( Environment, 'SelectDocument', {
'SelectedImage': -2,
'Strict': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# PasteAsNewLayer
App.Do( Environment, 'PasteAsNewLayer', {
'CreateFromDropData': False,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.Match,
'Version': ((16,0,0),1)
}
})

# MultiObjectProperties
App.Do( Environment, 'MultiObjectProperties', {
'General': {
'Opacity': None,
'Name': None,
'IsVisible': None,
'IsTransparencyLocked': None,
'LinkSet': None,
'UseHighlight': None,
'PaletteHighlightColor': None,
'GroupLink': None,
'BlendMode': App.Constants.BlendMode.Overlay
},
'Effects': None,
'WorkingMode': 1,
'Path': None,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Silent,
'AutoActionMode': App.Constants.AutoActionMode.AllAlways,
'Version': ((16,0,0),1)
}
})

# FileSaveAs
App.Do( Environment, 'FileSaveAs', {
'Encoding': {

},
'FileName': u'-fs.psd',
'FileFormat': App.Constants.FileFormat.PSD,
'FormatDesc': u'PSD Photoshop',
'WorkingMode': 0,
'GeneralSettings': {
'ExecutionMode': App.Constants.ExecutionMode.Default,
'AutoActionMode': App.Constants.AutoActionMode.AllAlways,
'Version': ((16,0,0),1)
},
'DefaultProperties': []
})

[AlanT]

I've also become a fan of frequency separation. My process is a bit different, and is not only easier, but also works with 16-bit images as well.

You start the same way, and create 2 duplicates of the image you want to edit. Rename the top one as "texture" or "high" and the other as "color" or "low". At this point, you will have 3 layers -- the original background plus 2 edit layers.

Now, select the texture layer and do a high-pass edge effect. Play with the settings so you retain the texture you want to keep and no more. In my case, (with 36 megapixel images of headshots) I tend to use settings around 5 to 9. Change the blend mode of this layer to hard light. At this point, the image will look "too sharp".

Next, select the color layer and do a guassian blur using the same value you used with the high-pass. Once done, the image will again look like the original.

To verify this, make a copy of the original background layer, bring this "check layer" to the top of the stack, zoom in to a 1:1 view, and turn the visibility of the check layer on and off to see that there are practically no differences between the 2.

From here, delete (or turn off) the check layer, and do your frequency separation retouching as you would in the other software.

One thing I do to eliminate any potential differences between the separated image and the original is to group the retouching layers with a mask and allow only those areas which have been retouched to be seen.

[migf1]

Hi guys, ancient topic but I just have to share this! Plus, I just realized I posted on a different sub-forum, so I'm just putting a link to that post here: https://forum.corel.com/viewtopic.php?p=386127#p386127

It's an insane Frequency Separation shortcut I just found out about!