Java 以编程方式查找颜色补码？

有没有办法在给定RGB值的情况下找到颜色的补码？或者只能在某些颜色中找到它？用Java怎么做呢？

应该是数学

两种颜色的r值之和应为255

两种颜色的g值之和应为255

---

这两种颜色的b值之和应该是255

以上答案中没有一个真正给出了找到互补颜色的方法，因此以下是我在Processing中编写的版本：

import java.awt.Color;

color initial = color(100, 0, 100);

void setup() {
  size(400, 400);  

  fill(initial);
  rect(0, 0, width/2, height);

  color opposite = getOppositeColor(initial);
  fill(opposite);
  rect(width/2, 0, width/2, height);
}

color getOppositeColor(color c) {
  float[] hsv = new float[3];
  Color.RGBtoHSB(c>>16&0xFF, c>>8&0xFF, c&0xFF, hsv);
  hsv[0] = (hsv[0] + 0.5) % 1.0;

  // black or white? return opposite
  if (hsv[2] == 0) return color(255);
  else if (hsv[2] == 1.0) return color(0);

  // low value? otherwise, adjust that too
  if (hsv[2] < 0.5) {
    hsv[2] = (hsv[2] + 0.5) % 1.0;
  }

  return Color.HSBtoRGB(hsv[0], hsv[1], hsv[2]);
}

导入java.awt.Color；
颜色初始值=颜色（100,0,100）；
无效设置（）{
尺寸（400400）；
填写（首字母）；
矩形（0，0，宽度/2，高度）；
color CONVERSITE=GetOppositieCLORE（初始）；
填充（相反）；
矩形（宽度/2，0，宽度/2，高度）；
}
颜色getOppositeColor（颜色c）{
浮动[]hsv=新浮动[3]；
颜色.RGBtoHSB（c>>16&0xFF，c>>8&0xFF，c&0xFF，hsv）；
hsv[0]=（hsv[0]+0.5）%1.0；
//黑色还是白色？返回相反方向
如果（hsv[2]==0）返回颜色（255）；
否则如果（hsv[2]==1.0）返回颜色（0）；
//低值？否则，也调整它
如果（hsv[2]<0.5）{
hsv[2]=（hsv[2]+0.5）%1.0；
}
返回颜色.HSBtoRGB（hsv[0]，hsv[1]，hsv[2]）；
}

这就是我想到的：（猜想）

设

r

、

g

和

b

为原始颜色的RGB分量

让

r'

、

g'

和

b'

成为互补色的RGB分量

然后：

---

我看到这与网站（即www.color-hex.com）给出的答案相同，但我仍将证明这一点。：）

只关注3D RGB立方体。这里有一个函数，它在立方体中进行二进制搜索，以避免必须找出如何在一个方向上投射向量，并在立方体边界上找到与其相交的最近点

def farthestColorInRGBcubeFrom(color):
  def pathsAt(r, g, b):
    paths = [(r, g, b)]
    if r < 255:
        paths.append((int((r + 255)/2), g, b))
    if r > 0:
        paths.append((int(r/2), g, b))
    if g < 255:
        paths.append((r, int((g + 255)/2), b))
    if g > 0:
        paths.append((r, int(g/2), b))
    if b < 255:
        paths.append((r, g, int((b + 255)/2)))
    if b > 0:
        paths.append((r, g, int(b/2)))
    return paths                         
r = color.red();  g = color.green();  b = color.blue();
#naive guess:
r0 = 255 - r;  g0 = 255 - g;  b0 = 255 - b;
paths = pathsAt(r0, g0, b0)
maxPath = None
while paths != []:
    for p in paths:
        d = (r - p[0])**2 + (g - p[1])**2 + (b - p[0])**2
        if maxPath != None:
            if d > maxPath[0]:
                maxPath = (d, p)
        else:
            maxPath = (d, p)
    p = maxPath[1]
    paths = pathsAt(p[0], p[1], p[2])
c = maxPath[1]
return QColor(c[0], c[1], c[2], color.alpha())

def farthestColorInRGBcubeFrom（颜色）：
def路径卫星（r、g、b）：
路径=[（r，g，b）]
如果r<255：
路径追加（（int（（r+255）/2），g，b））
如果r>0：
路径追加（（int（r/2），g，b））
如果g<255：
路径追加（（r，int（（g+255）/2），b））
如果g>0：
附加路径（（r，int（g/2），b））
如果b<255：
append（（r，g，int（（b+255）/2）））
如果b>0：
append（（r，g，int（b/2）））
返回路径
r=颜色。红色（）；g=颜色。绿色（）；b=颜色。蓝色（）；
#天真的猜测：
r0=255-r；g0=255-g；b0=255-b；
路径=路径卫星（r0、g0、b0）
maxPath=None
而路径！=[]:
对于路径中的p：
d=（r-p[0]）**2+（g-p[1]）**2+（b-p[0]）**2
如果maxPath！=无：
如果d>maxPath[0]：
maxPath=（d，p）
其他：
maxPath=（d，p）
p=最大路径[1]
路径=路径卫星（p[0]，p[1]，p[2]）
c=最大路径[1]
返回QColor（c[0]，c[1]，c[2]，color.alpha（））

对于粗略近似值，可以通过将RGB转换为HSL（色调、饱和度、亮度）来实现

使用HSL值，将色调移动180度，以获得与原始值相对的色轮上的颜色

最后，转换回RGB

我在这里使用十六进制值编写了一个JavaScript实现-

---

对于RGB，只需删除十六进制到RGB和RGB到十六进制的转换。

您可以在以下位置找到更多信息：

---

寻找相反颜色的更一般、更简单的解决方案是：

private int getComplementaryColor( int color) {
    int R = color & 255;
    int G = (color >> 8) & 255;
    int B = (color >> 16) & 255;
    int A = (color >> 24) & 255;
    R = 255 - R;
    G = 255 - G;
    B = 255 - B;
    return R + (G << 8) + ( B << 16) + ( A << 24);
}

private int getComplementaryColor（int-color）{
int R=color&255；
int G=（颜色>>8）和255；
intb=（颜色>>16）和255；
INTA=（颜色>>24）&255；
R=255-R；
G=255-G；
B=255-B；
返回R+（G定义补色/补色。如果补色和补色始终与输入颜色相关（取决于您的定义），应该很简单。我在网上看到过用Javascript完成的，我只是记不起名字或URL。更新：我找到了一个！它不做补色，但有一大堆其他选择。补色很容易使用该类。这将导致例如红色与青色配对，而不是绿色。更糟糕的是，
127127
会与蓝色配对th
128128
这将使红色与青色配对。
public static int complimentaryColour(int colour) {
    return ~colour;
}

private int getComplementaryColor( int color) {
    int R = color & 255;
    int G = (color >> 8) & 255;
    int B = (color >> 16) & 255;
    int A = (color >> 24) & 255;
    R = 255 - R;
    G = 255 - G;
    B = 255 - B;
    return R + (G << 8) + ( B << 16) + ( A << 24);
}