ukernel

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

#include <vcl.h>
#pragma hdrstop

#include "UKernel.h"
#include "UBsoDevice.h"
#include "UMainForm.h"
#include "math.h"
#include "stdio.h"
#include "stdlib.h"
#include "UOption.h"
#include "UVector.h"
#include "UMainData.h"
#include "UKGraphic.h"
#include "RzBmpBtn.hpp"
#include "UdebugMessage.h"
#include "UFormular.h"
#pragma package(smart_init)

extern TVaultMainData* MainData;
extern TKGraphic* MDGraphic_;
extern LPBsoConnect MDConnect_;
//---------------------------------------------------------------------------
__fastcall TKernel::TKernel()
{
 InitializeCriticalSection( &csDataAccess );

 array_alpnt.push_back();
 array_alpnt[ 0 ].clear();

 array_viewpoint_.push_back();
 array_viewpoint_[ 0 ].clear();

 VisibleAr[ 0 ] = true;   targtmpar[ 0 ] = &visible_targets_;
 VisibleAr[ 1 ] = false;  targtmpar[ 1 ] = &targets_;
 VisibleAr[ 2 ] = true;  targtmpar[ 2 ] = &lost_targets_;
 target_number_ = 0;
}
//---------------------------------------------------------------------------

void __fastcall TKernel::ClearPointArray()
{
 EnterCriticalSection( &csDataAccess );
 try
 {
  for( int tr=0; tr < (int)array_alpnt.size(); tr++ )
       array_alpnt[ tr ].clear();

  for( int cnt=0; cnt < (int)array_viewpoint_.size(); cnt++ )
       array_viewpoint_[ cnt ].clear();

  array_viewpoint_.clear();
  array_viewpoint_.push_back();
 }
 catch(...)
 {}
 LeaveCriticalSection( &csDataAccess );
}
//---------------------------------------------------------------------------
void __fastcall TKernel::ResetAlarmTrass()
{
 EnterCriticalSection( &csDataAccess );

 try
 {
    for( int k=0; k < targets_.size(); k++ )
         delete targets_[ k ];

    targets_.clear();

    for( int k=0; k < lost_targets_.size(); k++ )
         delete lost_targets_[ k ];
    lost_targets_.clear();

    for( int k=0; k < visible_targets_.size(); k++ )
         delete visible_targets_[ k ];

    visible_targets_.clear();
 }
 catch( ... )
 {}
 LeaveCriticalSection( &csDataAccess );
}
//---------------------------------------------------------------------------

int __fastcall TKernel::AddPoint( LPBsoPoint point_a )
{
 try
 {
  EnterCriticalSection( &csDataAccess );

  TBsoPoint ad_pnt = *point_a;
  ad_pnt.LevelContrast = 255;
  ad_pnt.time_birth = Now();
  ad_pnt.usingp = false;

  array_alpnt[0].push_back( ad_pnt );
  array_viewpoint_[0].push_back( ad_pnt );
 }
 __finally
 {
  LeaveCriticalSection( &csDataAccess );
 }

 return 1;
}
//---------------------------------------------------------------------------

void __fastcall TKernel::SetUsingPointStatus_( PUS_STATUS new_status )
{
 int n_ar, n_pnt;
 try
 {
  for( n_ar=0; n_ar < (int)array_alpnt.size(); n_ar++ )
   for( n_pnt=0; n_pnt < (int)array_alpnt[ n_ar ].size(); n_pnt++ )
     if( array_alpnt[ n_ar ][ n_pnt ].usingp )
     switch( new_status )
     {
      case PUS_DELETE:
                     try
                     {
                      array_alpnt[ n_ar ].erase( array_alpnt[ n_ar ].begin() + n_pnt );
                      n_pnt--;
                     }
                     catch( ... )
                     {
                       MainData->LogMessage( &TDebugMessage( "Deleting point failed", MDF_WORK | MDF_KERNEL | MDF_PNTACTION, __FILE__, __LINE__ ) );
                     }
                     break;

      case PUS_NOUSING:
                      array_alpnt[ n_ar ][ n_pnt ].usingp = false;
                      break;
     }
 }
 catch( ... )
 {
  //AnsiString dd;
  //dd.sprintf( "CHECK RANGE FAILED N_AR=%d N_PNT=%d MAX_AR=%d MAX_PNT=%d", n_ar, n_pnt, array_alpnt.size(), array_alpnt[ n_ar ].size() );
  //MainData->LogMessage( new TDebugMessage( dd, MDF_WORK | MDF_KERNEL | MDF_PNTACTION, __FILE__, __LINE__) );
 }
}
//---------------------------------------------------------------------------

