La función de descomponer el color en matices. - página 18

 
Реter Konow:

Tienes razón en lo de "R = Source_R", pero lo dejé así porque tiene más sentido el funcionamiento del algoritmo.

El algoritmo necesita ciertamente algo más de trabajo. No es perfecto. Tal vez al final se me ocurra un algoritmo similar al tuyo. Pero llegando hasta el final, obtendré incomparablemente más. Al fin y al cabo, voy a recorrer un camino de conocimiento y comprensión y, por tanto, el área creativa en la que aplique mi algoritmo será mucho más amplia que si me limitara a copiar la solución de otra persona. Por lo tanto, siempre elijo mi propio camino.

la línea

StringToColor((string)MathRound(Первая_компонента) + "," + (string)MathRound(Вторая_компонента) + "," + (string)MathRound(Третья_компонента));

es la fuente de los frenos locos.

Intenta hacer un perfil.

Esta forma será mucho más rápida:

((uint)MathRound(Первая_компонента))|((uint)MathRound(Вторая_компонента)<<8)|((uint)MathRound(Третья_компонента)<<16);
 
Nikolai Semko:

la línea

la fuente de los frenos rabiosos

Intenta hacer un perfil.

Así será mucho más rápido:

Mierda, mi algoritmo tiene la misma velocidad que el tuyo))

¡Gracias, Nikolai!

No estoy familiarizado con este tipo de operaciones.
 
Реter Konow:

Mierda, mi algoritmo tiene la misma velocidad que el tuyo)).

¡Gracias, Nikolai!

Todavía no. Todavía hay un par de cosas que arreglar.

 

Se eliminaron las funciones redundantes. Ahora solo la función principal:

 //+------------------------------------------------------------------+
