A função de decompor a cor em tons. - página 7

[Реter Konow]

Vladislav Andruschenko:

Bem, nomes ingleses foram inventados por uma razão.

Posso lhe dar outro exemplo em que nomes russos matarão seu código:

Você dá seu código a um cliente que não tem Cirílico. É isso aí. .... all gone..... :-)

E o cliente precisa do código, ou da solução?

[Vladislav Andruschenko]

Реter Konow:

O cliente quer o código ou a solução?

é por isso que você precisa decidir sobre o alvo e os usuários finais.

Coloque-se no lugar do usuário e esqueça tudo o que você fez: como o usuário se sentirá?

Será que tudo fará sentido para ele ou ela?

[Реter Konow]

Vladislav Andruschenko:

é por isso que você precisa decidir sobre o alvo e os usuários finais.

Coloque-se no lugar do usuário e esqueça tudo o que você fez: como o usuário se sentirá?

Será que ele ou ela entenderá tudo?

Eu concordo. Eu escrevo em dois idiomas. Eu posso fazer isso puramente em inglês.

[Vitaly Muzichenko]

Реter Konow:

Você, como um falante de inglês, sinta-se livre para ignorar minha decisão. Existem poucas palavras em inglês.

A propósito, como você é tão bom com o código inglês, por favor, me ajude com o código proposto por Nikolay Semko:

Sinceramente, eu não entendo como funciona. Tem muitas sílabas curtas em inglês. Exatamente o que você gosta.

Isso é o que eu sei sobre 30% de inglês, e apenas técnico, não conversador.

Na programação, há apenas algumas dezenas de palavras, e você pode memorizá-las depois de escrever literalmente 1-2 programas.

P.S. O código que você postou, existem apenas 5 variáveis, como elas não podem entender?

[Реter Konow]

Vitaly Muzichenko:

É isso mesmo, eu sei cerca de 30% de inglês, e apenas técnico, não conversador.

Na programação há apenas algumas dezenas de palavras, e elas podem ser memorizadas ao escrever literalmente 1-2 programas.

P.S. O código que você postou lá são apenas 5 variáveis, como você pode não entendê-las?

Bem, contei 30 variáveis em meu código (na função principal). E para quantos você conta? (estava brincando).

30% de inglês técnico é muito forte. Você sabe quão rico é o inglês técnico?

Algumas dúzias de palavras na programação? Agora vejo porque não nos entendemos))).

zy. Se você se refere ao código do Nikolai, esclareça como ele funciona.

[Реter Konow]

Em suma, o assunto pode ser encerrado. Fico feliz se alguém achar o código útil. Se não, então não...

[Nikolai Semko]

Реter Konow:

A propósito, a julgar pela imagem, a decomposição de cores aqui não está completa. Apenas a metade. A faixa deve se estender de completamente branco a completamente preto, através de todas as tonalidades de uma determinada cor.

Sim, você está certo.

Eu tentei implementá-lo e analisar e visualizar seu código.

Eis o que resultou disso:

#include <Canvas\iCanvas.mqh> //https://www.mql5.com/ru/code/22164

