 |
| GimpChat Member |
 |
Joined: Jan 20, 2012
Posts: 583
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Color Grading v1.5.2
# Copyright (c) 2012 John Lakkas
# [email protected]
# Licence: GNU GPLv3 ( http://www.gnu.org/licenses/ )
# This program is distributed WITHOUT ANY WARRANTY.
# You using it in your own risk.
# Version: 1.5.2
# > GIMP 2.8 compatibility fixes
# > Code cleaning
# Version: 1.5.1
# > Code bugfix
# Version: 1.5
# > Information pane for applying the corrections in another program
# > Profiles
# Version: 1.4
# > Major engine refactoring
# > Speed improvement
# Version: 1.3
# > Double version slider/colorwheel availability
# > UI reshaping to look like professional tools
# > Midtones bugfix
# Version: 1.2
# > saturation introduced
# Version: 1.1
# > levels introduced
# Version: 1.0
# > first production version
# Preview function taken from:
# python High Pass Sharpen
# version-1.2 01/04/2010
# Copyright (c) 2008-2010 Paul Sherman
# inspired by layerfx.py by Jonathan Stipe
# and the high-pass-sharpen.scm by Martin Egger
# HSV conversions taken from libgimpcolor/gimphsv.c
# LIBGIMP - The GIMP Library
# Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
# From the following links:
# http://www.gimphelp.org/python_fu.shtml
# http://www.gimphelp.org/scripts/high_end_sharpen_py.shtml
import gimp, gimpplugin, math
from gimpenums import *
pdb = gimp.pdb
import gtk, gimpui, gimpcolor
from gimpshelf import shelf
import os
#import numpy
import math
import cairo
import ConfigParser
import string
class reuse_init(object):
previewLayer = None
def get_layer_pos(self, layer):
i = 0
while i < len(self.img.layers):
if layer == self.img.layers[i]:
return i
else:
i += 1
return -1
def layer_exists(self, layer):
return layer != None and layer in self.img.layers
def removePreviews(self):
if self.layer_exists(self.previewLayer):
self.img.remove_layer(self.previewLayer)
self.previewLayer = None
gimp.displays_flush()
def make_label(self, text):
label = gtk.Label(text)
label.set_use_underline(True)
label.set_alignment(1.0, 0.5)
label.show()
return label
def make_slider_and_spinner(self, init, min, max, step, page, digits):
controls = {'adj':gtk.Adjustment(init, min, max, step, page), 'slider':gtk.HScale(), 'spinner':gtk.SpinButton()}
controls['slider'].set_adjustment(controls['adj'])
controls['slider'].set_draw_value(False)
controls['spinner'].set_adjustment(controls['adj'])
controls['spinner'].set_digits(digits)
controls['slider'].show()
controls['spinner'].show()
return controls
def show_error_msg(self, msg):
origMsgHandler = pdb.gimp_message_get_handler()
pdb.gimp_message_set_handler(ERROR_CONSOLE)
pdb.gimp_message(msg)
pdb.gimp_message_set_handler(origMsgHandler)
def stringToColor(self, string):
colorlist = string[5:-1].split(", ")
return gimpcolor.RGB(float(colorlist[0]), float(colorlist[1]), float(colorlist[2]), float(colorlist[3]))
class color_grading_cw(reuse_init):
def __init__(self, runmode, img, drawable, shh, shs, shlev, midh, mids, midlev, highh, highs, highlev, satlev):
self.img = img
self.drawable = drawable
#self.shelfkey = 'layerfx-drop-shadow'
#print "runmode:"
#print runmode
if (runmode ==0 ):
self.showDialog()
else:
fxlayer = self.makeLayer(self.img, self.drawable,
shh,
shs,
shlev,
midh,
mids,
midlev,
highh,
highs,
highlev,
satlev
)
def showDialog(self):
self.dialog = gimpui.Dialog("Color Grading", "colorgradingdialog")
#notebook page1
self.table = gtk.Table(5, 3, True)
self.table.set_homogeneous(False)
self.table.set_row_spacings(8)
self.table.set_col_spacings(8)
self.table.set_border_width(10)
self.table.show()
filename = os.path.join(os.path.expanduser("~"), ".gimp-2.8", "plug-ins", "colorwheel_150.png")
self.pixbuf = gtk.gdk.pixbuf_new_from_file(filename)
self.wheel_sh = ColorWheel(self.pixbuf, 75, 75, 75)
self.wheel_sh.show()
self.wheel_mid = ColorWheel(self.pixbuf, 75, 75, 75)
self.wheel_mid.show()
self.wheel_high = ColorWheel(self.pixbuf, 75, 75, 75)
self.wheel_high.show()
self.table.attach(self.wheel_sh, 0, 1, 1, 2)
self.table.attach(self.wheel_mid, 1, 2, 1, 2)
self.table.attach(self.wheel_high, 2, 3, 1, 2)
self.shlev_label = self.make_label("Shadows level:")
self.midlev_label = self.make_label("Midtones level:")
self.highlev_label = self.make_label("Highlights level:")
self.satlev_label = self.make_label("Saturation:")
self.table.attach(self.shlev_label, 0, 1, 2, 3)
self.table.attach(self.midlev_label, 1, 2, 2, 3)
self.table.attach(self.highlev_label, 2, 3, 2, 3)
self.table.attach(self.satlev_label, 0, 1, 5, 6)
self.shlev_spinner = self.make_slider_and_spinner(0, -100, 100, 1, 1, 0)
self.midlev_spinner = self.make_slider_and_spinner(0, -100, 100, 1, 1, 0)
self.highlev_spinner = self.make_slider_and_spinner(0, -100, 100, 1, 1, 0)
self.satlev_spinner = self.make_slider_and_spinner(0, -100, 100, 1, 1, 0)
self.shlev_spinner['adj'].set_value(0)
self.midlev_spinner['adj'].set_value(0)
self.highlev_spinner['adj'].set_value(0)
self.satlev_spinner['adj'].set_value(0)
self.shlev_label.set_mnemonic_widget(self.shlev_spinner['spinner'])
self.midlev_label.set_mnemonic_widget(self.midlev_spinner['spinner'])
self.highlev_label.set_mnemonic_widget(self.highlev_spinner['spinner'])
self.satlev_label.set_mnemonic_widget(self.satlev_spinner['spinner'])
self.table.attach(self.shlev_spinner['slider'], 0, 1, 3, 4)
self.table.attach(self.midlev_spinner['slider'], 1, 2, 3, 4)
self.table.attach(self.highlev_spinner['slider'], 2, 3, 3, 4)
self.table.attach(self.satlev_spinner['slider'], 1, 2, 5, 6)
self.table.attach(self.shlev_spinner['spinner'], 0, 1, 4, 5)
self.table.attach(self.midlev_spinner['spinner'], 1, 2, 4, 5)
self.table.attach(self.highlev_spinner['spinner'], 2, 3, 4, 5)
self.table.attach(self.satlev_spinner['spinner'], 2, 3, 5, 6)
#notebook page2
self.table2 = gtk.Table(13, 2, True)
self.table2.set_homogeneous(False)
self.table2.set_row_spacings(8)
self.table2.set_col_spacings(8)
self.table2.set_border_width(10)
self.table2.show()
#self.table2.set_col_spacing(1, 40)
self.sh_hsv_label = self.make_label("Shadows HSV:")
self.mid_hsv_label = self.make_label("Midtones HSV:")
self.high_hsv_label = self.make_label("Highlights HSV:")
self.sh_hsvv_label = self.make_label("1,1,1")
self.mid_hsvv_label = self.make_label("1,1,1")
self.high_hsvv_label = self.make_label("1,1,1")
self.sh_hsvv_label.set_alignment(0.0, 0.5)
self.mid_hsvv_label.set_alignment(0.0, 0.5)
self.high_hsvv_label.set_alignment(0.0, 0.5)
self.rch_label = self.make_label("Red Levels:")
self.gch_label = self.make_label("Green Levels:")
self.bch_label = self.make_label("Blue Levels:")
self.rinp_label = self.make_label("Input:")
self.ginp_label = self.make_label("Input:")
self.binp_label = self.make_label("Input:")
self.rout_label = self.make_label("Output:")
self.gout_label = self.make_label("Output:")
self.bout_label = self.make_label("Output:")
self.sat_label = self.make_label("Saturation:")
self.satv_label = self.make_label("1")
self.satv_label.set_alignment(0.0, 0.5)
self.rinpv_label = self.make_label("1")
self.ginpv_label = self.make_label("1")
self.binpv_label = self.make_label("1")
self.routv_label = self.make_label("1")
self.goutv_label = self.make_label("1")
self.boutv_label = self.make_label("1")
self.rinpv_label.set_alignment(0.0, 0.5)
self.ginpv_label.set_alignment(0.0, 0.5)
self.binpv_label.set_alignment(0.0, 0.5)
self.routv_label.set_alignment(0.0, 0.5)
self.goutv_label.set_alignment(0.0, 0.5)
self.boutv_label.set_alignment(0.0, 0.5)
self.table2.attach(self.sh_hsv_label, 0, 1, 0, 1)
self.table2.attach(self.mid_hsv_label, 0, 1, 1, 2)
self.table2.attach(self.high_hsv_label, 0, 1, 2, 3)
self.table2.attach(self.sh_hsvv_label, 1, 2, 0, 1)
self.table2.attach(self.mid_hsvv_label, 1, 2, 1, 2)
self.table2.attach(self.high_hsvv_label, 1, 2, 2, 3)
self.table2.attach(self.rch_label, 0, 1, 4, 5)
self.table2.attach(self.rinp_label, 0, 1, 5, 6)
self.table2.attach(self.rout_label, 0, 1, 6, 7)
self.table2.attach(self.gch_label, 0, 1, 7, 8)
self.table2.attach(self.ginp_label, 0, 1, 8, 9)
self.table2.attach(self.gout_label, 0, 1, 9, 10)
self.table2.attach(self.bch_label, 0, 1, 10, 11)
self.table2.attach(self.binp_label, 0, 1, 11, 12)
self.table2.attach(self.bout_label, 0, 1, 12, 13)
self.table2.attach(self.sat_label, 0, 1, 13, 14)
self.table2.attach(self.rinpv_label, 1, 2, 5, 6)
self.table2.attach(self.routv_label, 1, 2, 6, 7)
self.table2.attach(self.ginpv_label, 1, 2, 8, 9)
self.table2.attach(self.goutv_label, 1, 2, 9, 10)
self.table2.attach(self.binpv_label, 1, 2, 11, 12)
self.table2.attach(self.boutv_label, 1, 2, 12, 13)
self.table2.attach(self.satv_label, 1, 2, 13, 14)
#notebook page3
self.table3 = gtk.Table(5, 1, True)
self.table3.set_homogeneous(False)
self.table3.set_row_spacings(8)
self.table3.set_col_spacings(8)
self.table3.set_border_width(10)
self.table3.show()
self.liststore = gtk.ListStore(int, str)
#self.liststore.append([1, 'Profile 1'])
self.prof_list = gtk.TreeView(self.liststore)
cell_renderer = gtk.CellRendererText()
column0 = gtk.TreeViewColumn('id', cell_renderer, text=0)
column1 = gtk.TreeViewColumn('Profile Name', cell_renderer, text=1)
column0.set_resizable(True)
column1.set_resizable(True)
self.prof_list.append_column(column0)
self.prof_list.append_column(column1)
self.prof_list.connect("cursor-changed", self.prof_list_selection)
self.prof_list.show()
self.selected_profile = -1
self.table3.attach(self.prof_list, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND)
self.prof_name_text = gtk.Entry()
self.prof_name_text.show()
self.load_profile_button = gtk.Button("Load Profile")
self.saveas_profile_button = gtk.Button("Save As Profile")
self.delete_profile_button = gtk.Button("Delete Profile")
self.load_profile_button.connect("clicked", self.load_sel_profile)
self.saveas_profile_button.connect("clicked", self.saveas_sel_profile)
self.delete_profile_button.connect("clicked", self.delete_sel_profile)
self.load_profile_button.show()
self.saveas_profile_button.show()
self.delete_profile_button.show()
self.table3.attach(self.load_profile_button, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
self.table3.attach(self.delete_profile_button, 0, 1, 2, 3, gtk.FILL, gtk.FILL)
self.table3.attach(self.saveas_profile_button, 0, 1, 3, 4, gtk.FILL, gtk.FILL)
self.table3.attach(self.prof_name_text, 0, 1, 4, 5, gtk.FILL, gtk.FILL)
#notebook definition
self.notebook = gtk.Notebook()
self.notebook.connect("switch-page", self.refresh_info)
self.notebook.show()
self.nb_label1 = gtk.Label('Color Wheels')
self.nb_label1.show()
self.nb_label2 = gtk.Label('Information')
self.nb_label2.show()
self.nb_label3 = gtk.Label('Profiles')
self.nb_label3.show()
self.notebook.append_page(self.table, self.nb_label1)
self.notebook.append_page(self.table2, self.nb_label2)
self.notebook.append_page(self.table3, self.nb_label3)
#Profile loading: If file does not exist create one.
self.parser = ConfigParser.SafeConfigParser(
defaults={
'name':'Default profile',
'shadowshsv': '0.0|0.0|0.0',
'midtoneshsv': '0.0|0.0|0.0',
'highlightshsv': '0.0|0.0|0.0',
'redlevels_in': '0|1.0|255',
'greenlevels_in': '0|1.0|255',
'bluelevels_in': '0|1.0|255',
'redlevels_out': '0|255',
'greenlevels_out': '0|255',
'bluelevels_out': '0|255',
'saturation': '0',
'shadowslev': '0',
'midtoneslev': '0',
'highlightslev': '0'
})
self.profile_filename = os.path.join(os.path.expanduser("~"), ".gimp-2.8", "plug-ins", "colorgrading.profiles")
if (os.path.isfile(self.profile_filename) == True):
self.parser.read(self.profile_filename)
else:
self.parser.add_section('Profiles')
self.parser.set('Profiles', 'list', 'DEFAULT')
self.parser.set('Profiles', 'userprofileprefix', 'Prof')
self.parser.set('Profiles', 'integercurrent', '0')
f = file(self.profile_filename, 'w')
self.parser.write(f)
f.close()
self.refresh_prof_list()
self.load_profile('DEFAULT')
# Rest UI loading stuff
self.dialog.vbox.hbox1 = gtk.HBox(False, 7)
self.dialog.vbox.hbox1.show()
self.dialog.vbox.pack_start(self.dialog.vbox.hbox1, True, True, 7)
self.dialog.vbox.hbox1.pack_start(self.notebook, True, True, 7)
reset_button = gtk.Button("_Reset")
reset_button.connect("clicked", self.resetbutton)
reset_button.show()
self.preview_button = gtk.Button("Preview")
self.preview_button.connect("clicked", self.preview)
self.preview_button.set_size_request(100, -1)
self.preview_button.show()
if gtk.alternative_dialog_button_order():
ok_button = self.dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
cancel_button = self.dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
self.dialog.action_area.add(reset_button)
self.dialog.action_area.add(self.preview_button)
else:
self.dialog.action_area.add(self.preview_button)
self.dialog.action_area.add(reset_button)
cancel_button = self.dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
ok_button = self.dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
ok_button.connect("clicked", self.okbutton)
self.dialog.show()
self.dialog.run()
self.removePreviews()
def refresh_info(self, widget, page, page_num):
if (page_num == 1):
sh_hsv = self.wheel_sh.get_wheel_hsv()
mid_hsv = self.wheel_mid.get_wheel_hsv()
high_hsv = self.wheel_high.get_wheel_hsv()
sh_hsv_str = "{0}, {1}, {2}".format( str(round(sh_hsv[0],1)), str(round(sh_hsv[1],3)), str(round(sh_hsv[2],2)) )
mid_hsv_str = "{0}, {1}, {2}".format( str(round(mid_hsv[0],1)), str(round(mid_hsv[1],3)), str(round(mid_hsv[2],2)) )
high_hsv_str = "{0}, {1}, {2}".format( str(round(high_hsv[0],1)), str(round(high_hsv[1],3)), str(round(high_hsv[2],2)) )
self.sh_hsvv_label.set_text(sh_hsv_str)
self.mid_hsvv_label.set_text(mid_hsv_str)
self.high_hsvv_label.set_text(high_hsv_str)
rgbshift = self.convert_to_rgbshifts(
self.wheel_sh.hsv[0],
self.wheel_sh.hsv[1],
self.shlev_spinner['adj'].get_value(),
self.wheel_mid.hsv[0],
self.wheel_mid.hsv[1],
self.midlev_spinner['adj'].get_value(),
self.wheel_high.hsv[0],
self.wheel_high.hsv[1],
self.highlev_spinner['adj'].get_value(),
self.satlev_spinner['adj'].get_value()
)
levels = self.convert_to_levels(rgbshift[0], rgbshift[1], rgbshift[2], rgbshift[3], rgbshift[4], rgbshift[5], rgbshift[6], rgbshift[7], rgbshift[8], rgbshift[9], rgbshift[10], rgbshift[11], rgbshift[12])
redinp = "{0} {1} {2}".format( str(int(levels[0][0])), str(round(levels[0][2],2)), str(int(levels[0][1])) )
redout = "{0} {1}".format( str(int(levels[0][3])), str(int(levels[0][4])) )
greeninp = "{0} {1} {2}".format( str(int(levels[1][0])), str(round(levels[1][2],2)), str(int(levels[1][1])) )
greenout = "{0} {1}".format( str(int(levels[1][3])), str(int(levels[1][4])) )
blueinp = "{0} {1} {2}".format( str(int(levels[2][0])), str(round(levels[2][2],2)), str(int(levels[2][1])) )
blueout = "{0} {1}".format( str(int(levels[2][3])), str(int(levels[2][4])) )
sat = str(int(levels[3][0]))
self.rinpv_label.set_text(redinp)
self.routv_label.set_text(redout)
self.ginpv_label.set_text(greeninp)
self.goutv_label.set_text(greenout)
self.binpv_label.set_text(blueinp)
self.boutv_label.set_text(blueout)
self.satv_label.set_text(sat)
def refresh_prof_list(self):
self.profiles = string.split(self.parser.get('Profiles', 'list'), '|')
self.profile_int = int(self.parser.get('Profiles', 'integercurrent'))
self.liststore.clear()
n = len(self.profiles)
for i in range(0, n):
name = self.parser.get(self.profiles[i], 'name')
self.liststore.append([i, name])
def prof_list_selection(self, widget):
treeselection = widget.get_selection()
selection = treeselection.get_selected()
treemodel = selection[0]
treeiter = selection[1]
self.selected_profile = treemodel.get_value(treeiter, 0)
#print treemodel.get_value(treeiter, 0)
self.prof_name_text.set_text(treemodel.get_value(treeiter, 1))
if (self.selected_profile == 0):
self.delete_profile_button.set_sensitive(False)
else:
self.delete_profile_button.set_sensitive(True)
def load_profile(self, profile_internal_name):
hsv = string.split(self.parser.get(profile_internal_name, 'shadowshsv'), '|')
sh_hsv = [float(hsv[0]), float(hsv[1]), float(hsv[2])]
hsv = string.split(self.parser.get(profile_internal_name, 'midtoneshsv'), '|')
mid_hsv = [float(hsv[0]), float(hsv[1]), float(hsv[2])]
hsv = string.split(self.parser.get(profile_internal_name, 'highlightshsv'), '|')
high_hsv = [float(hsv[0]), float(hsv[1]), float(hsv[2])]
self.shlev_spinner['adj'].set_value( float(self.parser.get(profile_internal_name, 'shadowslev')) )
self.midlev_spinner['adj'].set_value( float(self.parser.get(profile_internal_name, 'midtoneslev')) )
self.highlev_spinner['adj'].set_value( float(self.parser.get(profile_internal_name, 'highlightslev')) )
self.satlev_spinner['adj'].set_value( float(self.parser.get(profile_internal_name, 'saturation')) )
self.wheel_sh.set_wheel_hsv(sh_hsv)
self.wheel_mid.set_wheel_hsv(mid_hsv)
self.wheel_high.set_wheel_hsv(high_hsv)
def load_sel_profile(self, widget):
self.load_profile(self.profiles[self.selected_profile])
self.wheel_sh.refresh_view()
self.wheel_mid.refresh_view()
self.wheel_high.refresh_view()
def saveas_sel_profile(self, widget):
exists = False
internal_name = ""
profile_name = self.prof_name_text.get_text()
if (profile_name != ""):
n = len(self.profiles)
for i in range(0, n):
name = self.parser.get(self.profiles[i], 'name')
if (profile_name == name):
exists = True
internal_name = self.profiles[i]
break
if (exists == False):
internal_name = self.parser.get('Profiles', 'userprofileprefix') + str( int(self.parser.get('Profiles', 'integercurrent')) +1 )
self.parser.add_section(internal_name)
self.profile_int = self.profile_int + 1
self.parser.set('Profiles', 'integercurrent', str(self.profile_int))
self.profiles = self.profiles.append(internal_name)
self.parser.set('Profiles', 'list', self.parser.get('Profiles', 'list') + "|" + internal_name )
self.parser.set(internal_name, 'name', profile_name)
sh_hsv = self.wheel_sh.get_wheel_hsv()
mid_hsv = self.wheel_mid.get_wheel_hsv()
high_hsv = self.wheel_high.get_wheel_hsv()
sh_hsv_str = "{0}|{1}|{2}".format( str(round(sh_hsv[0],1)), str(round(sh_hsv[1],3)), str(round(sh_hsv[2],2)) )
mid_hsv_str = "{0}|{1}|{2}".format( str(round(mid_hsv[0],1)), str(round(mid_hsv[1],3)), str(round(mid_hsv[2],2)) )
high_hsv_str = "{0}|{1}|{2}".format( str(round(high_hsv[0],1)), str(round(high_hsv[1],3)), str(round(high_hsv[2],2)) )
rgbshift = self.convert_to_rgbshifts(
self.wheel_sh.hsv[0],
self.wheel_sh.hsv[1],
self.shlev_spinner['adj'].get_value(),
self.wheel_mid.hsv[0],
self.wheel_mid.hsv[1],
self.midlev_spinner['adj'].get_value(),
self.wheel_high.hsv[0],
self.wheel_high.hsv[1],
self.highlev_spinner['adj'].get_value(),
self.satlev_spinner['adj'].get_value()
)
levels = self.convert_to_levels(rgbshift[0], rgbshift[1], rgbshift[2], rgbshift[3], rgbshift[4], rgbshift[5], rgbshift[6], rgbshift[7], rgbshift[8], rgbshift[9], rgbshift[10], rgbshift[11], rgbshift[12])
redinp = "{0}|{1}|{2}".format( str(int(levels[0][0])), str(round(levels[0][2],2)), str(int(levels[0][1])) )
redout = "{0}|{1}".format( str(int(levels[0][3])), str(int(levels[0][4])) )
greeninp = "{0}|{1}|{2}".format( str(int(levels[1][0])), str(round(levels[1][2],2)), str(int(levels[1][1])) )
greenout = "{0}|{1}".format( str(int(levels[1][3])), str(int(levels[1][4])) )
blueinp = "{0}|{1}|{2}".format( str(int(levels[2][0])), str(round(levels[2][2],2)), str(int(levels[2][1])) )
blueout = "{0}|{1}".format( str(int(levels[2][3])), str(int(levels[2][4])) )
sat = str(int(levels[3][0]))
self.parser.set(internal_name, 'shadowshsv', sh_hsv_str)
self.parser.set(internal_name, 'midtoneshsv', mid_hsv_str)
self.parser.set(internal_name, 'highlightshsv', high_hsv_str)
self.parser.set(internal_name, 'redlevels_in', redinp)
self.parser.set(internal_name, 'greenlevels_in', greeninp)
self.parser.set(internal_name, 'bluelevels_in', blueinp)
self.parser.set(internal_name, 'redlevels_out', redout)
self.parser.set(internal_name, 'greenlevels_out', greenout)
self.parser.set(internal_name, 'bluelevels_out', blueout)
self.parser.set(internal_name, 'saturation', sat)
self.parser.set(internal_name, 'shadowslev', str(self.shlev_spinner['adj'].get_value()))
self.parser.set(internal_name, 'midtoneslev', str(self.midlev_spinner['adj'].get_value()))
self.parser.set(internal_name, 'highlightslev', str(self.highlev_spinner['adj'].get_value()))
f = file(self.profile_filename, 'w')
self.parser.write(f)
f.close()
self.refresh_prof_list()
def delete_sel_profile(self, widget):
self.parser.remove_section(self.profiles[self.selected_profile])
new_profiles = ""
n = len(self.profiles)
j = 0
for i in range(0, n):
if (self.selected_profile != i):
j = j +1
if (j != n-1):
new_profiles = new_profiles + self.profiles[i] + "|"
else:
new_profiles = new_profiles + self.profiles[i]
self.parser.set('Profiles', 'list', new_profiles)
self.profiles = string.split(self.parser.get('Profiles', 'list'), '|')
f = file(self.profile_filename, 'w')
self.parser.write(f)
f.close()
self.refresh_prof_list()
def okbutton(self, widget):
# remove old preview layer if it exists
if self.layer_exists(self.previewLayer):
self.img.remove_layer(self.previewLayer)
self.previewLayer = None
# then build new layer with current settings to actually impliment...
fxlayer = self.makeLayer(self.img, self.drawable,
self.wheel_sh.hsv[0],
self.wheel_sh.hsv[1],
self.shlev_spinner['adj'].get_value(),
self.wheel_mid.hsv[0],
self.wheel_mid.hsv[1],
self.midlev_spinner['adj'].get_value(),
self.wheel_high.hsv[0],
self.wheel_high.hsv[1],
self.highlev_spinner['adj'].get_value(),
self.satlev_spinner['adj'].get_value()
)
def resetbutton(self, widget):
self.wheel_sh.reset()
self.shlev_spinner['adj'].set_value(0)
self.wheel_mid.reset()
self.midlev_spinner['adj'].set_value(0)
self.wheel_high.reset()
self.highlev_spinner['adj'].set_value(0)
self.satlev_spinner['adj'].set_value(0)
def preview(self, widget):
ptxt = self.preview_button.get_label()
if self.layer_exists(self.previewLayer):
self.img.remove_layer(self.previewLayer)
gimp.displays_flush()
else:
self.previewLayer = self.makeLayer(self.img, self.drawable,
self.wheel_sh.hsv[0],
self.wheel_sh.hsv[1],
self.shlev_spinner['adj'].get_value(),
self.wheel_mid.hsv[0],
self.wheel_mid.hsv[1],
self.midlev_spinner['adj'].get_value(),
self.wheel_high.hsv[0],
self.wheel_high.hsv[1],
self.highlev_spinner['adj'].get_value(),
self.satlev_spinner['adj'].get_value()
)
if ptxt == "Preview":
ptxt = "Undo Preview"
else:
ptxt = "Preview"
self.preview_button.set_label(ptxt)
def convert_to_rgbshifts(self, shh, shs, shlev, midh, mids, midlev, highh, highs, highlev, satlev):
hsvsh = [shh, 1.0, shs * 0.40]
hsvmid = [midh, 1.0, mids * 0.40]
hsvhigh = [highh, 1.0, highs * 0.40]
hsvtool = HSVbasics()
rgbsh = hsvtool.gimp_hsv_to_rgb4(hsvsh)
rgbmid = hsvtool.gimp_hsv_to_rgb4(hsvmid)
rgbhigh = hsvtool.gimp_hsv_to_rgb4(hsvhigh)
crsh = rgbsh[0]
mgsh = rgbsh[1]
ybsh = rgbsh[2]
crmid = rgbmid[0]
mgmid = rgbmid[1]
ybmid = rgbmid[2]
crhigh = rgbhigh[0]
mghigh = rgbhigh[1]
ybhigh = rgbhigh[2]
return [crsh, mgsh, ybsh, shlev, crmid, mgmid, ybmid, midlev, crhigh, mghigh, ybhigh, highlev, satlev]
def convert_to_levels(self, crsh, mgsh, ybsh, shlev, crmid, mgmid, ybmid, midlev, crhigh, mghigh, ybhigh, highlev, satlev):
lowinred=0
hiinred=255
lowingreen=0
hiingreen=255
lowinblue=0
hiinblue=255
gammared=0.
gammagreen=0.
gammablue=0.
lowoutred=0
hioutred=255
lowoutgreen=0
hioutgreen=255
lowoutblue=0
hioutblue=255
lowred = 0
lowgreen = 0
lowblue = 0
lowin=0
hiin=255
lowout=0
hiout=255
gamma=1.
#MIDTONES
if (crmid > 0.):
gammared = gammared +0.4*crmid/100.
gammagreen = gammagreen -0.3*crmid/100.
gammablue = gammablue -0.3*crmid/100.
if (crmid < 0.):
gammared = gammared +0.3*crmid/100.
gammagreen = gammagreen -0.4*crmid/100.
gammablue = gammablue -0.4*crmid/100.
if (mgmid > 0.):
gammared = gammared -0.3*mgmid/100.
gammagreen = gammagreen +0.4*mgmid/100.
gammablue = gammablue -0.3*mgmid/100.
if (mgmid < 0.):
gammared = gammared -0.4*mgmid/100.
gammagreen = gammagreen +0.3*mgmid/100.
gammablue = gammablue -0.4*mgmid/100.
if (ybmid > 0.):
gammared = gammared -0.3*ybmid/100.
gammagreen = gammagreen -0.3*ybmid/100.
gammablue = gammablue +0.4*ybmid/100.
if (ybmid < 0.):
gammared = gammared -0.4*ybmid/100.
gammagreen = gammagreen -0.4*ybmid/100.
gammablue = gammablue +0.3*ybmid/100.
gammared = gammared +1.
gammagreen = gammagreen +1.
gammablue = gammablue +1.
if (midlev > 0.):
gammared = gammared +0.4*midlev/100.
gammagreen = gammagreen +0.4*midlev/100.
gammablue = gammablue +0.4*midlev/100.
if (midlev < 0.):
gammared = gammared +0.3*midlev/100.
gammagreen = gammagreen +0.3*midlev/100.
gammablue = gammablue +0.3*midlev/100.
#SHADOWS
crsh = crsh * 0.3
mgsh = mgsh * 0.3
ybsh = ybsh * 0.3
if (crsh>0):
lowingreen = lowingreen + crsh
lowinblue = lowinblue + crsh
lowoutred = lowoutred + crsh
else:
lowinred = lowinred - crsh
lowoutgreen = lowoutgreen - crsh
lowoutblue = lowoutblue - crsh
if (mgsh>0):
lowinred = lowinred + mgsh
lowinblue = lowinblue + mgsh
lowoutgreen = lowoutgreen + mgsh
else:
lowingreen = lowingreen - mgsh
lowoutred = lowoutred - mgsh
lowoutblue = lowoutblue - mgsh
if (ybsh>0):
lowinred = lowinred + ybsh
lowingreen = lowingreen + ybsh
lowoutblue = lowoutblue + ybsh
else:
lowinblue = lowinblue - ybsh
lowoutred = lowoutred - ybsh
lowoutgreen = lowoutgreen - ybsh
if (shlev>0):
lowoutred = lowoutred + shlev
lowoutgreen = lowoutgreen + shlev
lowoutblue = lowoutblue + shlev
if (shlev<0):
lowinred = lowinred - shlev
lowingreen = lowingreen - shlev
lowinblue = lowinblue - shlev
#HIGHLIGHTS
crhigh = crhigh * 0.3
mghigh = mghigh * 0.3
ybhigh = ybhigh * 0.3
if (crhigh>0):
hiinred = hiinred - crhigh
hioutgreen = hioutgreen - crhigh
hioutblue = hioutgreen - crhigh
else:
hiingreen = hiingreen + crhigh
hiinblue = hiinblue + crhigh
hioutred = hioutred + crhigh
if (mghigh>0):
hiingreen = hiingreen - mghigh
hioutred = hioutred - mghigh
hioutblue = hioutblue - mghigh
else:
hiinred = hiinred + mghigh
hiinblue = hiinblue + mghigh
hioutgreen = hioutgreen + mghigh
if (ybhigh>0):
hiinblue = hiinblue - ybhigh
hioutred = hioutred - ybhigh
hioutgreen = hioutgreen - ybhigh
else:
hiinred = hiinred + ybhigh
hiingreen = hiingreen + ybhigh
hioutblue = hioutblue + ybhigh
if (highlev>0):
hiinred = hiinred - highlev
hiingreen = hiingreen - highlev
hiinblue = hiinblue - highlev
if (highlev<0):
hioutred = hioutred + highlev
hioutgreen = hioutgreen + highlev
hioutblue = hioutblue + highlev
return [[lowinred, hiinred, gammared, lowoutred, hioutred], [lowingreen, hiingreen, gammagreen, lowoutgreen, hioutgreen], [lowinblue, hiinblue, gammablue, lowoutblue, hioutblue], [satlev]]
def makeLayer(self, img, drawable, shh, shs, shlev, midh, mids, midlev, highh, highs, highlev, satlev):
pdb.gimp_image_undo_group_start(img)
tmpLayer1 = pdb.gimp_layer_copy(drawable, True)
pdb.gimp_image_add_layer(img, tmpLayer1, -1)
tmpLayer1.name = drawable.name + " Color Grading"
channelred=1
channelgreen=2
channelblue=3
rgbshift = self.convert_to_rgbshifts(shh, shs, shlev, midh, mids, midlev, highh, highs, highlev, satlev)
levels = self.convert_to_levels(rgbshift[0], rgbshift[1], rgbshift[2], rgbshift[3], rgbshift[4], rgbshift[5], rgbshift[6], rgbshift[7], rgbshift[8], rgbshift[9], rgbshift[10], rgbshift[11], rgbshift[12])
pdb.gimp_levels(tmpLayer1, channelred, levels[0][0], levels[0][1], levels[0][2], levels[0][3], levels[0][4])
pdb.gimp_levels(tmpLayer1, channelgreen, levels[1][0], levels[1][1], levels[1][2], levels[1][3], levels[1][4])
pdb.gimp_levels(tmpLayer1, channelblue, levels[2][0], levels[2][1], levels[2][2], levels[2][3], levels[2][4])
pdb.gimp_hue_saturation(tmpLayer1, 0, 0., 0., levels[3][0])
gimp.displays_flush()
pdb.gimp_image_undo_group_end(img)
return tmpLayer1
class ColorWheel(gtk.DrawingArea):
def __init__(self, pixbuf1, centerx, centery, radius):
gtk.DrawingArea.__init__(self)
self.connect('expose-event', self.do_expose )
self.connect("motion_notify_event", self.mouse_mv)
self.set_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.LEAVE_NOTIFY_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
self.set_size_request(2*radius, 2*radius)
self.pixbuf = pixbuf1
self.centerx = centerx
self.centery = centery
self.radius = radius
self.x = centerx
self.y = centery
self.hsv = [0., 0., 1.]
def mouse_mv(self, widget, event):
if event.is_hint:
x, y, state = event.window.get_pointer()
else:
x = event.x
y = event.y
state = event.state
if state & gtk.gdk.BUTTON1_MASK:
centerx = self.centerx
centery = self.centery
radius = self.radius
x2 = (float(x) - float(centerx)) * (float(x) - float(centerx))
y2 = (float(centery) - float(y)) * (float(centery) - float(y))
r2 = float(radius) * float(radius)
if (x2 + y2 < r2):
self.x = x
self.y = y
self.refresh_view()
#print self.get_wheel_hsv()
def refresh_view(self):
centerx = self.centerx
centery = self.centery
radius = self.radius
x = self.x
y = self.y
x2 = (float(x) - float(centerx)) * (float(x) - float(centerx))
y2 = (float(centery) - float(y)) * (float(centery) - float(y))
r2 = float(radius) * float(radius)
if (x2 + y2 < r2):
dist = math.sqrt( ( x2 + y2 ) / r2 )
theta = math.atan2(float(centery) - float(y), float(x) - float(centerx))
if theta > 0:
h = theta
h = h / (2*math.pi)
else:
h = 2*math.pi + theta
h = h / (2*math.pi)
s = dist
v = 1.0
#hsvtool = HSVbasics()
self.hsv = [h, s, v]
#self.rgb = hsvtool.gimp_hsv_to_rgb4(self.hsv)
#print self.hsvdeg
#print self.rgb
#print [x, y]
self.cr = self.window.cairo_create()
self.cr.set_operator(cairo.OPERATOR_SOURCE)
#self.cr.set_source_rgb(0,0,0)
#self.cr.paint()
self.cr.set_source_pixbuf(self.pixbuf, 0, 0)
self.cr.paint()
self.cr.set_line_width(2)
self.cr.stroke_preserve()
self.cr.set_source_rgb(0.5, 0.5, 0.5)
self.cr.arc(x, y, 4., 0.0, 2*math.pi)
self.cr.stroke_preserve()
#self.cr.fill()
def get_wheel_hsv(self):
h = self.hsv[0]*360
s = self.hsv[1]
v = 1.0
return [h, s, v]
def set_wheel_hsv(self, wheel_hsv):
self.x = self.centerx + wheel_hsv[1] * self.radius * math.cos(wheel_hsv[0]*2*math.pi/360.0)
self.y = self.centery - wheel_hsv[1] * self.radius * math.sin(wheel_hsv[0]*2*math.pi/360.0)
#self.refresh_view()
def reset(self):
self.x = self.centerx
self.y = self.centery
self.hsv = [0., 0., 1.]
self.cr = self.window.cairo_create()
self.cr.set_operator(cairo.OPERATOR_SOURCE)
#self.cr.set_source_rgb(0,0,0)
#self.cr.paint()
self.cr.set_source_pixbuf(self.pixbuf, 0, 0)
self.cr.paint()
self.cr.set_line_width(2)
self.cr.stroke_preserve()
self.cr.set_source_rgb(0.5, 0.5, 0.5)
self.cr.arc(self.centerx, self.centery, 4., 0.0, 2*math.pi)
self.cr.stroke_preserve()
#self.cr.fill()
def do_expose(self, widget, event):
self.refresh_view()
class HSVbasics:
#LIBGIMP - The GIMP Library
# * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
# *
# * This library is free software; you can redistribute it and/or
# * modify it under the terms of the GNU Lesser General Public
# * License as published by the Free Software Foundation; either
# * version 2 of the License, or (at your option) any later version.
# *
# * This library is distributed in the hope that it will be useful,
# * but WITHOUT ANY WARRANTY; without even the implied warranty of
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# * Library General Public License for more details.
# *
# * You should have received a copy of the GNU Lesser General Public
# * License along with this library; if not, write to the
# * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# * Boston, MA 02111-1307, USA.
# * gimp_rgb_to_hsv4:
# * @rgb: RGB triplet, rgb[0] is red channel, rgb[1] is green,
# * rgb[2] is blue (0..255)
# * @hue: Pointer to hue channel (0..1)
# * @saturation: Pointer to saturation channel (0..1)
# * @value: Pointer to value channel (0..1)
def gimp_rgb_to_hsv4(self, rgb):
#double red, green, blue;
#double h, s, v;
#double min, max;
#double delta;
#double hue;
#double saturation;
#double value;
#double[] hsv;
red = rgb[0] / 255.0;
green = rgb[1] / 255.0;
blue = rgb[2] / 255.0;
h = 0.0; #/* Shut up -Wall */
if (red > green):
maxc = max([red, blue])
minc = min([green, blue])
else:
maxc = max([green, blue])
minc = min([red, blue])
v = maxc
if (maxc != 0.0):
s = (maxc - minc) / maxc
else:
s = 0.0
if (s == 0.0):
h = 0.0
else:
delta = maxc - minc
if (delta == 0.0):
delta = 1.0
if (red == maxc):
h = (green - blue) / delta
elif (green == maxc):
h = 2 + (blue - red) / delta
elif (blue == maxc):
h = 4 + (red - green) / delta
h /= 6.0
if (h < 0.0):
h += 1.0
elif (h > 1.0):
h -= 1.0
hue = h
saturation = s
value = v
hsv = [hue, saturation, value]
return hsv
# * gimp_hsv_to_rgb4:
# * @rgb: RGB triplet, rgb[0] is red channel, rgb[1] is green,
# * rgb[2] is blue (0..255)
# * @hue: Hue channel (0..1)
# * @saturation: Saturation channel (0..1)
# * @value: Value channel (0..1)
def gimp_hsv_to_rgb4(self, hsv):
#double h, s, v;
#double f, p, q, t;
hue = hsv[0]
saturation = hsv[1]
value = hsv[2]
#double[] rgb;
if (saturation == 0.0):
hue = value
saturation = value
#value = value
else:
h = hue * 6.0
s = saturation
v = value
if (h == 6.0):
h = 0.0;
f = h - int(h)
p = v * (1.0 - s)
q = v * (1.0 - s * f)
t = v * (1.0 - s * (1.0 - f))
if (int(h)==0):
hue = v
saturation = t
value = p
elif (int(h)==1):
hue = q
saturation = v
value = p
elif (int(h)==2):
hue = p
saturation = v
value = t
elif (int(h)==3):
hue = p
saturation = q
value = v
elif (int(h)==4):
hue = t
saturation = p
value = v
elif (int(h)==5):
hue = v
saturation = p
value = q
#rgb = new Double[3];
rgb = [round(hue * 255.0), round(saturation * 255.0), round(value * 255.0)]
return rgb;
class pycolorgradingcw(gimpplugin.plugin):
def start(self):
gimp.main(self.init, self.quit, self.query, self._run)
def init(self):
pass
def quit(self):
pass
def query(self):
authorname = "John Lakkas"
copyrightname = "John Lakkas"
menu_location = "<Image>/Filters/Color Grading Color Wheel etition"
date = "May 2012"
plug_description = "Color Grading plug-in alters image/layer shadows, midtones and highlights color tones"
plug_help = "Color Grading plug-in alters image/layer shadows, midtones and highlights color tones."
plug_params = [
(PDB_INT32, "run_mode", "Run mode"),
(PDB_IMAGE, "image", "Input image"),
(PDB_DRAWABLE, "drawable", "Input drawable"),
####### 3 params above needed by all scripts using gimpplugin.plugin ######################
(PDB_FLOAT, "shh", "Shadows Hue"),
(PDB_FLOAT, "shs", "Shadows Saturation"),
(PDB_FLOAT, "shlev", "Shadows levels"),
(PDB_FLOAT, "midh", "Midtones Hue"),
(PDB_FLOAT, "mids", "Midtones Saturation"),
(PDB_FLOAT, "midlev", "Midtones levels"),
(PDB_FLOAT, "highh", "Highlights Hue"),
(PDB_FLOAT, "highs", "Highlights Saturation"),
(PDB_FLOAT, "highlev", "Highlights levels"),
(PDB_FLOAT, "satlev", "Saturation")
]
gimp.install_procedure("py_color_grading_cw",
plug_description,
plug_help,
authorname,
copyrightname,
date,
menu_location,
"RGB*, GRAY*",
PLUGIN,
plug_params,
[])
def py_color_grading_cw(self, runmode, img, drawable, shh=0.0, shs=0.0, shlev=0, midh=0.0, mids=0.0, midlev=0, highh=0.0, highs=0.0, highlev=0, satlev=0):
color_grading_cw(runmode, img, drawable, shh, shs, shlev, midh, mids, midlev, highh, highs, highlev, satlev)
if __name__ == '__main__':
pycolorgradingcw().start()
Try adapting this plugins save features for your own. It might help out.
_________________
"In the face of adversity, there's three things: fly, freeze or fight; We're choosing to fight..."- Guy Boucher, Tampa Bay Lighting Head Coach
|
|
Login
Register
Tweets
FAQ
Advanced Search
