How Do I Applyi RGB Values ToTweak Colors

I have a selection or a layer of which I want to tweak the color. I use my color sampler to read the RGB values from my "source". How can I apply those values to my selection/layer ? If I use a color fill, I lose all detail in my original.
As always, thanks.
Ira

Here's an example.
I photograph a piece of painted wood straight on.
I then photograph it at a 45% angle.
I want the color of the wood to match, but not lose any texture or detail.
I can use my color sampler to read the RGB values of the straight on shot.
How can I use those values to tweak the RGB numbers in the angled shot?
If I add a color overlay of those numbers, its a solid fill and I lose the detail below.
Lowering the opacity of the overlay lets too much "under color" show through.
Is there a way to read the RGB values and adjust them "on the fly"?

Similar Messages

How do you set RGB values for colors in Numbers?

We are trying to set a specific RGB value for the background cell shading in Numbers.   Please help me on how to accomplish this?

And another way is with short scripts.
This one gets the RGB values of the background color of a selected cell:
--get background color of cell -- like a "dropper"
--if none set, returns 'missing value'
tell application "Numbers" to tell front document to tell active sheet to tell (first table whose class of selection range is range)
          tell the first cell of the selection range
                    set bkgrRGB to its background color
          end tell
end tell
And this one sets the background color of selected cells to the RGB values defined in myBackGroundColor:
--sets background color of a cell
property myBackgroundColor : {8607, 65513, 1548}
tell application "Numbers" to tell the front document to tell active sheet to tell (first table whose class of selection range is range)
          repeat with aCell in the selection range
                    tell aCell
                              set its background color to myBackgroundColor
                    end tell
          end repeat
end tell
SG

How to find the RGB Values of a Color for Hyperion

When customizing your Hyperion forms, we come across situations where we need the exact RGB value of a given color. This article explains a simple technique to find the RGB values using MS Paint and the Calculator applications that come as standard applications with your operating system.
Here are the steps to find the exact RGB value of a given color.
1) View your Hyperion form using IE, scroll down until you see the color you want to find the RGB value and press the "Print Screen" button (in your keyboard).
2) Open MS Paint and click Edit -> Paste or simply Ctrl+V. What you saw in the browser will be copied as a new untitled image.
3) Select the Color Picker tool and click on an area that has the color you want to match.
4) Now go to Edit Colors... option and click on the "Define Custom Colors >>" button. The color you picked will be selected on this palette. At the bottom right hand corner you will see the Red, Green and Blue values you need. Note down the R,G,B values (given in decimal).
5) Now we need to find out the hexa-decimal values that correspond to those decimal values. This is where we use the simple Calculator. Open the Calculator application from Program -> Accessories. Switch to the scientific mode by clicking View ->Scientific.
6) By default it will be in the decimal number mode. Enter the R value (238 in this example) and click on the Hex radio button. The corresponding hexa-decimal value (EE in this case) will be shown in the dial.
The selected color in this case has the same value for R, G and B. (In fact, all shades of gray has the same values for R, G and B.) Therefore, the RGB value of the background color that we need is #eeeeee. Repeat step 6 to find out the hex value for the Green and Blue elements, if they are different.
Tip:
If you find it difficult to pick a color, zoom the image by pressing Ctrl+PageDown or using View -> Zoom -> Custom... option.

These tips are to find the RGB color of HFM default row where row is text and text lines in data columns are also visible to business users as Yellow as an input cell. By applying the same RGB color you can apply the same color to your data cells or rows. This post shows how to identify color from any web view-able object.
Regards,
Manaf

How to get the RGB value of each pixel of a hole image?

Hi,
I'm trying the get the RGB(between 0 and 255) value of each pixel of a hole image. I writte this code:
public void convertImage()
     int w = bufferedImage.getWidth();
     int h = bufferedImage.getHeight();
     int[] rgbs = new int[w*h];/* create a new array */
     bufferedImage.getRGB(0,0,w,h,rgbs,0,w);
     for(int i=0; i<10; i++)
         System.out.println(rgbs);
But the value rgbs[] contain an 8 bits integer, it's possible to have the RGB of this.
In other case, do you have another sample of code to help me to get the RGB value of each pixel of a hole image?
thanks.

