La funzione di scomporre il colore in sfumature. - pagina 7

[Реter Konow]

Vladislav Andruschenko:

Beh, i nomi inglesi sono stati inventati per un motivo.

Posso darvi un altro esempio in cui i nomi russi uccideranno il vostro codice:

Si passa il codice a un cliente che non ha il cirillico. Questo è tutto. .... tutto andato..... :-)

E il cliente ha bisogno del codice o della soluzione?

[Vladislav Andruschenko]

Реter Konow:

Il cliente vuole il codice o la soluzione?

Ecco perché è necessario decidere il target e gli utenti finali.

Mettiti nei panni dell'utente e dimentica tutto quello che hai fatto: come si sentirà l'utente?

Tutto avrà un senso per lui o per lei?

[Реter Konow]

Vladislav Andruschenko:

Ecco perché è necessario decidere il target e gli utenti finali.

Mettiti nei panni dell'utente e dimentica tutto quello che hai fatto: come si sentirà l'utente?

Lui o lei capirà tutto?

Sono d'accordo. Scrivo in due lingue. Posso farlo solo in inglese.

[Vitaly Muzichenko]

Реter Konow:

Lei, in quanto anglofilo, si senta libero di ignorare la mia decisione. Ci sono poche parole inglesi.

A proposito, visto che sei così bravo con il codice inglese, per favore aiutami con il codice proposto da Nikolay Semko:

Onestamente, non capisco come funziona. Ha molte sillabe inglesi corte. Proprio quello che ti piace.

Questa è la cosa che so sul 30% dell'inglese, e solo tecnico, non conversazionale.

Nella programmazione, ci sono solo un paio di dozzine di parole, e si possono memorizzare dopo aver scritto letteralmente 1-2 programmi.

P.S. Il codice che hai postato, ci sono solo 5 variabili, come possono non capire?

[Реter Konow]

Vitaly Muzichenko:

Questo è il punto, conosco circa il 30% dell'inglese, e solo tecnico, non conversazionale.

Nella programmazione ci sono solo un paio di dozzine di parole, e possono essere memorizzate scrivendo letteralmente 1-2 programmi.

P.S. Nel codice che hai postato ci sono solo 5 variabili, come fai a non capirle?

Bene, ho contato 30 variabili nel mio codice (nella funzione principale). E fino a quanti ne conta? (scherzo).

Il 30% di inglese tecnico è molto forte. Sai quanto è ricco l'inglese tecnico?

Un paio di dozzine di parole in programmazione? Ora capisco perché non ci capiamo)).

zy. Se intendi il codice di Nikolai, illumina come funziona.

[Реter Konow]

Tutto sommato, l'argomento può essere chiuso. Sono contento se qualcuno trova il codice utile. Se no, allora no...

[Nikolai Semko]

Реter Konow:

A proposito, a giudicare dalla foto, la decomposizione del colore qui non è completa. Solo la metà. La gamma dovrebbe estendersi dal completamente bianco al completamente nero, attraverso tutte le sfumature di un colore particolare.

Sì, hai ragione.

Ho cercato di implementarlo e di analizzare e visualizzare il tuo codice.

Ecco cosa ne è venuto fuori:

#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;
        }
     }
  }

La tua variante

la mia variante:

Lasciatemi spiegare:

La linea bianca è la linea del tono (somma dei colori R+B+G) - idealmente dovrebbe essere una linea diagonale dritta. Io l'ho implementato, voi no.

Le linee rosse, blu e verdi sono linee di rapporto di colore. Chiamiamole armoniche dello spettro. Idealmente dovrebbero essere verticali. Ma è impossibile realizzarlo dopo che il colore massimo iniziale è diventato 255. Ma è possibile raggiungere una situazione in cui non ci saranno punti di flessione (contrassegnati da frecce rosse) e fare un arco liscio. Allora il gradiente apparirà senza "grumi". Questo problema esiste sia nel tuo che nel mio algoritmo. Può essere risolto, ma non ne vedo ancora il motivo, quindi è una perdita di tempo. In pratica ho bisogno di un gradiente da un colore all'altro. Questo è facilmente realizzabile con le armoniche strettamente verticali dello spettro (la sfocatura dell'armonica in alto è normale, poiché è una conseguenza dell'arrotondamento). In questo problema, però, il gradiente va dal nero al bianco attraverso un terzo colore, ed è per questo che esistono queste pieghe.