LPBsoPoint __fastcall TKernel::GetMinimumLengthPoint_( LPBsoPoint cur_point, double MaxRadius )
{
 double min_radius = MaxRadius;
 LPBsoPoint res_point = NULL;
 for( int n_ar=0; n_ar < (int)array_alpnt.size(); n_ar++ )
  for( int n_pnt=0; n_pnt < (int)array_alpnt[ n_ar ].size(); n_pnt++ )
    if( !array_alpnt[ n_ar ][ n_pnt ].usingp )
    {
     double radius = hypot( cur_point->x - array_alpnt[ n_ar ][ n_pnt ].x,
                            cur_point->y - array_alpnt[ n_ar ][ n_pnt ].y );

     if( radius > 0.2 && radius < min_radius )
     {
         min_radius = radius;
         res_point = &array_alpnt[ n_ar ][ n_pnt ];
     }
    }

 return res_point;
}
//---------------------------------------------------------------------------

void __fastcall TKernel::TryAddPointFront_( LPTarget pTarget, BYTE NumAr )
{
 deque< int > number_adding_points_;
 while( true )
 {
    double minlen = pTarget->MiddleSpeed * 1.5;

    double targlen = hypot( pTarget->Points[ FIRST_POINT ].x - pTarget->Points[ AIMING_POINT ].x,
                            pTarget->Points[ FIRST_POINT ].y - pTarget->Points[ AIMING_POINT ].y );//запоминаем длину между начальной и временной конечной точкой цели

    number_adding_points_.clear();
    for( int cnt=0; cnt < (int)array_alpnt[ NumAr ].size(); cnt++ ) //для всех точек массива
    {
     if( array_alpnt[ NumAr ][ cnt ].usingp )
         continue;

     double len = hypot( pTarget->Points[ FIRST_POINT ].x - array_alpnt[ NumAr ][ cnt ].x,
                         pTarget->Points[ FIRST_POINT ].y - array_alpnt[ NumAr ][ cnt ].y );//высчитываем приращение

     if( len > minlen * 0.2 && len < minlen ) //если приращение находится в допустимых пределах
     {
         double addlen = hypot( pTarget->Points[ AIMING_POINT ].x - array_alpnt[ NumAr ][ cnt ].x,
                                pTarget->Points[ AIMING_POINT ].y - array_alpnt[ NumAr ][ cnt ].y ); //высчитываем длину между временной конечной точкой и точкой приращения

         if( addlen > targlen ) //проверяем вектор приращения, дожен быть положительным
         {
          number_adding_points_.push_back( cnt );   //запоминаем положение точки с минимальным радиусом
          minlen = len;
          array_alpnt[ NumAr ][ cnt ].usingp = true;
         }
     }
    }

    if( number_adding_points_.size() == 0 )
        return;

    double minangl = M_PI;
    int savecnt=-1;
    int arsize = number_adding_points_.size();
    for( int pntcnt=0; pntcnt < arsize; pntcnt++ )
    {
     int numpnt = number_adding_points_[ pntcnt ];
     double angl = AngleBtwnLine( &array_alpnt[ NumAr ][ numpnt ], &( pTarget->Points[ FIRST_POINT ] ), &( pTarget->Points[ AIMING_POINT ] ) );
     if( angl < minangl )
     {
       minangl = angl;
       savecnt = numpnt;
     }
    }

    if( minangl < M_PI / 4 )
    {
        pTarget->Points[ NEW_POINT ] = array_alpnt[ NumAr ][ savecnt ];

        {
         int arsize = number_adding_points_.size();
         for( int pntcnt=0; pntcnt < arsize; pntcnt++ )
              array_alpnt[ NumAr ][ number_adding_points_[ pntcnt ] ].usingp = false;
        }

        array_alpnt[ NumAr ][ savecnt ].usingp = true;
    }
  }
}
//---------------------------------------------------------------------------

