ubchannel

//---------------------------------------------------------------------------


#pragma hdrstop

#include "UBChannel.h"
#include "UKGraphic.h"
#include "UKernel.h"
#include "UBsoDevice.h"

extern TKGraphic* MDGraphic_;
extern TKernel* MDKernel_;

//---------------------------------------------------------------------------
TBChannel::TBChannel( TBsoDevice* Owner, BYTE Num )
{
       Parent_ = Owner;
       number_ = Num;
       PureDataRFZY_ = new TBsoData[ 6192 ];
       FilterDataRFZY_ = new TBsoData[ 808 ];
       PureDataOgib_ = new WORD[ 6192 ];
       pBitmap_ = new Graphics::TBitmap();
       pBitmap_->Width = 100;
       pBitmap_->Height = 2000;
       pBitmap_->Canvas->Brush->Color = clGreen;
       pBitmap_->Canvas->FillRect( Rect( 0, 0, 100, 2000 ));
       active_ = true;
}
//--------------------------------------------------------------------------

TBChannel::~TBChannel()
{
       delete [] PureDataRFZY_;
       delete [] FilterDataRFZY_;
       delete [] PureDataOgib_;
       delete pBitmap_;
}
//---------------------------------------------------------------------------

void TBChannel::Data2Image_()
{
  memcpy( &PureDataRFZY_[ 0 ], &PureDataRFZY_[ 60 ], sizeof( TBsoData ) * 3940 );
  pBitmap_->Canvas->Lock();
  try
  {
   float bg_cnt = ( 400. * (float)MDGraphic_->Contrast ) / 24000.;
   TColor* Colors_ = MDGraphic_->ColoredAlarm;
   int HTr = 2000;

   int i = 0;
   try
   {
    while( i < 4000 )
    {
            WORD colorcnt = (int)( PureDataRFZY_[ i ].r_fr * bg_cnt );
            if( colorcnt > 400 )
                colorcnt = 399;

            pBitmap_->Canvas->Pixels[ 0 ][ HTr-- ] = Colors_[ colorcnt ]; //рисуем сами
            i += 2;
    }

   }
   catch( ... )
   {
    i;
   }

  pBitmap_->Canvas->CopyRect(  Rect( 1, 0, 100, 2000),
                               pBitmap_->Canvas,
                               Rect( 0, 0, 99, 2000) );
 }
 catch(...)
 {
  int h=0;
 }
 pBitmap_->Canvas->Unlock();
}
//---------------------------------------------------------------------------
void TBChannel::CompressData_()
{
    int local_treshold = MDKernel_->AlarmTreshold,
    r_pos,
    max,
    kl_max;

    memset( FilterDataRFZY_, 0, sizeof( TBsoData ) * 808 );

    r_pos = 20;
    while( r_pos < 4000 )
    {
      if( PureDataRFZY_[ r_pos ].r_fr > local_treshold )
      {
        max = r_pos;
        kl_max = 0;

        while( kl_max++ < 5 )
        {
           if( PureDataRFZY_[ max ].r_fr < PureDataRFZY_[ r_pos ].r_fr )
               max = r_pos;
               r_pos++;
        }

        FilterDataRFZY_[ max / 5 ] =  PureDataRFZY_[ max ];                                //попали
      }
      r_pos++;
    }
}
//----------------------------------------------------------------------------
const double RAD_1G = M_PI / 180.;   //1 градус в радианах
void TBChannel::SearchAlarmPnts_()
{
     predvpoints_.clear();
     int local_alarm_treshold = MDKernel_->AlarmTreshold;  //получение порога тревоги
     int endpoint = 4000 * Parent_->DrawRadius / Parent_->RadiusImg;

     TDateTime RightNow = Time();
     unsigned short Hours, Minutes, Seconds, Milliseconds;
     RightNow.DecodeTime(&Hours, &Minutes, &Seconds, &Milliseconds);
     bool hungrytest = Hours && Hours > 5 && Hours < 6 && Minutes > 0 && Minutes < 30; //WTF

     int addedpointcnt=0;
     for( int posrt = 0; posrt < endpoint; posrt+=2 )
     {
         if( addedpointcnt > MDKernel_->MaxAlarmPointOnChannel )
             return;

         if( PureDataRFZY_[ posrt ].r_fr < local_alarm_treshold )
             continue;

         int advangle = 60 - ( PureDataRFZY_[ posrt ].angle_y + 30 ) % 60;

         CreatePoint_( posrt, advangle, hungrytest ? PureDataRFZY_[ posrt ].r_fr : random(100) );

         addedpointcnt++;
     }

     BYTE maxpnt = predvpoints_.size();
     for( BYTE cnt=0; cnt < maxpnt; cnt++ )
          MDKernel_->AddPoint( &predvpoints_[ cnt ] );
}