//|                                              Gradient test 1.mq4 |
//|                                                      Peter Konow |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
#property link        "https://www.mql5.com"
#property version    "1.00"
#include <Canvas\Canvas.mqh>
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
union rgb { uint clr; uchar c[ 4 ];};
rgb C,cc;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart ()
  {
   CCanvas canvas;
   if (!canvas.CreateBitmapLabel( "Gradient" , 200 , 200 , 768 , 256 , COLOR_FORMAT_ARGB_NORMALIZE )) { Print ( "Error creating canvas: " , GetLastError ()); }
   double d= 5 ;
   uint Gradient[ 256 ];
   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;
       ulong t= GetMicrosecondCount ();
      Диапазон_оттенков(C.clr,Gradient);
       //Gradient(C.clr,Gradient,256);
      t= GetMicrosecondCount ()-t;
       for ( int y= 0 ; y< 256 ; y++)
        {
         //Alert(__FUNCTION__,"  Gradient[",y,"]  ",Gradient[y]);
         //canvas.LineHorizontal(0,767,y,ColorToARGB(StringToColor(Gradient[y]),255));
         canvas.LineHorizontal( 0 , 767 ,y, ColorToARGB (Gradient[y], 255 ));
         C.clr=Gradient[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( 500 , 75 , 660 , 150 , ColorToARGB (cc.clr, 240 ));
      canvas.FontSet( "Tahoma" , 20 ); 
      canvas. TextOut ( 510 , 85 , "R = " + string (cc.c[ 2 ]), ColorToARGB (~cc.clr)); 
      canvas. TextOut ( 510 , 107 , "G = " + string (cc.c[ 1 ]), ColorToARGB (~cc.clr)); 
      canvas. TextOut ( 510 , 129 , "B = " + string (cc.c[ 0 ]), ColorToARGB (~cc.clr));
      canvas.FontSet( "Times New Roman" , 15 );
      canvas. TextOut ( 300 , 10 , "Время формирования градиентного массива из 256 элементов = " + string (t)+ " микросекунд" , ColorToARGB ( clrWhite ));
      canvas.Update();
      d+= 0.01 ;
       Sleep ( 30 );
     }
   canvas.Destroy();
//------------------------
// for(int a1 = 0; a1 < 256; a1++)Alert(__FUNCTION__,"  Gradient[",a1,"]  ",Gradient[a1]);
  }
//+------------------------------------------------------------------+
//================================================================================================================================================================
void Диапазон_оттенков( color _Цвет, uint &Все_оттенки[])
{
 color R = 0 , G = 0 ,  B = 0 ;
 int    q = 0 , w1 = 0 , w2 = 0 ;
 double Components[ 3 ];
 //------------------------------------------------------
 uint Этот_цвет;
 double Тангенс_угла_старшего_треугольника_1,      
        Тангенс_угла_среднего_треугольника_1,                  
        Тангенс_угла_младшего_треугольника_1,                       
        Значение_в_точке_преломления_старшей_компоненты,  
        Значение_в_точке_преломления_средней_компоненты,
        Значение_в_точке_преломления_младшей_компоненты,    
        Тангенс_угла_старшего_треугольника_2,
        Тангенс_угла_среднего_треугольника_2,    
        Тангенс_угла_младшего_треугольника_2;
 //------------------------------------------------------
 double pi = 3.1415926536 ,
        Comp_1,Comp_2,Comp_3,
         //-----------------------------------------------
        Первая_компонента = 0.0 ,
        Вторая_компонента = 0.0 ,
        Третья_компонента = 0.0 ,
         //-----------------------------------------------
        Исходный_R = (_Цвет)& 0xff , 
        Исходный_G = (_Цвет>> 8 )& 0xff , 
        Исходный_B = (_Цвет>> 16 )& 0xff ;        
         //-----------------------------------------------

   //-----------------------------------------------
   Components[ 0 ] = Исходный_R;
   Components[ 1 ] = Исходный_G;
   Components[ 2 ] = Исходный_B;
   //---------------------------
   ArraySort (Components);
   //---------------------------
   double Старшая_компонента         = Components[ 2 ]; 
   double Средняя_компонента         = Components[ 1 ]; 
   double Младшая_компонента         = Components[ 0 ]; 
//-----------------------------------------------
   double Координата_исходного_цвета=Старшая_компонента/ tan (( 63.43989 *pi)/ 180 )+Младшая_компонента/ 2 ;
//-----------------------------------------------
 //-----------------------------------------------
 if (Старшая_компонента == Исходный_R)R = ( color )Старшая_компонента;
 if (Старшая_компонента == Исходный_G)G = ( color )Старшая_компонента; 
 if (Старшая_компонента == Исходный_B)B = ( color )Старшая_компонента;     
 //------------------------
 if (Средняя_компонента == Исходный_R)R = ( color )Средняя_компонента;
 if (Средняя_компонента == Исходный_G)G = ( color )Средняя_компонента; 
 if (Средняя_компонента == Исходный_B)B = ( color )Средняя_компонента; 
 //------------------------
 if (Младшая_компонента == Исходный_R)R = ( color )Младшая_компонента;
 if (Младшая_компонента == Исходный_G)G = ( color )Младшая_компонента; 
 if (Младшая_компонента == Исходный_B)B = ( color )Младшая_компонента; 
 //------------------------------------------------
   
 //==========================================================================================
 if (Координата_исходного_цвета <= 127 )
   {
    Тангенс_угла_старшего_треугольника_1  = Старшая_компонента/Координата_исходного_цвета;
    Тангенс_угла_среднего_треугольника_1  = Средняя_компонента/Координата_исходного_цвета;     
    Тангенс_угла_младшего_треугольника_1  = Младшая_компонента/Координата_исходного_цвета;
     //-----------------------------------------------
    Значение_в_точке_преломления_старшей_компоненты  = Тангенс_угла_старшего_треугольника_1* 128 ;
    Значение_в_точке_преломления_средней_компоненты  = Тангенс_угла_среднего_треугольника_1* 128 ;
    Значение_в_точке_преломления_младшей_компоненты  = Тангенс_угла_младшего_треугольника_1* 128 ;    
     //-----------------------------------------------    
    Тангенс_угла_старшего_треугольника_2  = ( 255 - Значение_в_точке_преломления_старшей_компоненты)/ 128 ;
    Тангенс_угла_среднего_треугольника_2  = ( 255 - Значение_в_точке_преломления_средней_компоненты)/ 128 ;       
    Тангенс_угла_младшего_треугольника_2  = ( 255 - Значение_в_точке_преломления_младшей_компоненты)/ 128 ;
     //-----------------------------------------------    
     for ( int a1 = 0 ; a1 < 128 ; a1++)
      {
       Comp_1 = Тангенс_угла_старшего_треугольника_1*a1;
       Comp_2 = Тангенс_угла_среднего_треугольника_1*a1;
       Comp_3 = Тангенс_угла_младшего_треугольника_1*a1;
       //---------------------------------------------------
       if (Comp_1 > 255 )Comp_1 = 255 ;
       if (Comp_1 > 255 )Comp_2 = 255 ;
       if (Comp_1 > 255 )Comp_3 = 255 ;
       if (Comp_1 < 0 )Comp_1 = 0 ;
       if (Comp_2 < 0 )Comp_2 = 0 ;
       if (Comp_3 < 0 )Comp_3 = 0 ;           
       //---------------------------------------------------
       if (R == Старшая_компонента)Первая_компонента = Comp_1;
       if (R == Средняя_компонента)Первая_компонента = Comp_2;
       if (R == Младшая_компонента)Первая_компонента = Comp_3;
       //---------------------------------------------------
       if (G == Старшая_компонента)Вторая_компонента = Comp_1;
       if (G == Средняя_компонента)Вторая_компонента = Comp_2;
       if (G == Младшая_компонента)Вторая_компонента = Comp_3;
       //---------------------------------------------------
       if (B == Старшая_компонента)Третья_компонента = Comp_1;
       if (B == Средняя_компонента)Третья_компонента = Comp_2;
       if (B == Младшая_компонента)Третья_компонента = Comp_3;
       //---------------------------------------------------
       Все_оттенки[a1] = (( uint ) MathRound (Первая_компонента))|(( uint ) MathRound (Вторая_компонента)<< 8 )|(( uint ) MathRound (Третья_компонента)<< 16 );
       //---------------------------------------------------------------------------    
       w1++;
      }
     //------------------------------------------------------------------------------
     for ( int a2 = 255 ; a2 >= w1; a2--)
      {
       Comp_1 = 255 - Тангенс_угла_старшего_треугольника_2*q;
       Comp_2 = 255 - Тангенс_угла_среднего_треугольника_2*q;
       Comp_3 = 255 - Тангенс_угла_младшего_треугольника_2*q;
       //---------------------------------------------------
       if (Comp_1 > 255 )Comp_1 = 255 ;
       if (Comp_1 > 255 )Comp_2 = 255 ;
       if (Comp_1 > 255 )Comp_3 = 255 ;
       if (Comp_1 < 0 )Comp_1 = 0 ;
       if (Comp_2 < 0 )Comp_2 = 0 ;
       if (Comp_3 < 0 )Comp_3 = 0 ;           
       //---------------------------------------------------       
       if (R == Старшая_компонента)Первая_компонента = Comp_1;
       if (R == Средняя_компонента)Первая_компонента = Comp_2;
       if (R == Младшая_компонента)Первая_компонента = Comp_3;
       //---------------------------------------------------
       if (G == Старшая_компонента)Вторая_компонента = Comp_1;
       if (G == Средняя_компонента)Вторая_компонента = Comp_2;
       if (G == Младшая_компонента)Вторая_компонента = Comp_3;
       //---------------------------------------------------
       if (B == Старшая_компонента)Третья_компонента = Comp_1;
       if (B == Средняя_компонента)Третья_компонента = Comp_2;
       if (B == Младшая_компонента)Третья_компонента = Comp_3;
       //---------------------------------------------------
       Все_оттенки[a2] = (( uint ) MathRound (Первая_компонента))|(( uint ) MathRound (Вторая_компонента)<< 8 )|(( uint ) MathRound (Третья_компонента)<< 16 );
       //---------------------------------------------------------------------------
       q++;
      }
  } 
 //------------------------------------------------------------------------------
 if (Координата_исходного_цвета > 127 )
   {
    Тангенс_угла_старшего_треугольника_1  = ( 255 - Старшая_компонента)/( 255 - Координата_исходного_цвета);
    Тангенс_угла_среднего_треугольника_1  = ( 255 - Средняя_компонента)/( 255 - Координата_исходного_цвета);       
    Тангенс_угла_младшего_треугольника_1  = ( 255 - Младшая_компонента)/( 255 - Координата_исходного_цвета);
     //-----------------------------------------------
    Значение_в_точке_преломления_старшей_компоненты  = 255 - (Тангенс_угла_старшего_треугольника_1* 128 );
    Значение_в_точке_преломления_средней_компоненты  = 255 - (Тангенс_угла_среднего_треугольника_1* 128 );
    Значение_в_точке_преломления_младшей_компоненты  = 255 - (Тангенс_угла_младшего_треугольника_1* 128 );    
     //-----------------------------------------------    
    Тангенс_угла_старшего_треугольника_2  = Значение_в_точке_преломления_старшей_компоненты/ 128 ;
    Тангенс_угла_среднего_треугольника_2  = Значение_в_точке_преломления_средней_компоненты/ 128 ;      
    Тангенс_угла_младшего_треугольника_2  = Значение_в_точке_преломления_младшей_компоненты/ 128 ;
     //-----------------------------------------------    
     for ( int b1 = 0 ; b1 < 128 ; b1++)
      {
       Comp_1 = Тангенс_угла_старшего_треугольника_2*b1;
       Comp_2 = Тангенс_угла_среднего_треугольника_2*b1;
       Comp_3 = Тангенс_угла_младшего_треугольника_2*b1;
       //---------------------------------------------------
       if (Comp_1 > 255 )Comp_1 = 255 ;
       if (Comp_1 > 255 )Comp_2 = 255 ;
       if (Comp_1 > 255 )Comp_3 = 255 ;
       if (Comp_1 < 0 )Comp_1 = 0 ;
       if (Comp_2 < 0 )Comp_2 = 0 ;
       if (Comp_3 < 0 )Comp_3 = 0 ;           
       //---------------------------------------------------
       if (R == Старшая_компонента)Первая_компонента = Comp_1;
       if (R == Средняя_компонента)Первая_компонента = Comp_2;
       if (R == Младшая_компонента)Первая_компонента = Comp_3;
       //---------------------------------------------------
       if (G == Старшая_компонента)Вторая_компонента = Comp_1;
       if (G == Средняя_компонента)Вторая_компонента = Comp_2;
       if (G == Младшая_компонента)Вторая_компонента = Comp_3;
       //---------------------------------------------------
       if (B == Старшая_компонента)Третья_компонента = Comp_1;
       if (B == Средняя_компонента)Третья_компонента = Comp_2;
       if (B == Младшая_компонента)Третья_компонента = Comp_3;
       //---------------------------------------------------
       Все_оттенки[b1] = (( uint ) MathRound (Первая_компонента))|(( uint ) MathRound (Вторая_компонента)<< 8 )|(( uint ) MathRound (Третья_компонента)<< 16 );
       //---------------------------------------------------------------------------    
       w2++;
      }
     //------------------------------------------------------------------------------
     for ( int b2 = 255 ; b2 >= w2; b2--)
      {
       Comp_1 = 255 - Тангенс_угла_старшего_треугольника_1*q;
       Comp_2 = 255 - Тангенс_угла_среднего_треугольника_1*q;
       Comp_3 = 255 - Тангенс_угла_младшего_треугольника_1*q;
       //---------------------------------------------------
       if (Comp_1 > 255 )Comp_1 = 255 ;
       if (Comp_1 > 255 )Comp_2 = 255 ;
       if (Comp_1 > 255 )Comp_3 = 255 ;
       if (Comp_1 < 0 )Comp_1 = 0 ;
       if (Comp_2 < 0 )Comp_2 = 0 ;
       if (Comp_3 < 0 )Comp_3 = 0 ;           
       //---------------------------------------------------       
       if (R == Старшая_компонента)Первая_компонента = Comp_1;
       if (R == Средняя_компонента)Первая_компонента = Comp_2;
       if (R == Младшая_компонента)Первая_компонента = Comp_3;
       //---------------------------------------------------
       if (G == Старшая_компонента)Вторая_компонента = Comp_1;
       if (G == Средняя_компонента)Вторая_компонента = Comp_2;
       if (G == Младшая_компонента)Вторая_компонента = Comp_3;
       //---------------------------------------------------
       if (B == Старшая_компонента)Третья_компонента = Comp_1;
       if (B == Средняя_компонента)Третья_компонента = Comp_2;
       if (B == Младшая_компонента)Третья_компонента = Comp_3;
       //---------------------------------------------------
       Этот_цвет = (( uint ) MathRound (Первая_компонента))|(( uint ) MathRound (Вторая_компонента)<< 8 )|(( uint ) MathRound (Третья_компонента)<< 16 );
       //---------------------------------------------------------------------------    
       Все_оттенки[b2] = Этот_цвет; 
       //---------------------------------------------------------------------------
       q++;
      }
   }   
 //------------------------------------------------------------------------------  
}
//=============================================================================
 
Nikolai Semko:
Me has pillado, Andrew. :)
En realidad, es una tarea interesante conseguir una paleta de colores sin aglomeraciones y con una mínima distorsión del color. Obviamente, el delta entre los componentes del color no debe ser una constante y debe variar suavemente. En los ejemplos anteriores tiene dos valores: de negro y de blanco. Por eso se me quedó grabada.

