[RESOLVIDO] Buscar o intervalo de cores

Assuntos Gerais
#1

Boa Tarde pessoal,
Peço a ajuda de vocês para solucionar o seguinte problema.
Tenho em mãos duas cores em hexadecimal e preciso buscar o intervalo de cores existente entre elas.
Como faço para realizar essa operação e retornar os códigos correspondentes desse intervalo?

#2

Faz o Seguinte:

Converte os valores para Decimal utilizando o metodo parseInt da classe Integer, passando como parametro a base 16.

Ex: int valor =  Integer.parseInt( stringcomoHexa, 16);

Pronto, é só você dar um loop de um número até o outro e printar o código Hexa, para converter de decimal para hexa é só utilizar:

Integer.toHexString

Abs!

#3

Dependendo do que você queira, talvez será necessário separar os canais de cores para buscar esse intervalo, e fazer isso canal por canal.
De qualquer forma é só fazer o que o colega indicou pegando de 2 em 2 dígitos hexas. Dará um número muito menor de combinações.

#4

Com base nas sugestões citadas anteriormente tentei criar um teste que me retornasse os valores intermediários entre as cores. Esse teste funcionou, mas com algumas falhas.
Não consigo pegar a escala de cores entre as cores passadas. As cores retornadas fogem do padrão limitado.

Exemplo:
Se eu passar duas cores (ex: preto e branco) o normal seria aparecer uma escala com tons de cinza. Entretando, aparecem cores diferentes.

O código abaixo é o que utiizo para fazer esse teste.
Os parâmetros são as duas cores passadas para limitar a escala e a quatidade de cores de retorno dessa escala.

public static void buscaValores(String cor1, String cor2, int qtde) {
		int divisor = qtde;
		int corMaior = Integer.parseInt(cor1, 16);
		int corMenor = Integer.parseInt(cor2, 16);
		int diferenca = (corMaior - 1) - (corMenor + 1);
		int valorIntermediario = diferenca / divisor;
		List<String> listaCores = new LinkedList<String>();
		for (int i = corMenor + valorIntermediario ; i <= corMaior - 1; i = i + valorIntermediario) {
			listaCores.add(Integer.toHexString(i));
		}
		for (String string : listaCores) {
			System.out.println(string);
		}
	}
#5

Acho que o pessoal lhe deu informações completamente erradas.

Uma cor, em hexadecimal, é composta aditivamente pelos valores das cores vermelho ®, verde (G) e azul (B), sendo que o primeiro byte é o vermelho, o segundo o verde, e o terceiro o azul.
O valor 0 corresponde à intensidade mínima, e o valor 0xFF à intensidade máxima.
Veja uma tabelinha aqui:
http://html-color-codes.com/

Por exemplo, branco = 0xFFFFFF, preto = 0x000000, vermelho = 0xFF0000, verde = 0x00FF00, azul = 0x0000FF, amarelo = 0xFFFF00 (porque é uma combinação de vermelho e verde), ciano = 0x00FFFF (uma combinação de azul e verde), magenta = 0xFF00FF (uma combinação de azul e vermelho).

Os tons de cinza têm os três componentes, azul, amarelo e vermelho, em proporções iguais (os três números, R, G e B, são iguais).

Por exemplo, preto = 0x000000, branco = 0xFFFFFF, cinza escuro = 0x333333, cinza claro = 0xCCCCCC, cinza médio = 0x808080.

Sabendo isso, você vai conseguir obter a gradação das cores conforme você quiser.

#6

Você precisa entender como as cores funcionam. Como eu falei, existem 3 componentes, R, G e B.
Se você quer uma variação homogênea de cor, você precisa calcular cada um desses componentes individualmente.

import java.util.LinkedHashSet;
import java.util.Set;

public class Teste {

    public static Set&lt;String&gt; buscaCoresIntermediarias(String cor1, String cor2, int qtde) {
        double r1 = Integer.parseInt(cor1.substring(0, 2), 16);
        double g1 = Integer.parseInt(cor1.substring(2, 4), 16);
        double b1 = Integer.parseInt(cor1.substring(4, 6), 16);

        int r2 = Integer.parseInt(cor2.substring(0, 2), 16);
        int g2 = Integer.parseInt(cor2.substring(2, 4), 16);
        int b2 = Integer.parseInt(cor2.substring(4, 6), 16);

        //Calcula a taxa de aumento em cada componente
        double propr = (r2 - r1) / qtde;
        double propg = (g2 - g1) / qtde;
        double propb = (b2 - b1) / qtde;
        Set&lt;String&gt; cores = new LinkedHashSet&lt;String&gt;();

        for (int i = 0; i &lt; qtde; i++) {
            cores.add(String.format(&quot;%02x%02x%02x&quot;, (int)r1, (int)g1, (int)b1));
            r1 += propr;
            g1 += propg;
            b1 += propb;
            
        }
        return cores;
    }
    
    public static void main(String args[]) {
        for (String cor : buscaCoresIntermediarias(&quot;FFFFFF&quot;, &quot;000000&quot;, 10)) {
            System.out.println(cor);
        }    
    }
}
#7

O exemplo que ViniGodoy enviou funcionou do jeito que eu queria.

Muito Obrigado a todos pela ajuda.

#8