bool __fastcall TKernel::DeleteTarget_( DQ_LPTarget &lptargets, LPTarget del_targ )
{
 for( int rtarg=0; rtarg  < (int)lptargets.size(); rtarg++ )
   if( lptargets[ rtarg ] == del_targ )
   {
       lptargets.erase( lptargets.begin() + rtarg );
       return true;
   }

 return false;
}
//---------------------------------------------------------------------------
void __fastcall TKernel::DeleteNearPoints_( LPTarget val_target )
{
 int rad = ( val_target->Status == ST_VISIBLE ) ? 9 : 5;
 for( int nof_pnt=0; nof_pnt < val_target->OffsetEndPoint-1; nof_pnt++ )
 {
   TBsoPoint tmp_pnt = val_target->Points[ nof_pnt ];
   for( int nar=1; nar < (int)array_alpnt.size(); nar++ )
    for( int nom_pnt=0; nom_pnt < (int)array_alpnt[ nar ].size(); nom_pnt++ )
    if( hypot( tmp_pnt.x - array_alpnt[ nar ][ nom_pnt ].x,
               tmp_pnt.y - array_alpnt[ nar ][ nom_pnt ].y ) < rad )
    {
        array_alpnt[ nar ].erase( array_alpnt[ nar ].begin() + nom_pnt );
        nom_pnt--;
    }
 }
}
//---------------------------------------------------------------------------

void __fastcall TKernel::AlgoritmGrowingTargets_( DQ_LPTarget &lptargets )
{
 for( int ntarg=0; ntarg < (int)lptargets.size(); ntarg++ )
 {
  LPTarget tmp_targ = lptargets[ ntarg ];
  tmp_targ->NewCicle();

  if( tmp_targ->Status == ST_LOST )  //цель потеряна
  {
   if( tmp_targ->PointNumber < 15 )  //цель не дотянула до обнаруженной
       delete tmp_targ;                                    //удалить из памяти
   else
   {
       lost_targets_.push_front( tmp_targ );               //цель была в обработке, поместим её в массив потерянных целей
       MainData->Action( DMSA_SEND_TARGET_COM, (char*)tmp_targ );
       tmp_targ->SaveToFile();
   }

   lptargets.erase( lptargets.begin() + ntarg );           //удалим цель из текущего массива
   ntarg--;                                                //сместимся на шаг назад
   continue;                                               //обработка для следующей цели
  }

  //обработка для текущей цели по пришедшим точкам
  if( tmp_targ->PointNumber > 0 )
  {
   int lastpntnum = tmp_targ->PointNumber;
   BYTE right_ar = 0;

   while( true )
   {
     tmp_targ += array_alpnt[ right_ar ];
     if( lastpntnum == tmp_targ->PointNumber && right_ar < 8 )
     {
      right_ar++;
     }
     else
     {
      array_alpnt[ right_ar ] -= tmp_targ;
      break;
     }
   }

   if( tmp_targ->MiddleSpeed / 4. > 4 )
   {
    lptargets.erase( lptargets.begin() + ntarg );
    delete tmp_targ;
   }
   else
   if( tmp_targ->Status == ST_READY )
   {
    lptargets.erase( lptargets.begin() + ntarg );
    visible_targets_.push_back( tmp_targ );
    tmp_targ->Status = ST_VISIBLE;
    tmp_targ->Number = ++target_number_;

    MainData->AlarmSound = true;
   }
  }
 }
}
//---------------------------------------------------------------------------

