Único valor atual no gráfico. Como não deixar resúduos?

[AnarcoPhysic]

Boa fim de semana, pessoal.

Estou com uma dúvida. Quero ter no gráfico, somente o dado presente. Como deleto algo com POINTER_AUTOMATIC, já que de outra forma não tem jeito (pois quero deletar o último valor determinado plotado (times and series)  (e não fazê-lo zero somente).

Abaixo, a cópia da tranqueira que estou construindo.

Agradeço, desde já, qualquer ajuda!

//+------------------------------------------------------------------+
//|                                                Ponto Estrela.mq5 |
//|                                                  Daniel Bandeira |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Daniel Bandeira"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
//--- plot PonntoEstrela
#property indicator_label1  "PonntoEstrela"
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrYellow
#property indicator_width1  1
//--- input parameters
input int      PontoMeio = 4; // Seleciona candle de referencia. 1, é o candle anterior ao atual. 2, o anterior a este. 3, o anterior do anterior...
input bool     ValorPresente = false; //Considerar Candle atual?
int            BotaoValorPresente = 1; // modificador em função da pergunta acima
static double         PontoEstrela[]; // dado que quero plotar. Gostaria que todos os outros dados antigos fossem anulados (sem acúmulo de dado)
int bars=0;
double ValorPonderado[][2]; // constrói arranjo/tabela de interesse
double PontoEstrelaP; // dado auxiliar. Pretendo removê-lo, mas é ainda de ajuda para detectar erros
//--- indicator buffers


// calcula preço ponderado (eu sei que existe função pronta para isso)
double PrecoPonderado (double Open, double Close, double Low, double High)

       { return (Open+Close+Low+High)/4 ; }
// (Módulo... também sei )
double  DifAbsoluta (double x, double y) 
   {
   
         if ( x >= y ) { return x-y; }
          else { return y-x;} 
    }
//Função para ver valor e avaliar sua realidade. Conta a quantidade de vez que foi chamada
 void Bisbilhotar(double Numero_a_escrever,string NAME) 

   { static int X = 1; Print("Valor Testado para "+NAME+": "+DoubleToString(Numero_a_escrever,2)+". "+
                                                                              IntegerToString(X)+"º vez executado"); X++; return;}
   


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
  
   Print("TESTE INICIAL:");
    
   if(PontoMeio<1)
     {
          
      Print("Valor Incoerente para Ponto do Meio. Programado forçado a parar!");
      
      return(0); //Na verdade, queria para o programa, mas não achei o recurso. Já já olho isso com calma
           
     }
     
         
     if (ValorPresente) BotaoValorPresente = 0;
    
     ArrayResize(ValorPonderado,PontoMeio-BotaoValorPresente); // define tamanho da "TABELA"
     
     Print("Isto é um array dinâmico = ",ArrayIsDynamic(ValorPonderado) ? "Sim" : "Não"); 
			//Queria ter certeza... nunca usei isso antes (Array dinâmico) ela não deixa de ser dinâmica
 
//--- indicator buffers mapping
   SetIndexBuffer(0,PontoEstrela,INDICATOR_DATA);
   PlotIndexSetInteger(0,PLOT_ARROW,115);
  if( PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0)) Print("Tudo Zerado. Podem começar!!!");
   
  Print("FIM DO TESTE INICIAL.");
//---
   return(INIT_SUCCEEDED);

  }
    
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---

    
      if (bars < rates_total)
       
       {    
		bars = rates_total;
              
                            ArraySetAsSeries(open,true);  ArraySetAsSeries(high,true) ;
              ArraySetAsSeries(low,true);  ArraySetAsSeries(close,true); ArraySetAsSeries(PontoEstrela,true);
              
         
      //VP[x][0] para os valores posteriores (temporal) ao PontoMeio e VP[x][1] para o valores anteriores.
// Quanto mais longe do valor de referencia, maior é o índice x.
	
   
         //coloca valores nos dados ulteriores a referencia
     
              for(int k= PontoMeio-1; k> BotaoValorPresente-1; k--) 
                  {
                          ValorPonderado[PontoMeio-1-k][0] = PrecoPonderado (open[k],  close[k],  low[k],  high[k]);
                  } 
           //coloca valores nos dados anteriores a referencia

               for(int p = PontoMeio+1; p < PontoMeio*2+1-BotaoValorPresente; p++) 
                  {
                            ValorPonderado[p-PontoMeio-1][1] = PrecoPonderado ( open[p],  close[p],  low[p],  high[p]);
                  } 
     
     // escreve valores do array! A primeira vez que escreve, falha. Com um novo tick, reescreve bem. POR QUE
     for(int b=0;b<PontoMeio-BotaoValorPresente;b++)
       {
        
        for(int a=0;a<2;a++)
          {
           
           Print( "Valor na tabela em ("+IntegerToString(b)+"),("+IntegerToString(a)+") ="
                                                                   +DoubleToString(ValorPonderado[b][a])+"."); 
           
          }
        
       }
     
     
           
   
    // queria ter na tela SOMENTE o valor ATUAL! Mas assim, acabo preenchendo o dado anterior sem deletá-lo pra valer. Alguma sugestão?
  // sobre o calulo em si do "estrela" (VALOR ATUAL), achei que não valesse a pena colocar aqui, já que não tenho dúvida por isso. (até porque é meio criação)
PontoEstrela[1] = EMPTY_VALUE;
     
    
     
   } 
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+