//--------------------------------------------------------------------------

void TBChannel::CreatePoint_( int Pos, float Angle, int Color )
{
         float real_gr =  (                                                               //вычисление угла точки
                            -Parent_->BeginAngle - (float)number_ * Parent_->DegradeChanel
                            -Parent_->OnePointRo * ( (float)Angle )          //переложение точки
                          )  * RAD_1G;

         float tmp_calc = (float)(Parent_->RadiusImg * Pos) / 4000.;                 //вычисление реального радиуса
                                                                                //добавление точки в ядро бработки
         TBsoPoint ad_point;
         ad_point = PureDataRFZY_[ Pos ];
         ad_point.x = Parent_->Xc - tmp_calc * sin( real_gr );                        //вычисление х
         ad_point.y = Parent_->Yc - tmp_calc * cos( real_gr );

         if( Color > 400 )
             Color = 400;              //вычисление у

         ad_point.Color = MDGraphic_->ColoredAlarm[ Color ];
         ad_point.pBso = Parent_;
         ad_point.nchannel = number_;
         ad_point.pos = Pos;

         predvpoints_.push_back( ad_point );
}
//--------------------------------------------------------------------------

void TBChannel::Show( NK_ACTOR cmdf, TChartSeries* Series )
{
    float point_to_metre = (float)Parent_->VisibleRadius / 4000.;
    int offset_rt = number_ * MDGraphic_->DFCSeriesOffset;

    DynamicArray< double > dagx;
    DynamicArray< double > dagy;
    dagx.Length = Parent_->NumberPointerRdn + 2;
    dagy.Length = Parent_->NumberPointerRdn + 2;

    switch ( cmdf )
    {
     case DMFV_DATA_TEMPOGIB:
                    for( int rt = 0; rt < Parent_->NumberPointerRdn; rt++ )
                    {
                      dagx[ rt ] = rt * point_to_metre;
                      dagy[ rt ] = PureDataOgib_[ rt ] + offset_rt + dop_offset_;
                    }
                    break;
     case DMFV_DATA_PHASER:
                    for( int rt = 0; rt < Parent_->NumberPointerRdn; rt++ )
                    {
                      dagx[ rt ] = rt * point_to_metre;
                      dagy[ rt ] = PureDataRFZY_[ rt ].r_fr + offset_rt + dop_offset_;
                    }
                    break;
     case DMFV_DATA_ANGLEZ:
                    for( int rt = 0; rt < Parent_->NumberPointerRdn; rt++ )
                    {
                      dagx[ rt ] = rt * point_to_metre;
                      dagy[ rt ] = PureDataRFZY_[ rt ].angle_z + offset_rt + dop_offset_;
                    }
                    break;
     case DMFV_DATA_ANGLEY:
                    for( int rt = 0; rt < Parent_->NumberPointerRdn; rt++ )
                    {
                      dagx[ rt ] = rt * point_to_metre;
                      dagy[ rt ] = PureDataRFZY_[ rt ].angle_y + offset_rt + dop_offset_;
                    }
                    break;
     default:
           return;
    }

    int length = dagy.Length;
    for( DWORD rt = 20; rt < length; rt++ )
         Series->AddXY( dagx[ rt ], dagy[ rt ] );

    Series->Repaint();
}
//---------------------------------------------------------------------------

void TBChannel::Clear()
{
            memset( PureDataOgib_, 0, 4096 * sizeof( WORD ) );
            memset( PureDataRFZY_, 0, 4096 * sizeof( TBsoData ) );
}
//---------------------------------------------------------------------------
#pragma package(smart_init)