union rgb {uint clr; uchar c[4];};
void OnStart()
  {
   rgb c,cc;
   double d=5;
   while(!IsStopped())
     {
      c.c[2]=uchar(127.5*(1+sin(d*1.2))+0.4999); c.c[1]=uchar(127.5*(1+sin(d*1.9))+0.4999); c.c[0]=uchar(127.5*(1+sin(d*2.8))+0.4999);  // генерируем новый цвет
      cc.clr=c.clr;
      uint CLR[];
      ulong t=GetMicrosecondCount();
      Gradient(c.clr,CLR,W.Height);
      t=GetMicrosecondCount()-t;
      for(int y=0; y<W.Height; y++)
        {
         Canvas.LineHorizontal(0,W.Width-1,y,ColorToARGB(CLR[y],240));
         c.clr=CLR[y];
         Canvas.PixelSet((int)c.c[2]+(int)c.c[1]+(int)c.c[0],y,ColorToARGB(clrWhite));
         if (c.c[1]>0) Canvas.PixelSet(int(50.0*(int)c.c[2]/(double)c.c[1]+50.0*(int)c.c[0]/(double)c.c[1]),y,ColorToARGB(clrGreen));
         if (c.c[2]>0) Canvas.PixelSet(int(50.0*(int)c.c[1]/(double)c.c[2]+50.0*(int)c.c[0]/(double)c.c[2]),y,ColorToARGB(clrRed));
         if (c.c[0]>0) Canvas.PixelSet(int(50.0*(int)c.c[2]/(double)c.c[0]+50.0*(int)c.c[1]/(double)c.c[0]),y,ColorToARGB(clrBlue));
        }
      Canvas.FillRectangle(W.Width/2-80,W.Height/2-50,W.Width/2+80,W.Height/2+50,ColorToARGB(cc.clr,240));
      Canvas.CurentFont("Tahoma",20,22,ColorToARGB(~cc.clr)); // 20 -  размер шрифта, 22 - межстрочный интервал
      Canvas.TextPosition(W.Width/2-70,W.Height/2-40); // Стартовая позиция для шрифта в пикселях
      Canvas.Comm("Текущий цвет:");
      Canvas.Comm("R = "+string(cc.c[2]));
      Canvas.Comm("G = "+string(cc.c[1]));
      Canvas.Comm("B = "+string(cc.c[0]));
      Canvas.CurentFont("Times New Roman",30);
      Canvas.TextPosition(25.0,10.0);  // Стартовая позиция для шрифта в процентах от размеров экрана
      Canvas.Comm("Время формирования градиентного массива из "+string(W.Height)+" элементов = "+string(t)+" микросекунд");
      ChartChanged(); // на всякий случай контролируем изменение размеров окна, т.к. это скрипт (в индикаторах и экспертах это происходит автоматически)
      Canvas.Update();
      d+=0.01;
      Sleep(30);
     }
  }
//+------------------------------------------------------------------+

void Gradient(uint clr,uint &arr[],uint size)
  {
   if(size==0) return;
   ArrayResize(arr,size);
   rgb c;
   c.clr=clr;
   uchar R=c.c[2],G=c.c[1],B=c.c[0];
   uint i=0, tone=uint((size-1)*(((double)R+(double)G+(double)B)/765.0)+0.4999);
   double kR,kG,kB;
   if(tone!=0)
     {
      kR=(double)R/tone;
      kG=(double)G/tone;
      kB=(double)B/tone;
      for(i=0;i<=tone;i++)
        {
         c.c[2]=uchar(i*kR+0.4999);
         c.c[1]=uchar(i*kG+0.4999);
         c.c[0]=uchar(i*kB+0.4999);
         arr[i]=c.clr;
        }
     }
   if(tone!=(size-1))
     {
      kR=(double)(255-R)/(size-i);
      kG=(double)(255-G)/(size-i);
      kB=(double)(255-B)/(size-i);
      for(uint j=1;i<size;i++,j++)
        {
         c.c[2]=uchar(R+j*kR+0.4999);
         c.c[1]=uchar(G+j*kG+0.4999);
         c.c[0]=uchar(B+j*kB+0.4999);
         arr[i]=c.clr;
        }
     }
  }

Sua variante

minha variante:

Deixe-me explicar:

A linha branca é a linha de tom (soma das cores R+B+G) - idealmente deveria ser uma linha diagonal reta. Eu o tenho implementado, você não.

As linhas vermelha, azul e verde são linhas de relação de cores. Vamos chamá-los de harmônicas do espectro. O ideal seria que fossem verticais. Mas é impossível perceber isso depois que a cor máxima inicial passou a ser 255. Mas é possível chegar a uma situação em que não serão pontos de inflexão (marcados por setas vermelhas) e fazer um arco suave. Então, o declive parecerá sem "tufos". Este problema existe tanto em seus algoritmos quanto em meus. Pode ser corrigido, mas ainda não vejo o ponto, portanto é uma perda de tempo. Na prática, eu preciso de um gradiente de uma cor para outra. Isto é facilmente implementado com harmônicas estritamente verticais do espectro (o embaçamento da harmônica no topo é normal, pois é uma conseqüência do arredondamento). Neste problema, no entanto, o gradiente vai do preto ao branco através de uma terceira cor, razão pela qual estas manchas existem.