Hi, I am currently working on an application which requires the generation of color histograms that are a representation of a given image ie; myImage.jpg. I have made use of the JAI API and used it's Histogram class to generate a histogram vector for the image that I provide.
However, upon closer inpsection, I have realised the following:-
(1) The image, as it contains multiple colours is a multi-banded image ie; this means that each individual pixel in the image contains multiple colour samples (I assume) ie; Red, Blue Green. Due to this, a "separate list of bins represents each individual band". This means that for myImage.jpg, there is not ONE individual vector that contains data such as "400 pixels purple" "5000 pixels yellow" etc but there are indeed 3 vectors that represent the image.
I have found this to be true using the getBinSize(int band, int bin) method call - the first parameter being 0,1,2 for Red Blue or Green.
My basic (or complex) problem is that I basically want to generate 2 color histogram vectors that represent 2 separate images and then compare these vectors "side-by-side" using the vector comparison algorithms that I have already developed.
Is there a way of using Java's Histogram class and it's associated methods to be able to store all colour information for an image in only ONE vector?? I am pretty certain that this is not possible, so my dilemma is now: - If I have an image and it is represented by three separate vectors/histograms, then how can I possibly compare these to say whether an image matches or not.
When a pixel is analysed by a program, what seems to be the result returned is how that pixel is made up in terms of Red, Green or blue ie; a purple pixel is X blue, X red and X green and hence 3 vectos existing.
Can anybody offer advice on how to achieve this task of looking at a pixel and simply determining it's actual color. I would preferably like to keep my code that I have already developed ie; the use of the Java Histoogram class but any other offerings are appreciated.

How to select matching RGB and CMYK colors