Strano, ero sicuro che stavi scrivendo in MQL5. Ma oltre al programma del 4 in sé, hai anche lo stile di programmazione del 4. Ho provato a trasferire il tuo algoritmo al 5 ma non ha funzionato, perché mostra solo alcune strisce di colore. Questo accade molto probabilmente a causa della confusione con l'ambito delle variabili, ma risolverlo perché il codice non è suscettibile di debug è estremamente difficile, quindi ho rinunciato. Capisco che siete abituati al vostro stile di programmazione e non capite il mio stile. È reciproco perché sono abituato a vedere la struttura di un programma invece di leggerlo come un libro. E nel tuo codice è impossibile fare il debug e capire in quale momento della definizione delle variabili, i lunghi nomi di variabili occupano il 90% del testo del programma, di conseguenza la struttura del programma si perde, dissolvendosi in questi lunghi nomi di variabili color barbie. Tutto sommato, il tuo codice mi sembra personalmente una specie di sadomaso.

Inoltre, il tuo algoritmo è risultato essere decine di volte più lento, e la ragione non è nemmeno MQL4. Non riuscivo a capirlo. Qualitangenti, quali triangoli quando c'è solo RGB?

E cerca di padroneggiare l'unione - cosa molto utile.

Per capire meglio cosa intendo, dovresti provare ad eseguire entrambi gli script che ho allegato con il tuo algoritmo (MQL4) e il mio (MQL5).

Anche voi avete queste disavventure:

Solo che non capisco ancora, è un problema di lentezza di MT4 o un bug nel tuo algoritmo.

[Реter Konow]

Nikolai Semko:

1. Nikolai, anche confrontando le prime due foto che hai citato, si vede subito che c'è una foschia grigia che incombe sulla tua versione. Guardate attentamente. E nella mia versione il colore è molto più luminoso. Pensi che la tua versione trasmetta meglio il colore?

2. Ho preso la tavolozza dei colori di Windows come riferimento. Ho ottenuto una corrispondenza di colore del 99%. Controllate i vostri colori per vedere se corrispondono a quelli di Windows. Stampate una serie di tonalità come ho fatto io. Poi apri le proprietà del grafico e la tavolozza. Inserisci nelle finestre dei valori dei componenti del colore iniziale e poi muovi il cursore su e giù. I numeri cambieranno. Cercate questi numeri sulla vostra stampa e vedete quanto bene corrispondono.

3. Comprendo che l'attuazione specifica può variare. Non ho controllato il mio algoritmo specificamente per la velocità, e non l'ho ottimizzato per la velocità. La vostra soluzione può sembrare che vi dia una velocità maggiore. Non lo nego.

4. C'è una nozione di prisma in ottica. C'è una nozione di rifrazione della luce. Partivo proprio da questo paradigma. Ho tracciato 256*256 (da 0 a 255). Poi ho tracciato delle linee. Ho trovato l'asse di rifrazione del colore. Si trova al centro del grafico. Ogni componente è una curva composta da due segmenti. In totale il colore ha tre linee curve, ognuna delle quali si rifrange nel centro del grafico, dividendosi in due segmenti. Ogni segmento ha il suo angolo. Il colore originale ha una coordinata sul grafico. Si può trovare tra le sue sfumature. Il mio compito era quello di trovare il colore iniziale, determinare gli angoli di tutti e sei i segmenti e ottenere i valori di ogni componente lungo la sua linea.

5. Le tangenti sono i rapporti tra i cateti adiacenti e quelli opposti. È necessario per il calcolo degli angoli dei segmenti e il calcolo dell'altezza dei cateti opposti (che è il valore di un componente in un tono di colore concreto).