Estranho, eu tinha certeza que você estava escrevendo na MQL5. Mas além do programa dos 4, você também tem o estilo de programação dos 4. Tentei transferir seu algoritmo para 5, mas não funcionou, porque ele só exibe algumas faixas de cores. Isto provavelmente acontece por causa da confusão com o escopo das variáveis, mas corrigi-lo porque o código não é passível de depuração é extremamente difícil, por isso desisti. Entendo que você está acostumado ao seu estilo de programação e não entende o meu estilo. É mútuo porque estou acostumado a ver a estrutura de um programa em vez de lê-lo como um livro. E em seu código é impossível depurar e entender em que momento da definição da variável, os nomes longos das variáveis ocupam 90% do texto do programa, como resultado da qual a estrutura do programa é perdida, dissolvendo-se nestes nomes longos de variáveis de cor de barbie. Em resumo, seu código me parece pessoalmente como uma espécie de S&M.

Além disso, seu algoritmo acabou sendo dezenas de vezes mais lento, e a razão nem sequer é MQL4.Eu não consegui descobrir. Que tangentes, que triângulos quando só háRGB?

E tente dominar o sindicato - coisa muito útil.

Para entender melhor o que quero dizer, você deve tentar executar os dois scripts que anexei com seu algoritmo (MQL4) e o meu (MQL5).

Você também tem tais contratempos:

só que eu ainda não entendo, é um problema de lentidão do MT4 ou um bug em seu algoritmo.

[Реter Konow]

Nikolai Semko:

1. Nikolai, mesmo comparando as duas primeiras fotos que você citou, você pode ver imediatamente que há uma névoa cinza pairando sobre sua versão. Veja com atenção. E na minha versão a cor é muito mais brilhante. Você acha que sua versão transmite melhor a cor?

2. Tomei a paleta de cores do Windows como referência. Consegui uma correspondência de 99% de cores. Verifique suas cores para ver se elas combinam com o Windows. Imprima uma série de tons como eu fiz. Em seguida, abra as propriedades do gráfico e a paleta. Entrar em janelas de valores de componentes de cor inicial e depois mover o controle deslizante para cima e para baixo. Os números vão mudar. Você procura por estes números em sua impressão e vê o quão bem eles correspondem.

3. eu entendo que a implementação específica pode variar. Eu não verifiquei meu algoritmo especificamente para velocidade, e não o otimizei para velocidade. Sua solução pode parecer dar-lhe uma velocidade maior. Não vou negá-lo.

4. Existe a noção de um prisma na óptica. Há uma noção de refração da luz. Eu estava começando a partir deste mesmo paradigma. Tracei 256*256 (de 0 a 255). Em seguida, tracei linhas. Encontrei o eixo de refração da cor. Ela está no centro do gráfico. Cada componente é uma curva que consiste em dois segmentos. No total, a cor tem três linhas curvas, cada uma delas refracta-se no centro do gráfico, dividindo-se em dois segmentos. Cada segmento tem seu próprio ângulo. A cor original tem uma coordenada no gráfico. Ela pode ser encontrada entre seus matizes. Minha tarefa era encontrar a cor inicial, determinar os ângulos de todos os seis segmentos e obter os valores de cada componente ao longo de sua linha.

5. Tangentes são proporções de cataratas contíguas a cataratas opostas. É necessário para o cálculo dos ângulos dos segmentos e o cálculo da altura dos catafetos opostos (que é o valor de um componente em um tom de cor concreta).

6. Quanto aos estilos de programação, sugiro que não discutamos isso. Para a essência do tópico não é relevante.

7. Sobre os contratempos - talvez sejam. Mas eu ainda não os encontrei. Portanto, não sei.

A propósito, diga-me como funciona a decomposição de cores em sua versão. Eu não entendo totalmente.

[Реter Konow]

Nikolai Semko:

Eu simplesmente ainda não entendo, é um problema de lentidão do MT4 ou um bug em seu algoritmo.

Sobre a diferença de velocidade dos algoritmos:

1. seu algoritmo preenche a matriz de uint, enquanto o meu preenche a matriz de string. (Preciso exatamente de fio, para extrair facilmente os componentes necessários da sombra e depois trabalhar com eles). Você pode ver a diferença na velocidade de preenchimento dos dois tipos de matrizes a partir do roteiro abaixo.

2. seu algoritmo funciona em МТ5, e o meu em МТ4. A diferença na velocidade de enchimento destas plataformas foi discutida por mim aqui -https://www.mql5.com/ru/forum/222333. Pelo roteiro abaixo, você mesmo pode ver a diferença. Coloque-o em ambas as plataformas e compare.