Starting from scratch for a client, how do I select matching RGB and CMYK pairs?
Say we find a nice red colour in RGB for screen use, how do I then find the correct CMYK for print? And what assumptions do I have to make when doing this, if any?
Would it be the same for the other way around (choose CMYK first for print and then find the RGB equivalent)
Is it more sensible to start with a Pantone colour and then find the RGB and CMYK equivalents for that?
Many thanks
RobbieG
(I'm working with Ai, Ps and Id CS6)

Yes. Better to start with Pantone reference books where you are viewing the color in a reflective environment. As already mentioned, color on the monitor can be deceptive. And, I think the others are basiclt saying that you should have everything calibrated and use color management policies in your apps. There is a way to find CMYK equivalents using Photoshop's color palette. Let's say you have an RGB Red as the foreground color in Photoshop. If you double click on the swatch you will get Photoshop's color palette which lists the RGB percentages, CMYK percentages, LAB percentages, and HEX web color for that Red. You can go further and select "Custom" and the Pasntone Spot color palette opens and gives you the closest Spot color value for that Red. This however, depends on your color settings. That's why I recommend you start with the Pantone swatch book and get the perecentages of CMYK from their formula guide which is set to industry standard color.

RGB values of current terminal color settings?

The colors displayed for different ANSI escape codes are configurable via .Xdefaults or directly on the command line via other ANSI escapes.
Is there any way to dump the current values from a terminal? For example, given the ANSI escape code "\033[31m", I would like to know the current RGB values used to display it.
Obviously this will depend on the terminal (e.g. urxvt can have different settings from xterm), but I'm hoping that there is some obscure tool to do this.

Coincidentally, I recently wrote a script to do exactly this: query all the color values from a terminal emulator and show them in a nice table. I was planning to make a thread for this, but this thread is perfect. In my opinion, the strategy of querying colors from the terminal itself is superior (when it is supported by the terminal) to mucking around with .Xresources, .Xdefaults, or "xrdb --query", which only work in pretty limited situations. The drawbacks of my approach are: (1) it can be challenging to make the same code work on different terminal emulators, and (2) you have to use it from the terminal you want to query, and not from within a screen or tmux session. (I think there may be partial workarounds for (2), but I haven't implemented them.) I've tested my code on a number of terminals, and the upshot is that xterm and urxvt are supported flawlessly, and VTE-based terminals like gnome-terminal and XFCE's "Terminal" are almost fully supported. (I wasn't able to query the default foreground and background colors, but everything else seems to work.) Most other X terminals don't seem to support this method of querying color values.
Here's an example of what the script produces:
Obviously, that's a heavily formatted table, but I think the code has enough comments that you can take what you need from it. It works under python 3 or python 2.7.
Edit: This version is superseded by the one in post #27, which is structured better. I'm leaving this here since some of the future replies refer to it.
#!/usr/bin/python
This is a Python script to show off your terminal ANSI colors (or more
colors, if your terminal has them). It works on both Python 2.7 and
Python 3.
This script must be run from the terminal whose colors you want to
showcase. Not all terminal types are supported (see below). At the
very minimum, 16-color support is required.
Fully supported terminals:
xterm
urxvt
For these terminals, this script can show a color table with correct RGB
values for each color. It queries the RGB values from the terminal
itself, so it works even if you change the colors after starting the
terminal.
Mostly supported terminals: pretty much all VTE-based terminals. This
includes:
vte
Terminal (XFCE)
gnome-terminal
terminator
tilda
and many more. These are on "mostly" status because I don't know how to
query their foreground and background colors. Everything else works,
though, albeit with noticeable slowness (which may be beyond this
script's control).
Somewhat supported terminals: pretty much all other X-client terminals
I've tried. These include:
konsole (KDE)
terminology (Enlightenment)
Eterm (Enlightenment)
(etc.)
For these terminals, the script can output a color table just fine, but
without RGB values.
Unsupported terminals:
ajaxterm
Linux virtual console (i.e., basic TTY without X-windows)
Warning: do not run this script on the Linux virtual console unless you
want a garbled TTY! That said, you can still type `tput reset<Enter>'
afterward to get back to a usable console. :-) The situation with
ajaxterm is similar, but not as bad.
If a terminal isn't mentioned here, I probably haven't tried it. Attempt
at your own risk!
Note regarding screen/tmux: this script can theoretically be run from a
screen or tmux session, but you will not get any RGB values in the
output (indeed, a screen session can be opened on multiple terminals
simultaneously, so there typically isn't a well defined color value for
a given index). However, it's interesting to observe that screen and
tmux emulate a 256 color terminal independently of the terminal(s)
to which they are attached, which is very apparent if you run the script
with 256-color output on a screen session attached to a terminal with 8-
or 16-color terminfo (or with $TERM set to such).
This code is licensed under the terms of the GNU General Public License:
http://www.gnu.org/licenses/gpl-3.0.html
and with absolutely no warranty. All use is strictly at your own risk.
from sys import stdin, stdout, stderr
import re
import select
import termios
from collections import defaultdict
from argparse import (ArgumentParser, ArgumentError)
# Operating system command
osc = "\033]"
# String terminator
# ("\033\\" is another option, but "\007" seems to be understood by
# more terminals. Terminology, for example, doesn't seem to like
# "\033\\".)
st = "\007"
# Control sequence introducer
csi = "\033["
# ANSI SGR0
reset = csi + 'm'
# Errors that may be raised by rgb_query
num_errors = 0
class InvalidResponseError(Exception):
The terminal's response couldn't be parsed.
def __init__(self, q, r):
global num_errors
num_errors += 1
Exception.__init__(self, "Couldn't parse response " + repr(r) +
" to query " + repr(q))
class NoResponseError(Exception):
The terminal didn't respond, or we were too impatient.
def __init__(self, q):
global num_errors
num_errors += 1
Exception.__init__(self, "Timeout on query " + repr(q))
# Wrappers for xterm & urxvt operating system controls.
# These codes are all common to xterm and urxvt. Their responses aren't
# always in the same format (xterm generally being more consistent), but
# the regular expression used to parse the responses is general enough
# to work for both.
# Note: none of these functions is remotely thread-safe.
def get_fg(timeout):
Get the terminal's foreground (text) color as a 6-digit
hexadecimal string.
return rgb_query([10], timeout)
def get_bg(timeout):
Get the terminal's background color as a 6-digit hexadecimal
string.
return rgb_query([11], timeout)
def get_color(a, timeout):
Get color a as a 6-digit hexadecimal string.
return rgb_query([4, a], timeout)
def test_fg(timeout):
Return True if the terminal responds to the "get foreground" query
within the time limit and False otherwise.
return test_rgb_query([10], timeout)
def test_bg(timeout):
Return True if the terminal responds to the "get background" query
within the time limit and False otherwise.
return test_rgb_query([11], timeout)
def test_color(timeout):
Return True if the terminal responds to the "get color 0" query
within the time limit and False otherwise.
return test_rgb_query([4, 0], timeout)
def test_rgb_query(q, timeout):
Determine if the terminal supports query q.
Arguments: `q' and `timeout' have the same interpretation as in
rgb_query().
Return: True if the terminal gives a valid response within the
time limit and False otherwise.
This function will not raise InvalidResponseError or
NoResponseError, but any other errors raised by rgb_query will
be propagated.
try:
rgb_query(q, timeout)
return True
except (InvalidResponseError, NoResponseError):
return False
# String to use for color values that couldn't be determined
rgb_placeholder = '??????'
# This is what we expect the terminal's response to a query for a color
# to look like. If we didn't care about urxvt, we could get away with a
# simpler implementation here, since xterm and vte seem to give pretty
# consistent and systematic responses. But I actually use urxvt most of
# the time, so....
ndec = "[0-9]+"
nhex = "[0-9a-fA-F]+"
crgb = ("\033\\]({ndec};)+rgba?:" +
"({nhex})/({nhex})/({nhex})(/({nhex}))?").format(**vars())
re_response = re.compile(crgb)
# The problem I'm attempting to work around with this complicated
# implementation is that if you supply a terminal with a query that it
# does not recognize or does not have a good response to, it will simply
# not respond *at all* rather than signaling the error in any way.
# Moreover, there is a large variation in how long terminals take to
# respond to valid queries, so it's difficult to know whether the
# terminal has decided not to respond at all or it needs more time.
# This is why rgb_query has a user-settable timeout.
P = select.poll()
P.register(stdin.fileno(), select.POLLIN)
def flush_input():
Discard any input that can be read at this moment.
repeat = True
while repeat:
evs = P.poll(0)
if len(evs) > 0:
stdin.read()
repeat = True
else:
repeat = False
def rgb_query(q, timeout=-1):
Query a color-valued terminal parameter.
Arguments:
q: The query code as a sequence of nonnegative integers, i.e.,
[q0, q1, ...] if the escape sequence in pseudo-Python is
"\033]{q0};{q1};...;?\007"
timeout: how long to wait for a response. (negative means
wait indefinitely if necessary)
Return: the color value as a 6-digit hexadecimal string.
Errors:
NoResponseError will be raised if the query times out.
InvalidResponseError will be raised if the terminal's
response can't be parsed.
See
http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
("Operating System Controls") to see the various queries
supported by xterm. Urxvt supports some, but not all, of them,
and has a number of its own (see man -s7 urxvt).
Warning: before calling this function, make sure the terminal is
in noncanonical, non-blocking mode.
query = osc + ';'.join([str(k) for k in q]) + ';?' + st
flush_input()
stdout.write(query)
stdout.flush()
# This is addmittedly flawed, since it assumes the entire response
# will appear in one shot. It seems to work in practice, though.
evs = P.poll(timeout)
if len(evs) == 0:
raise NoResponseError(query)
r = stdin.read()
m = re_response.search(r)
if not m:
raise InvalidResponseError(query, r)
# (possibly overkill, since I've never seen anything but 4-digit RGB
# components in responses from terminals, in which case `nd' is 4
# and `u' is 0xffff, and the following can be simplified as well
# (and parse_component can be eliminated))
nd = len(m.group(2))
u = int('f'*nd, 16)
# An "rgba"-type reply (for urxvt) is apparently actually
# rgba:{alpha}/{alpha * red}/{alpha * green}/{alpha * blue}
# I opt to extract the actual RGB values by eliminating alpha. (In
# other words, the alpha value is discarded completely in the
# reported color value, which is a compromise I make in order to get
# an intuitive and compact output.)
if m.group(5):
# There is an alpha component
alpha = float(int(m.group(2), 16))/u
idx = [3, 4, 6]
else:
# There is no alpha component
alpha = 1.0
idx = [2, 3, 4]
c_fmt = '%0' + ('%d' % nd) + 'x'
components = [int(m.group(i), 16) for i in idx]
t = tuple(parse_component(c_fmt % (c/alpha)) for c in components)
return "%02X%02X%02X" % t
def parse_component(s):
Take a string representation of a hexadecimal integer and transorm
the two most significant digits into an actual integer (or double
the string if it has only one character).
n = len(s)
if n == 1:
s += s
elif n > 2:
s = s[:2]
return int(s, 16)
def test_num_colors(timeout):
Attempt to determine the number of colors we are able to query from
the terminal. timeout is measured in milliseconds and has the same
interpretation as in rgb_query. A larger timeout is safer but will
cause this function to take proportionally more time.
if not test_color(timeout):
return 0
a = 0
b = 1
while test_rgb_query([4, b], timeout):
a = b
b += b
while b - a > 1:
c = (a + b)>>1
if test_rgb_query([4, c], timeout):
a = c
else:
b = c
return b
class ColorDisplay(object):
Class for producing a colored display of terminal RGB values.
def __init__(self, timeout=100, color_level=3, do_query=True):
timeout: same interpretation as in rgb_query. A larger timeout
will be used a small number of times to test the
capabilities of the terminal.
color_level: how much color should be in the output. Use 0 to
suppress all color and 3 or greater for maximum coloredness.
do_query: whether to attempt to query RGB values from the
terminal or just use placeholders everywhere
self.timeout=timeout
self.color_level=color_level
# try getting the rgb value for color 0 to decide whether to
# bother trying to query any more colors.
self.do_query = do_query and test_color(self.timeout*5)
def none_factory():
return None
# colors for highlighting
self.hi = defaultdict(none_factory)
self.hi['['] = 10
self.hi[']'] = 10
self.hi['+'] = 9
self.hi['/'] = 9
for c in '0123456789ABCDEF':
self.hi[c] = 12
def show_ansi(self):
Show the 16 ANSI colors (colors 0-15).
color_order = [0, 1, 3, 2, 6, 4, 5, 7]
names = [' Black ', ' Red ', ' Green ', ' Yellow ',
' Blue ', ' Magenta', ' Cyan ', ' White ']
stdout.write(self.fgcolor('15', 3))
for k in range(8):
a = color_order[k]
stdout.write(names[a])
stdout.write('\n')
stdout.write(self.fgcolor(None, 3))
c = None
for k in range(8):
a = color_order[k]
c = self.hiprint(' [%X/%X] ' % (a, 8 + a), c)
stdout.write('\n')
self.show_color_table([0,8], color_order)
def show_color_cube(self, n):
Show the "RGB cube" (xterm colors 16-231 (256-color) or 16-79
(88-color)). The cube has sides of length 6 or 4 (for 256-color
or 88-color, respectively).
base = {256:6, 88:4}[n]
c = None
c = self.hiprint('[ + ] ', c)
for w in range(base):
c = self.hiprint('[%X] ' % w, c)
stdout.write('\n\n' + self.fgcolor(None, 3))
for u in range(base):
for v in range(base):
stdout.write(' '*v)
x = (u*base + v)*base
self.hiprint(' [%02X] ' % (16 + x))
for w in range(base):
self.show_color(x + w + 16)
stdout.write('\n')
stdout.write('\n\n')
def show_grayscale_ramp(self, end):
Show the "grayscale ramp" (xterm colors 232-255 (256-color) or
80-87 (88-color)).
start = {256:232, 88:80}[end]
n = end - start
vals = [self.get_color(a) for a in range(start, end)]
#stdout.write(reset)
c = None
c = self.hiprint('[ ', c)
for v in range(n):
c = self.hiprint('%02X ' % (start + v), c)
c = self.hiprint(']\n', c)
stdout.write('\n ' + self.fgcolor(None, 3))
for v in range(n):
stdout.write(' ' + self.block(start + v, 2))
stdout.write('\n ')
for u in range(3):
for v in range(n):
stdout.write(' ')
stdout.write(self.fgcolor(start + v, 2))
stdout.write(vals[v][2*u : 2*(u + 1)])
stdout.write(self.fgcolor(None, 2))
stdout.write('\n ')
stdout.write('\n')
def show_colors(self, n):
Make a table showing colors 0 through n-1.
self.show_color_table(range(0,n,8), range(8), n, True)
def show_color_table(self, rows, cols, stop=-1, label=False):
Make a color table with all possible color indices of the form
rows[k] + cols[j] that are less than `stop' (if `stop' is not
negative). If label is True, then print row and column labels.
if label:
self.hiprint('[ + ]')
stdout.write(self.fgcolor(None, 3))
for a in cols:
stdout.write(' ' + self.octal(a) + ' ')
stdout.write('\n')
if label:
stdout.write(' ')
stdout.write('\n')
for b in rows:
if label:
stdout.write(self.octal(b) + ' ')
for a in cols:
c = a + b
if stop < 0 or c < stop:
self.show_color(b + a)
else:
stdout.write(' ')
stdout.write('\n')
stdout.write('\n')
def show_color(self, a):
Make a pretty display of color number `a', showing a block of
that color followed by the 6-character hexadecimal code for the
color.
stdout.write(' ' + self.block(a) + ' ')
stdout.write(self.fgcolor(a, 2) + (self.get_color(a)))
stdout.write(self.fgcolor(None, 2))
def hiprint(self, s, last_color=-1):
Print s to stdout, highlighting digits, brackets, etc. if the
color level allows it.
Arguments:
s: the string to print.
last_color: the current terminal foreground color. This
should be `None' if no color is set, or the current
color index, or something else (like a negative integer)
if the color isn't known. (The last option is always
safe and will force this function to do the right
thing.)
Return: the current foreground color, which can be passed as
last_color to the next call if the color isn't changed in
between.
for c in s:
if c == ' ':
color = last_color
else:
color = self.hi[c]
if color != last_color:
stdout.write(self.fgcolor(color, 3))
stdout.write(c)
last_color = color
return last_color
def octal(self, x):
Return a base-8 string for the integer x, highlighted if the
color level allows it.
return self.fgcolor(self.hi['+'], 3) + '0' + \
self.fgcolor(self.hi['0'], 3) + ('%03o' % x)
def block(self, c, n=1):
Return a string that prints as a block of color `c' and size `n'.
return self.bgcolor(c, 1) + ' '*n + self.bgcolor(None, 1)
# Changing the foreground and background colors.
# While the 38;5 and 48;5 SGR codes are less portable than the usual
# 30-37 and 40-47, these codes seem to be fairly widely implemented (on
# X-windows terminals, screen, and tmux) and support the whole color
# range, as opposed to just colors 0-8. They also make it very easy to
# set the background to a given color without needing to mess around
# with bold or reverse video (which are hardly portable themselves).
# This is useful even for the 16 ANSI colors.
def fgcolor(self, a=None, level=-1):
Return a string designed to set the foreground color to `a' when
printed to the terminal. None means default.
if self.color_level >= level:
if a is None:
return csi + '39m'
else:
return csi + '38;5;' + str(a) + 'm'
else:
return ''
def bgcolor(self, a=None, level=-1):
Return a string designed to set the background color to `a' when
printed to the terminal. None means default.
if self.color_level >= level:
if a is None:
return csi + '49m'
else:
return csi + '48;5;' + str(a) + 'm'
else:
return ''
def get_color(self, a):
if self.do_query:
try:
return get_color(a, timeout=self.timeout)
except (InvalidResponseError, NoResponseError):
return rgb_placeholder
else:
return rgb_placeholder
# Command-line arguments
timeout_dft = 200
parser = ArgumentParser(
description="Python script to show off terminal colors.",
epilog="Run this script from the terminal whose colors " +
"you want to showcase. " +
"For a brief synopsis of which terminal types are " +
"supported, see the top of the source code.")
mode_group = parser.add_mutually_exclusive_group()
p_choices = [16, 88, 256]
arg_p = mode_group.add_argument(
'-p', '--pretty',
action='store_true', default=False,
help="show colors 0 through N-1 in a pretty format. " +
("N must belong to %r. " % p_choices) +
"If N > 16, it should be the actual number of colors " +
"supported by the terminal, or the output will almost " +
"certainly not be pretty.")
mode_group.add_argument(
'-f', '--flat',
action='store_true', default=False,
help="show a simple table with colors 0 through N-1. ")
parser.add_argument(
'n', nargs='?', metavar='N',
type=int, default=16,
help="number of colors to show. " +
"Unless you explicitly supply -p/--pretty or -f/--flat, " +
"--pretty is used if possible and --flat is used " +
"otherwise. " +
"N defaults to 16, showing the ANSI colors 0-15. " +
"If N is 0, the script will attempt to determine the " +
"maximum number of colors automatically " +
"(which may be slow).")
parser.add_argument(
'--no-fgbg',
action='store_false', dest='fgbg', default=True,
help="suppress display of foreground/background colors.")
parser.add_argument(
'--no-query',
action='store_false', dest='do_query', default=True,
help="don't try to query any RGB values from the terminal " +
"and just use placeholders.")
parser.add_argument(
'-t', '--timeout', metavar='T',
type=int, default=timeout_dft,
help="how long to wait for the terminal to "
"respond to a query, in milliseconds " +
"[default: {0}]. ".format(timeout_dft) +
"If your output has '?' characters " +
"instead of RGB values " +
"or junk printed after the script runs, " +
"increasing this value may or may not " +
"help, depending on the terminal. " +
"A negative T will behave like infinity.")
parser.add_argument(
'-l', '--level', metavar='L',
type=int, default=3,
help="choose how much color to use in the output. " +
"(0 = no color; 3 = most color [default])")
if __name__ == '__main__':
args = parser.parse_args()
assert not (args.pretty and args.flat)
if args.pretty:
if args.n not in p_choices:
raise ArgumentError(
arg_p,
"N must belong to %r" % p_choices)
tc_save = None
try:
tc_save = termios.tcgetattr(stdout.fileno())
tc = termios.tcgetattr(stdout.fileno())
# Don't echo the terminal's responses
tc[3] &= ~termios.ECHO
# Noncanonical mode (i.e., disable buffering on the terminal
# level)
tc[3] &= ~termios.ICANON
# Make input non-blocking
tc[6][termios.VMIN] = 0
tc[6][termios.VTIME] = 0
termios.tcsetattr(stdout.fileno(), termios.TCSANOW, tc)
if args.n == 0:
args.n = test_num_colors(args.timeout)
# We are guaranteed to have failed some queries now, but
# that isn't meaningful.
num_errors = 0
if not (args.pretty or args.flat):
if args.n in p_choices:
args.pretty = True
else:
args.flat = True
if args.level >= 1:
stdout.write(reset)
if args.fgbg:
if args.do_query:
try:
bg = get_bg(timeout=args.timeout)
except (InvalidResponseError, NoResponseError):
bg = rgb_placeholder
try:
fg = get_fg(timeout=args.timeout)
except (InvalidResponseError, NoResponseError):
fg = rgb_placeholder
else:
bg = rgb_placeholder
fg = rgb_placeholder
stdout.write("\n Background: %s\n" % bg)
stdout.write(" Foreground: %s\n\n" % fg)
C = ColorDisplay(args.timeout, args.level, args.do_query)
if args.pretty:
assert args.n in p_choices
stdout.write('\n ANSI colors:\n\n')
C.show_ansi()
if args.n > 16:
stdout.write('\n RGB cube:\n\n')
C.show_color_cube(args.n)
stdout.write(' Grayscale ramp:\n\n')
C.show_grayscale_ramp(args.n)
else:
C.show_colors(args.n)
if num_errors > 0:
stderr.write("Warning: not all queries succeeded\n" +
"Warning: (output contains " +
"placeholders and may be inaccurate)\n")
finally:
if args.level >= 1:
stdout.write(reset)
flush_input()
if tc_save != None:
termios.tcsetattr(stdout.fileno(),
termios.TCSANOW, tc_save)
Run it as
python showcolors.py -h
to get an overview of the functionality.
TL;DR: you can echo a string like "\033]4;13;?\007" to an xterm, and it will output the RGB value of color #13 to itself in the form "\033]4;13;rgb:rrrr/gggg/bbbb\007", which you can then read and parse. To try it out:
$ echo -en "\033]4;13;?\007"
There are some subtleties if you want this to work on other terminals like urxvt; for that you can experiment yourself or read the code.
Further reading: http://invisible-island.net/xterm/ctlseqs/ctlseqs.html (heading "Operating System Controls").
Xyne, regarding determining the number of colors: I don't know how to do that completely reliably. You can try simply
tput colors
but this relies on the value of $TERM and its terminfo and thus may be unreliable. A kludgy but workable way to do this using the "rgb_query" function in my script is to query color values using binary search to find the highest color value the terminal will allow you to query. The main problem with this is that if you query an invalid color index, then the terminal just won't respond at all, and if you query a valid index, it will respond but after a somewhat unpredictable delay, so it's hard to know for sure which one is the case. Like I said, it's kludgy but workable.
Edit: I went ahead and added that functionality to my script. Try running it as
python showcolors.py 0
or look at the function "test_num_colors".
Last edited by Lux Perpetua (2012-10-22 11:18:21)