Pues sí, 18 páginas están dedicadas exactamente a discutir el problema. Y ni una sola palabra sobre la POO, los nombres de las variables rusas y el futuro del autotrading).

 
Andrey Khatimlianskii:

Pues sí, se dedican 18 páginas a discutir el problema. Y ni una sola palabra sobre la POO, los nombres rusos de las variables y el futuro del autotrading )

Por qué, he hablado del cirílico varias veces sólo en este hilo. Pero Pedro es inquebrantable en el tema de la POO y el cirílico, que me he rendido y pienso que mi "engaño" sobre él ha terminado hasta que vea su código con sus propias clases sin cirílico y usando la depuración. Ya le he dicho repetidamente que sin OOP y estilo depurable (es decir, sin cirílico) la GUI nunca verá la luz, y si lo hace, será inmediatamente abucheada y lanzada con huevos podridos y tomates. Qué se le va a hacer, si Pedro con su fantástica persistencia y eficiencia (que logra escribir código sin el depurador) tiene el mismo fantástico grado de conservadurismo y terquedad.

Pero sin Pedro este foro no sería tan carismático. ))
 
TheXpert:

Probablemente será un poco más rápido así:

void Gradient(uint clr1,uint clr2,uint &arr[],uint size)
  {
   if(size==0) return;
   ArrayResize(arr,size);
   arr[0]=clr1; 
   rgb c1,c2;
   c1.clr=clr1;
   c2.clr=clr2;
   double R1=c1.c[2],G1=c1.c[1],B1=c1.c[0];
   double R2=c2.c[2],G2=c2.c[1],B2=c2.c[0];
   double deltaR=(R2-R1)/(size-1);
   double deltaG=(G2-G1)/(size-1);
   double deltaB=(B2-B1)/(size-1);
   R1 += 0.4999;
   G1 += 0.4999;
   B1 += 0.4999;
   for(uint i=1;i<size;i++)
     {
      R1+=deltaR; c1.c[2]=uchar (R1);
      G1+=deltaG; c1.c[1]=uchar (G1);
      B1+=deltaB; c1.c[0]=uchar (B1);
      arr[i]=c1.clr;
     }
  }