void __fastcall TKernel::UpdateTargetCom_()
{
  for( WORD nk=0; nk < (int)visible_targets_.size(); nk++ )
    if( visible_targets_[ nk ]->MissedCicle < 2 )
       MainData->Action( DMSA_SEND_TARGET_COM, (char*)visible_targets_[ nk ] );
}
//---------------------------------------------------------------------------

void __fastcall TKernel::ShowInformationOnGrid_()
{
 int rt=0;
 for( BYTE n_check=0; n_check < 3; n_check++ )
 {
  if( !VisibleAr[ n_check ] )
      continue;

  DQ_LPTarget &lptargets = *targtmpar[ n_check ];

  try
  {
   for( WORD nk=0; nk < (int)lptargets.size(); nk++ )
   {
    FFormular->rzFormular->Objects[ 0 ][ rt+1 ] = (TObject*)lptargets[ nk ];

    MDGraphic_->Show( lptargets[ nk ] );
    rt++;
   }
  }
  catch(...)
  {

  }
 }

 FFormular->rzFormular->RowCount = rt+1;

 if( array_alpnt.size() > 2 )
 {
     MainForm->imgClock->Canvas->Lock();
     try
     {
      AnsiString text = "";
      text.sprintf( "Точек %d/%d/%d       ", array_alpnt[ 0 ].size(),
                                            array_alpnt[ 1 ].size(),
                                            array_alpnt[ 2 ].size() );
      MainForm->imgClock->Canvas->TextOutA( 10, 55, text );

      text.sprintf( "Целей %d/%d/%d       ", targtmpar[ 0 ]->size(),
                                            targtmpar[ 1 ]->size(),
                                            targtmpar[ 2 ]->size() );
      MainForm->imgClock->Canvas->TextOutA( 10, 70, text );
     }
     __finally
     {
      MainForm->imgClock->Canvas->Unlock();
     }

 }
}
//---------------------------------------------------------------------------
void __fastcall TKernel::DeleteOldTarget( TTarget* ptarg )
{
 try
 {
  if( ptarg != NULL && ptarg->Status == ST_LOST )
  {
     DeleteTarget_( lost_targets_, ptarg );
     delete ptarg;
  }
 }
 catch(...)
 {

 }
}
//---------------------------------------------------------------------------

LPTarget __fastcall TKernel::GetTargetByColor( TColor Color )
{
 for( BYTE n_check=0; n_check < 3; n_check++ )
 {
  if( !VisibleAr[ n_check ] )
      continue;

  DQ_LPTarget &lptargets = *targtmpar[ n_check ];

  for( WORD nk=0; nk < (int)lptargets.size(); nk++ )
    if( lptargets[ nk ]->Color == Color )
        return lptargets[ nk ];
 }

 return NULL;
}
//---------------------------------------------------------------------------

void __fastcall TKernel::CheckVisibleArrayClick( TObject* Sender )
{
  TRzBmpButton* btnh = dynamic_cast< TRzBmpButton* >( Sender );
  VisibleAr[ btnh->Tag ] = !VisibleAr[ btnh->Tag ];
  btnh->Down = VisibleAr[ btnh->Tag ];
}
//---------------------------------------------------------------------------

void __fastcall TKernel::Process_alarm_points_()
{
 MDGraphic_->ClearPlane();

 int nk = 1;

 try
 {
  AlgoritmGrowingTargets_( visible_targets_ );

  AlgoritmGrowingTargets_( targets_ );
 }
 catch(...)
 {
  //int h=0;
 }

 try
 {
  AlgoritmAiming_();
 }
 catch(...)
 {}

 try
 {
  ShowInformationOnGrid_();
 }
 catch(...)
 {}

 try
 {
  UpdateTargetCom_();
 }
 catch(...)
 {}

 ShiftArray( array_alpnt, 15 );

 ShiftArray( array_viewpoint_, 700 );
}
//---------------------------------------------------------------------------