//+------------------------------------------------------------------+
//|                        Проверка скорости заполнения массивов.mq5 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int int_Array[30000];
string string_Array[30000];
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   ulong t1 = GetMicrosecondCount();
   //--------------------------
   for(int b1 = 0; b1 < 30000; b1++)int_Array[b1] = 1;
   //--------------------------
   ulong t2 = GetMicrosecondCount();
   //--------------------------
   int q = int_Array[0] + int_Array[1];//Этот код нужен, иначе компилятор не заполняет массив.
   //--------------------------
   Print("//----------------------------------------------------------------------------------");
   Print(" Время заполнения массива      int:  ",t2-t1);
   
 
 
   ulong t3 = GetMicrosecondCount();
   //--------------------------
   for(int b2 = 0; b2 < 30000; b2++)string_Array[b2] = "1";
   //--------------------------
   ulong t4 = GetMicrosecondCount();
   //--------------------------
   int q2 = int_Array[0] + int_Array[1];//Этот код нужен, иначе компилятор не заполняет массив.
   //--------------------------
   Print(" Время заполнения массива string:  ",t4-t3);   
   Print("//----------------------------------------------------------------------------------");
   
   Alert(q + q2);//Этот код нужен, иначе компилятор не заполняет массив.
  }
//+------------------------------------------------------------------+

Medi a velocidade de 30 000 células de matrizes int e string em MT4 e MT5 (ms):

MT5
2018.10.11 13:29:24.502 Замер скорости заполнения массивов (RTS-12.18,H1)  Время заполнения массива string:  464
2018.10.11 13:29:24.502 Замер скорости заполнения массивов (RTS-12.18,H1)  Время заполнения массива    int:  14

MT4
2018.10.11 13:30:39.199 Замер скорости заполнения массивов GBPUSD,M30:     Время заполнения массива string:  692
2018.10.11 13:30:39.199 Замер скорости заполнения массивов GBPUSD,M30:     Время заполнения массива    int:  363

Como você pode ver, meu algoritmo é mais lento por duas razões:

1. Ele preenche o conjunto de fios e não o conjunto de uint.
2. Você só o testou no MT4. A velocidade das matrizes de enchimento entre plataformas pode variar dezenas de vezes.

P.S. Além disso, meu algoritmo pode retornar o número de células da matriz onde a cor original está localizada. Ajuda a criar um gradiente. Afinal, você precisa saber de qual célula se mover para a esquerda ou direita.

[Nikolai Semko]

Реter Konow:

Sobre a diferença na velocidade dos algoritmos:

1. seu algoritmo preenche uma matriz de uint, enquanto o meu preenche uma matriz de string. (Preciso de fio para extrair facilmente os componentes necessários da sombra e depois trabalhar com eles). Você pode ver a diferença na velocidade de preenchimento dos dois tipos de matrizes a partir do roteiro abaixo.

2. seu algoritmo funciona em МТ5, e o meu em МТ4. A diferença na velocidade de enchimento destas plataformas foi discutida por mim aqui -https://www.mql5.com/ru/forum/222333. Pelo roteiro abaixo, você mesmo pode ver a diferença. Coloque-o em ambas as plataformas e compare.

Medi a velocidade de 30 000 células de matrizes int e string em MT4 e MT5 (ms):

Como você pode ver, meu algoritmo é mais lento por duas razões:

1. Ele preenche o conjunto de fios e não o conjunto de uint.
2. Você só o testou no MT4. A velocidade das matrizes de enchimento entre plataformas pode variar dezenas de vezes.

P.S. Além disso, meu algoritmo pode retornar o número de células da matriz onde a cor original está localizada. Ajuda a criar um gradiente. Afinal, você precisa saber de qual célula se mover para a esquerda ou direita.

Eu tirei as tangas do seu algoritmo. Foi um mistério para mim porque você os usou. Olhe no código, então como eu produziria a cor real. Você tem muitas verificações desnecessárias, você usa funções como tangente, ordenação de matriz, eu apenas +-*//. A Mt4 é mais lenta, isso é compreensível, mas não 30 vezes mais lenta.

Ok, vou colocar meu algoritmo no 4 mais tarde e ver. Por que você está usando 4? Para uma GUI, 4 não é bom de todo. Nem sequer lê recursos. De 4 a 5, é muito mais difícil refazer o código do que o contrário.