How to read RGB values into Set

Hi,
I have been told that to count the total number of unique colors in an image is by reading each pixel RGB values into a set.
I have checked this and it is true that the set can do this fine if considering only either one channel of the R,G or B (this does not allow me to know the exact number of color exist). However, I am confuse on how to have all three R, G and B values into a set so that the set can consider the whole 3 values of RG and B as a color which can then be differentiated separately.
I think pixelgrabber allow to getPixel RGB values but I am working with JIU getsample method. Perhaps I missed out other methods in JIU which have the same functionality as in pixelGrabber.
I am working on an image analysis so I need to figure out this out first.
I am hoping anyone can help me out with this and I thank you.

as mentioned, pack the rgb values into an integer.
instead of a set, you will get better performance and
memory useage using a sorted, dynamically allocated
int array. With some minor work, you better this
structure by using more than one sorted array and a
cheap rgb mask hashing mechanism. I don't know what
JIU is, but look at the source of java.awt.Color for
details on how to pack/unpack rgb values.Hi,
Thank for your feedback. I have tried to pack the rgb values into an integer. At the moment I just making used of Set (will look into probably ArrayList after I get the rgb values correct). However, I am not sure whether my code is correct (which I doubt) or not. Not sure how the output looks like that. If you could have a look at it and confirm me, I would be very much thanking you.
the code snippet:
public void countColour() {
int r, g, b;
int[] rgb1DArray = new int[h * w];
int[] rgb = new int[4];
Set set = new HashSet();
int alpha = 255;
for (int i = 0, cnt = 0; i < w; i++) {
for (int j = 0; j < h; j++) {
r = intImg.getSample(0, i, j);
g = intImg.getSample(1, i, j);
b = intImg.getSample(2, i, j);
System.out.println(r+ "," g "," +b); // just checking rgb values
//rgb[0] = alpha;
rgb[1] = r;
rgb[2] = g;
rgb[3] = b;
System.out.println(rgb[0]+ "," rgb[1] "," rgb[2] "," +rgb[3]);
rgb1DArray[cnt] = ((rgb[1])<<16)|
((rgb[2]<<8))|(rgb[3]);
System.out.println("rgb["+cnt+"] :" +rgb1DArray[cnt]);
output:
Image file size is 230 x 236
204,221,203
0,204,221,203
rgb[0] :13426123
204,212,191
0,204,212,191
rgb[1] :13423807
180,166,140
0,180,166,140
rgb[2] :11839116
236,209,166
0,236,209,166
rgb[3] :15520166

System colors do not give correct RGB values

When using the IMAQ integer to color value function, I get correct RGB values for colors chosen via a color box control - except if the colors are selected from the “system colors”. Is this supposed to happen? The RGB values for the system "White" is: 0, 0, 9.
Attachments:
ScreenShot010.jpg ‏21 KB

That function does look at the most significant byte. Try wiring the system color to a "Split Number" (numerics "Dat manipulation) to split the I32 to two I16 and then again to get four I8s.
You will find that the "other" bytes has a "1".
System colors are special.
Ben
Ben Rayner
I am currently active on.. MainStream Preppers
Rayner's Ridge is under construction

How to enter 16 bit RGB value?

I created a new blank file with 16 bit per channel mode.
I expect that RGB values would be three 16-bit numbers (0 to 65535) but when I try to manually enter a RGB value, each color is still 0 to 255. Why??

Obviously one cannot input in any RGB mode anything else
but integers 0...255 (in CS2).
The reason is probably this: besides special tests, a
higher resolution than 8bpc for input data is of no
practical value.
The range for 16bpc is not 0...2^16-1 but 0...2^15+1.
0 is mapped to 0, 128 to 16448 and 255 to 32768.
These values are shown in the InfoPalette by clicking
on the small triangle right to the eyedropper, followed
by choosing 16bpc.
Best regards --Gernot Hoffmann

Browse, open a Picture from phone. Getting the RGB value

Hai, can someone give me an example how to browse a picture file from the phone. And also an example on how to get the RGB value from a cordinate in a picture?
thx in advanced
Chapui

Apple needs an "unsubscribe" option from iMessage, so you can cease to take part of the conversation, just like you would with notifications in a forum. This happens all the time with my family, a group text gets sent out, and you're stuck for hours hearing the beeps of messages getting sent back & forth. If not unsubscribed, just silence it so you still get a record of it, but you stop being notified every time a message shows up from that thread for a certain "period", say like 6 hours (in case anyone reuses the thread to send another group message later).

How to change the text color of a label by using RGB values without changing the background colour?

xCode interface builder:
When I try to change the color property of a label's text by using the RGB values, the background color also changes to the same value automatically.
in other words:
While setting the RGB values for text colour of labels, the background colour also changes unless we use the sliders.
How to make sure that only the color of text changes and not the background?

You can simply do this.
[labelname setTextColor:[UIColor colorWithRed:38/255.0f green:171/255.0f blue:226/255.0f alpha:1.0f]];

How to use color picker or RGB values in the hue-saturation colorize adjustment

I have a monochromatic adornment that I want to match to the color of a logo. I am attempting to use the colorize option of a hue saturation adjustment layer to match color. But I cannot quite get the colors to match. I know the RGB values of the color, but how do these translate into the Hue/Sat/Lightness numbers of the adjustment dialog? I tried using the correlating H/S/B values fro9m the color picker but that did not work.
Any suggestions?

Thanks Zeno. Creating a layer with the color and using the blend mode worked fine. But as I stated in the original post, using the H/S/B (there is no HSL) values from the color picker does not work when you place them into the H/S/L values in the hue-adjustment layer with (or without) the colorize box checked. But your first suggestion worked like a charm. Thank you.

How do I get hexadecimal code or rgb values of the color in a selection?

I have a color. I need to know what its hexadecimal code is or what its rgb values are. I cannot find any tool or interface element in Photoshop that discovers the hexadecimal code or rgb values of a color in a selected area.
I have searched in the User Guide on every phrase I can think of, and not one gets a hit.
Any help will be appreciated.
Thanks,
Jeff

Easiest way is to click on the foreground colour which opens the Color Picker dialog box, and changes the cursor to the eye dropper. Now click on the colour. If it is crucial that it uses your selected area, copy the selection to a new layer. I have no idea if you want a point sample, or average of entire selection or what though?

How to get RGB value from pixel of an image.

hi, i need a little help... Is there any EASY way to get RGB value from point of an image? I searched javadoc but i only found very complex getRGB method working only with regions, and saving data into arrays.
Is there any other way that can use for example image.getGraphics() (so, i mean to get RGB from point of Graphics object) ?
Btw.: If you know, how Sprite.collidesWith(Sprite s, Boolean pixellevel) is working (with pixellevel = true), please write me. It could solve my problem too.
Thanks

Is there any other way that can use for example image.getGraphics() (so, i mean to get RGB from point of Graphics object) ?You can think of the graphics object like a pencil or paintbrush. Does a paintbrush know the color of the surface it is painting on? No.
Btw.: If you know, how Sprite.collidesWith(Sprite s, Boolean pixellevel) is working (with pixellevel = true), please write me. It could solve my problem too.Download the reference implementation from this site and see for yourself.
luck, db

How can I convert (or switch) the RGB percent values from the LR histogram into RGB values which are shown e. g. in PS/CameraRAW?

In LR 5.5 (same in previous versions) the RGB values in the histogram are shown in percent (relativ) values. I prefere to see the absolute values, but I can`t find any way to switch. Maybe this option is intentional disabled, because LR works in 16-Bit mode this would result in values up to 2^16. But as i compared the relativ values from LR with the absolute values from PS i run into a conversion problem. The following example shows the differences:
CameraRAW : RGB, 128,0,0
Lightroom: RGB, 43,8%, 19,0%, 6,2%
CameraRAW: RGB, 0,128,0
Lightroom: RGB, 29,8%, 47,5%, 17,5%
Mainly i have two questions:
1. Is there any possibility to change the percent RGB values in LR to absolut values?
2. How can i convert CameraRAW values to LR values (see above)?

TThe reason that a design decision was made from the beginning of LR to show only the percentage values was that RGB values are dependent on the color space and the LR histogram and numerical readout are derived from the Develop module's display space which is a hybrid color space with ProPhoto RGB primaries and the sRGB TRC. Thus the numerical values in the display would be different from the exported RGB image (in an orthodox space) and it was feared that this would be misleading. When soft proofing was introduced, because it involved converting the display to an orthodox space, it became possible to use the 0-255 scale in that mode.

How Do I Applyi RGB Values ToTweak Colors

Similar Messages

Maybe you are looking for