6. Per quanto riguarda gli stili di programmazione, suggerisco di non discuterne. Per l'essenza dell'argomento non è rilevante.

7. Sui contrattempi - forse lo sono. Ma non li ho ancora incontrati. Perciò non lo so.

A proposito, dimmi come funziona la decomposizione del colore nella tua versione. Non lo capisco completamente.

[Реter Konow]

Nikolai Semko:

Solo non capisco ancora, è un problema di lentezza di MT4 o un bug nel tuo algoritmo.

Sulla differenza di velocità degli algoritmi:

1. Il tuo algoritmo riempie l'array di uint, mentre il mio riempie l'array di stringhe. (Ho bisogno esattamente di stringhe, per estrarre facilmente i componenti necessari dall'ombra e poi lavorare con loro). Potete vedere la differenza nella velocità di riempimento di entrambi i tipi di array dallo script qui sotto.

2. il tuo algoritmo funziona su МТ5, e il mio su МТ4. La differenza nella velocità di riempimento degli array su queste piattaforme è stata discussa da me qui -https://www.mql5.com/ru/forum/222333. Dallo script qui sotto potete vedere voi stessi la differenza. Mettetelo su entrambe le piattaforme e confrontatelo.

//+------------------------------------------------------------------+
//|                        Проверка скорости заполнения массивов.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);//Этот код нужен, иначе компилятор не заполняет массив.
  }
//+------------------------------------------------------------------+

Ho misurato la velocità di 30 000 celle di array di int e stringhe su 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

Come potete vedere, il mio algoritmo è più lento per due motivi:

1. Riempie l'array di stringhe e non quello di uint.
2. L'hai testato solo su MT4. La velocità di riempimento degli array tra le piattaforme può variare di decine di volte.

P.S. Inoltre, il mio algoritmo può restituire il numero della cella dell'array dove si trova il colore originale. Aiuta a creare un gradiente. Dopo tutto, è necessario sapere da quale cella spostarsi a sinistra o a destra.

[Nikolai Semko]

Реter Konow:

Sulla differenza di velocità degli algoritmi:

1. il tuo algoritmo riempie un array uint, mentre il mio riempie un array di stringhe. (Ho bisogno di stringhe per estrarre facilmente i componenti necessari dall'ombra e poi lavorare con loro). Potete vedere la differenza nella velocità di riempimento di entrambi i tipi di array dallo script qui sotto.

2. il tuo algoritmo funziona su МТ5, e il mio su МТ4. La differenza nella velocità di riempimento degli array su queste piattaforme è stata discussa da me qui -https://www.mql5.com/ru/forum/222333. Dallo script qui sotto potete vedere voi stessi la differenza. Mettetelo su entrambe le piattaforme e confrontatelo.

Ho misurato la velocità di 30 000 celle di array di int e stringhe su MT4 e MT5 (ms):

Come potete vedere, il mio algoritmo è più lento per due motivi:

1. Riempie l'array di stringhe e non quello di uint.
2. L'hai testato solo su MT4. La velocità di riempimento degli array tra le piattaforme può variare di decine di volte.

P.S. Inoltre, il mio algoritmo può restituire il numero della cella dell'array dove si trova il colore originale. Aiuta a creare un gradiente. Dopo tutto, è necessario sapere da quale cella spostarsi a sinistra o a destra.

Ho tolto i perizomi dal tuo algoritmo. Era un mistero per me perché li hai usati. Guarda nel codice, come farei ad emettere il colore reale allora. Hai un sacco di controlli inutili, usi funzioni come la tangente, l'ordinamento degli array, io solo +-*//. Mt4 è più lento, questo è comprensibile, ma non 30 volte più lento.

Ok, più tardi metterò il mio algoritmo sul 4 e vedremo. Perché usi il 4? Per una GUI, il 4 non va affatto bene. Non legge nemmeno le risorse. Da 4 a 5 è molto più difficile convertire il codice che il contrario.