void __fastcall TKernel::ShiftArray( DQ_DQTBPS &lparray, BYTE Step )
{
  if( (int)lparray.size() == Step )
  {
      lparray[ Step - 1 ].clear();
      lparray.pop_back();
  }

  lparray.push_front();
  lparray[ 0 ].clear();
}
//---------------------------------------------------------------------------

int __fastcall TKernel::ClearFirstArray_()
{
   int nompnt = 0;
   for( int k=0; k < (int)array_alpnt[ 0 ].size(); k++ )
    for( int kk=k+1; kk < (int)array_alpnt[ 0 ].size(); kk++ )
     if( hypot( array_alpnt[ 0 ][ k ].x - array_alpnt[ 0 ][ kk ].x,
                array_alpnt[ 0 ][ k ].y - array_alpnt[ 0 ][ kk ].y ) < 0.15 )
     {
         array_alpnt[ 0 ][ k ].x = ( array_alpnt[ 0 ][ k ].x + array_alpnt[ 0 ][ kk ].x ) / 2;
         array_alpnt[ 0 ][ k ].y = ( array_alpnt[ 0 ][ k ].y + array_alpnt[ 0 ][ kk ].y ) / 2;
         if( array_alpnt[ 0 ][ k ].r_fr < array_alpnt[ 0 ][ kk ].r_fr )
             array_alpnt[ 0 ][ k ].Color = array_alpnt[ 0 ][ kk ].Color;
         array_alpnt[ 0 ].erase( array_alpnt[ 0 ].begin() + kk );
         nompnt++;
     }

   return nompnt;
}
//---------------------------------------------------------------------------

void __fastcall TKernel::Execute()
{
   try
   {
    if( MDConnect_->CicleCounter > 30 )
        Process_alarm_points_();
   }
   catch(...)
   {
   // MainData->LogMessage( new TDebugMessage( "Process_alarm_points FAILED", MDF_WORK | MDF_KERNEL, __FILE__, __LINE__) );
   }

   try
   {
     //MDGraphic_->Show( array_alpnt );
     MDGraphic_->Show( array_viewpoint_ );
   }
   catch(...)
   {
    //MainData->LogMessage( new TDebugMessage( "Show( Array_viewpoint_ ) FAILED", MDF_WORK | MDF_KERNEL, __FILE__, __LINE__) );
   }
}
//---------------------------------------------------------------------------

void __fastcall TKernel::AlgoritmAiming_() //алгоритм обнаружения
{
 if( array_alpnt.size() == 15 && targets_.size() < 20 )
 {
  for( int nom_point = 0; nom_point < (int)array_alpnt[ 14 ].size(); nom_point++ )         //поиск от первой точки в рабочем массиве точек
  {
   TTarget new_target(0);// = new TTarget( 0 );                  //выделяем память для новой цели

   try
   {
    new_target.Points[ NEW_POINT ] = array_alpnt[ 14 ][ nom_point ];      //ставим начальную точку
    array_alpnt[ 14 ][ nom_point ].usingp = true;
   }
   catch(...)
   {
    //int h=0;
   }

   LPBsoPoint secondpnt = GetMinimumLengthPoint_( &( new_target.Points[ FIRST_POINT ] ), 20 );
   if( secondpnt != NULL )
       new_target.Points[ NEW_POINT ] = *secondpnt;
   else
       continue;

   int tmpar = array_alpnt.size() - 1;
   while( tmpar >= 0 )
   {
           TryAddPointFront_( &new_target, tmpar );
           tmpar--;
   }

   if( new_target.Status == ST_NEW )
   {
        new_target.Visible = true;
        MDGraphic_->Show( &new_target );

        targets_.push_back( new TTarget( new_target ) );
        SetUsingPointStatus_( PUS_DELETE );
        DeleteNearPoints_( &new_target );
        continue;
   }

   SetUsingPointStatus_( PUS_NOUSING );
  }
 }
}
//---------------------------------------------------------------------------