Estoy de acuerdo.

 
Nikolai Semko:

Estoy de acuerdo.

Nikolai, seamos objetivos.

Al eliminar el dibujo que es irrelevante en esta prueba, simplifiqué al máximo el guión y revelé las siguientes discrepancias:

Como puede ver, el centro de la gama de colores en su algoritmo se desplaza hacia arriba. La banda más brillante debe estar en el centro. Así lo confirma la paleta de Windows:


A continuación, adjunto un script para hacer pruebas:

Archivos adjuntos:
 

La casilla 127 es el centro del conjunto de sombras. En esta celda, debe ser del mismo color que en la paleta. Yo tengo un margen de error de 1, tú tienes 63.

El desenfoque y el sobrepintado me impidieron concentrarme en verificar que el algoritmo funcionaba correctamente. Por eso he sugerido que se coteje con la impresión en Alerta.

SZY. En realidad, el centro de la matriz es la celda 128, pero eso no cambia la esencia.
 

Nuevos datos de interés:

  • Color azul - C'0,0,255'

  • Color gris - C'128,128,128' (ambos son iguales)

  • Color - C'128,64,0' (gran diferencia)



No te ofendas Nikolai, pero tu algoritmo es más rápido y más corto (hecho), pero funciona incorrectamente (también hecho). Carece de un marco conceptual bien pensado.

A mi algoritmo originalmente le faltaba velocidad (pero tú ayudaste) y depuración. Al mismo tiempo, tenía un concepto bien pensado y correcto desde el principio.

Por eso hay tanta diferencia.