SHARE
TWEET

ukernel

a guest Dec 15th, 2015 15,000 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //---------------------------------------------------------------------------
  2.  
  3. #include <vcl.h>
  4. #pragma hdrstop
  5.  
  6. #include "UKernel.h"
  7. #include "UBsoDevice.h"
  8. #include "UMainForm.h"
  9. #include "math.h"
  10. #include "stdio.h"
  11. #include "stdlib.h"
  12. #include "UOption.h"
  13. #include "UVector.h"
  14. #include "UMainData.h"
  15. #include "UKGraphic.h"
  16. #include "RzBmpBtn.hpp"
  17. #include "UdebugMessage.h"
  18. #include "UFormular.h"
  19. #pragma package(smart_init)
  20.  
  21. extern TVaultMainData* MainData;
  22. extern TKGraphic* MDGraphic_;
  23. extern LPBsoConnect MDConnect_;
  24. //---------------------------------------------------------------------------
  25. __fastcall TKernel::TKernel()
  26. {
  27.  InitializeCriticalSection( &csDataAccess );
  28.  
  29.  array_alpnt.push_back();
  30.  array_alpnt[ 0 ].clear();
  31.  
  32.  array_viewpoint_.push_back();
  33.  array_viewpoint_[ 0 ].clear();
  34.  
  35.  VisibleAr[ 0 ] = true;   targtmpar[ 0 ] = &visible_targets_;
  36.  VisibleAr[ 1 ] = false;  targtmpar[ 1 ] = &targets_;
  37.  VisibleAr[ 2 ] = true;  targtmpar[ 2 ] = &lost_targets_;
  38.  target_number_ = 0;
  39. }
  40. //---------------------------------------------------------------------------
  41.  
  42. void __fastcall TKernel::ClearPointArray()
  43. {
  44.  EnterCriticalSection( &csDataAccess );
  45.  try
  46.  {
  47.   for( int tr=0; tr < (int)array_alpnt.size(); tr++ )
  48.        array_alpnt[ tr ].clear();
  49.  
  50.   for( int cnt=0; cnt < (int)array_viewpoint_.size(); cnt++ )
  51.        array_viewpoint_[ cnt ].clear();
  52.  
  53.   array_viewpoint_.clear();
  54.   array_viewpoint_.push_back();
  55.  }
  56.  catch(...)
  57.  {}
  58.  LeaveCriticalSection( &csDataAccess );
  59. }
  60. //---------------------------------------------------------------------------
  61. void __fastcall TKernel::ResetAlarmTrass()
  62. {
  63.  EnterCriticalSection( &csDataAccess );
  64.  
  65.  try
  66.  {
  67.     for( int k=0; k < targets_.size(); k++ )
  68.          delete targets_[ k ];
  69.  
  70.     targets_.clear();
  71.  
  72.     for( int k=0; k < lost_targets_.size(); k++ )
  73.          delete lost_targets_[ k ];
  74.     lost_targets_.clear();
  75.  
  76.     for( int k=0; k < visible_targets_.size(); k++ )
  77.          delete visible_targets_[ k ];
  78.          
  79.     visible_targets_.clear();
  80.  }
  81.  catch( ... )
  82.  {}
  83.  LeaveCriticalSection( &csDataAccess );
  84. }
  85. //---------------------------------------------------------------------------
  86.  
  87. int __fastcall TKernel::AddPoint( LPBsoPoint point_a )
  88. {
  89.  try
  90.  {
  91.   EnterCriticalSection( &csDataAccess );
  92.  
  93.   TBsoPoint ad_pnt = *point_a;
  94.   ad_pnt.LevelContrast = 255;
  95.   ad_pnt.time_birth = Now();
  96.   ad_pnt.usingp = false;
  97.  
  98.   array_alpnt[0].push_back( ad_pnt );
  99.   array_viewpoint_[0].push_back( ad_pnt );
  100.  }
  101.  __finally
  102.  {
  103.   LeaveCriticalSection( &csDataAccess );
  104.  }
  105.  
  106.  return 1;
  107. }
  108. //---------------------------------------------------------------------------
  109.  
  110. void __fastcall TKernel::SetUsingPointStatus_( PUS_STATUS new_status )
  111. {
  112.  int n_ar, n_pnt;
  113.  try
  114.  {
  115.   for( n_ar=0; n_ar < (int)array_alpnt.size(); n_ar++ )
  116.    for( n_pnt=0; n_pnt < (int)array_alpnt[ n_ar ].size(); n_pnt++ )
  117.      if( array_alpnt[ n_ar ][ n_pnt ].usingp )
  118.      switch( new_status )
  119.      {
  120.       case PUS_DELETE:
  121.                      try
  122.                      {
  123.                       array_alpnt[ n_ar ].erase( array_alpnt[ n_ar ].begin() + n_pnt );
  124.                       n_pnt--;
  125.                      }
  126.                      catch( ... )
  127.                      {
  128.                        MainData->LogMessage( &TDebugMessage( "Deleting point failed", MDF_WORK | MDF_KERNEL | MDF_PNTACTION, __FILE__, __LINE__ ) );
  129.                      }
  130.                      break;
  131.                      
  132.       case PUS_NOUSING:
  133.                       array_alpnt[ n_ar ][ n_pnt ].usingp = false;
  134.                       break;
  135.      }
  136.  }
  137.  catch( ... )
  138.  {
  139.   //AnsiString dd;
  140.   //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() );
  141.   //MainData->LogMessage( new TDebugMessage( dd, MDF_WORK | MDF_KERNEL | MDF_PNTACTION, __FILE__, __LINE__) );
  142.  }
  143. }
  144. //---------------------------------------------------------------------------
  145.  
  146. LPBsoPoint __fastcall TKernel::GetMinimumLengthPoint_( LPBsoPoint cur_point, double MaxRadius )
  147. {
  148.  double min_radius = MaxRadius;
  149.  LPBsoPoint res_point = NULL;
  150.  for( int n_ar=0; n_ar < (int)array_alpnt.size(); n_ar++ )
  151.   for( int n_pnt=0; n_pnt < (int)array_alpnt[ n_ar ].size(); n_pnt++ )
  152.     if( !array_alpnt[ n_ar ][ n_pnt ].usingp )
  153.     {
  154.      double radius = hypot( cur_point->x - array_alpnt[ n_ar ][ n_pnt ].x,
  155.                             cur_point->y - array_alpnt[ n_ar ][ n_pnt ].y );
  156.  
  157.      if( radius > 0.2 && radius < min_radius )
  158.      {
  159.          min_radius = radius;
  160.          res_point = &array_alpnt[ n_ar ][ n_pnt ];
  161.      }
  162.     }
  163.  
  164.  return res_point;
  165. }
  166. //---------------------------------------------------------------------------
  167.  
  168. void __fastcall TKernel::TryAddPointFront_( LPTarget pTarget, BYTE NumAr )
  169. {
  170.  deque< int > number_adding_points_;
  171.  while( true )
  172.  {
  173.     double minlen = pTarget->MiddleSpeed * 1.5;
  174.  
  175.     double targlen = hypot( pTarget->Points[ FIRST_POINT ].x - pTarget->Points[ AIMING_POINT ].x,
  176.                             pTarget->Points[ FIRST_POINT ].y - pTarget->Points[ AIMING_POINT ].y );//запоминаем длину между начальной и временной конечной точкой цели
  177.  
  178.     number_adding_points_.clear();
  179.     for( int cnt=0; cnt < (int)array_alpnt[ NumAr ].size(); cnt++ ) //для всех точек массива
  180.     {
  181.      if( array_alpnt[ NumAr ][ cnt ].usingp )
  182.          continue;
  183.  
  184.      double len = hypot( pTarget->Points[ FIRST_POINT ].x - array_alpnt[ NumAr ][ cnt ].x,
  185.                          pTarget->Points[ FIRST_POINT ].y - array_alpnt[ NumAr ][ cnt ].y );//высчитываем приращение
  186.  
  187.      if( len > minlen * 0.2 && len < minlen ) //если приращение находится в допустимых пределах
  188.      {
  189.          double addlen = hypot( pTarget->Points[ AIMING_POINT ].x - array_alpnt[ NumAr ][ cnt ].x,
  190.                                 pTarget->Points[ AIMING_POINT ].y - array_alpnt[ NumAr ][ cnt ].y ); //высчитываем длину между временной конечной точкой и точкой приращения
  191.  
  192.          if( addlen > targlen ) //проверяем вектор приращения, дожен быть положительным
  193.          {
  194.           number_adding_points_.push_back( cnt );   //запоминаем положение точки с минимальным радиусом
  195.           minlen = len;
  196.           array_alpnt[ NumAr ][ cnt ].usingp = true;
  197.          }
  198.      }
  199.     }
  200.  
  201.     if( number_adding_points_.size() == 0 )
  202.         return;
  203.  
  204.     double minangl = M_PI;
  205.     int savecnt=-1;
  206.     int arsize = number_adding_points_.size();
  207.     for( int pntcnt=0; pntcnt < arsize; pntcnt++ )
  208.     {
  209.      int numpnt = number_adding_points_[ pntcnt ];
  210.      double angl = AngleBtwnLine( &array_alpnt[ NumAr ][ numpnt ], &( pTarget->Points[ FIRST_POINT ] ), &( pTarget->Points[ AIMING_POINT ] ) );
  211.      if( angl < minangl )
  212.      {
  213.        minangl = angl;
  214.        savecnt = numpnt;
  215.      }
  216.     }
  217.  
  218.     if( minangl < M_PI / 4 )
  219.     {
  220.         pTarget->Points[ NEW_POINT ] = array_alpnt[ NumAr ][ savecnt ];
  221.  
  222.         {
  223.          int arsize = number_adding_points_.size();
  224.          for( int pntcnt=0; pntcnt < arsize; pntcnt++ )
  225.               array_alpnt[ NumAr ][ number_adding_points_[ pntcnt ] ].usingp = false;
  226.         }
  227.  
  228.         array_alpnt[ NumAr ][ savecnt ].usingp = true;
  229.     }
  230.   }
  231. }
  232. //---------------------------------------------------------------------------
  233.  
  234. bool __fastcall TKernel::DeleteTarget_( DQ_LPTarget &lptargets, LPTarget del_targ )
  235. {
  236.  for( int rtarg=0; rtarg  < (int)lptargets.size(); rtarg++ )
  237.    if( lptargets[ rtarg ] == del_targ )
  238.    {
  239.        lptargets.erase( lptargets.begin() + rtarg );
  240.        return true;
  241.    }
  242.  
  243.  return false;
  244. }
  245. //---------------------------------------------------------------------------
  246. void __fastcall TKernel::DeleteNearPoints_( LPTarget val_target )
  247. {
  248.  int rad = ( val_target->Status == ST_VISIBLE ) ? 9 : 5;
  249.  for( int nof_pnt=0; nof_pnt < val_target->OffsetEndPoint-1; nof_pnt++ )
  250.  {
  251.    TBsoPoint tmp_pnt = val_target->Points[ nof_pnt ];
  252.    for( int nar=1; nar < (int)array_alpnt.size(); nar++ )
  253.     for( int nom_pnt=0; nom_pnt < (int)array_alpnt[ nar ].size(); nom_pnt++ )
  254.     if( hypot( tmp_pnt.x - array_alpnt[ nar ][ nom_pnt ].x,
  255.                tmp_pnt.y - array_alpnt[ nar ][ nom_pnt ].y ) < rad )
  256.     {
  257.         array_alpnt[ nar ].erase( array_alpnt[ nar ].begin() + nom_pnt );
  258.         nom_pnt--;
  259.     }
  260.  }
  261. }
  262. //---------------------------------------------------------------------------
  263.  
  264. void __fastcall TKernel::AlgoritmGrowingTargets_( DQ_LPTarget &lptargets )
  265. {
  266.  for( int ntarg=0; ntarg < (int)lptargets.size(); ntarg++ )
  267.  {
  268.   LPTarget tmp_targ = lptargets[ ntarg ];
  269.   tmp_targ->NewCicle();
  270.  
  271.   if( tmp_targ->Status == ST_LOST )  //цель потеряна
  272.   {
  273.    if( tmp_targ->PointNumber < 15 )  //цель не дотянула до обнаруженной
  274.        delete tmp_targ;                                    //удалить из памяти
  275.    else
  276.    {
  277.        lost_targets_.push_front( tmp_targ );               //цель была в обработке, поместим её в массив потерянных целей
  278.        MainData->Action( DMSA_SEND_TARGET_COM, (char*)tmp_targ );
  279.        tmp_targ->SaveToFile();
  280.    }
  281.    
  282.    lptargets.erase( lptargets.begin() + ntarg );           //удалим цель из текущего массива
  283.    ntarg--;                                                //сместимся на шаг назад
  284.    continue;                                               //обработка для следующей цели
  285.   }
  286.  
  287.   //обработка для текущей цели по пришедшим точкам
  288.   if( tmp_targ->PointNumber > 0 )
  289.   {
  290.    int lastpntnum = tmp_targ->PointNumber;
  291.    BYTE right_ar = 0;
  292.  
  293.    while( true )
  294.    {
  295.      tmp_targ += array_alpnt[ right_ar ];
  296.      if( lastpntnum == tmp_targ->PointNumber && right_ar < 8 )
  297.      {
  298.       right_ar++;
  299.      }
  300.      else
  301.      {
  302.       array_alpnt[ right_ar ] -= tmp_targ;
  303.       break;
  304.      }
  305.    }
  306.  
  307.    if( tmp_targ->MiddleSpeed / 4. > 4 )
  308.    {
  309.     lptargets.erase( lptargets.begin() + ntarg );
  310.     delete tmp_targ;
  311.    }
  312.    else
  313.    if( tmp_targ->Status == ST_READY )
  314.    {
  315.     lptargets.erase( lptargets.begin() + ntarg );
  316.     visible_targets_.push_back( tmp_targ );
  317.     tmp_targ->Status = ST_VISIBLE;
  318.     tmp_targ->Number = ++target_number_;
  319.  
  320.     MainData->AlarmSound = true;
  321.    }
  322.   }
  323.  }
  324. }
  325. //---------------------------------------------------------------------------
  326.  
  327. void __fastcall TKernel::UpdateTargetCom_()
  328. {
  329.   for( WORD nk=0; nk < (int)visible_targets_.size(); nk++ )
  330.     if( visible_targets_[ nk ]->MissedCicle < 2 )
  331.        MainData->Action( DMSA_SEND_TARGET_COM, (char*)visible_targets_[ nk ] );
  332. }
  333. //---------------------------------------------------------------------------
  334.  
  335. void __fastcall TKernel::ShowInformationOnGrid_()
  336. {
  337.  int rt=0;
  338.  for( BYTE n_check=0; n_check < 3; n_check++ )
  339.  {
  340.   if( !VisibleAr[ n_check ] )
  341.       continue;
  342.  
  343.   DQ_LPTarget &lptargets = *targtmpar[ n_check ];
  344.  
  345.   try
  346.   {
  347.    for( WORD nk=0; nk < (int)lptargets.size(); nk++ )
  348.    {
  349.     FFormular->rzFormular->Objects[ 0 ][ rt+1 ] = (TObject*)lptargets[ nk ];
  350.  
  351.     MDGraphic_->Show( lptargets[ nk ] );
  352.     rt++;
  353.    }
  354.   }
  355.   catch(...)
  356.   {
  357.  
  358.   }
  359.  }
  360.  
  361.  FFormular->rzFormular->RowCount = rt+1;
  362.  
  363.  if( array_alpnt.size() > 2 )
  364.  {
  365.      MainForm->imgClock->Canvas->Lock();
  366.      try
  367.      {
  368.       AnsiString text = "";
  369.       text.sprintf( "Точек %d/%d/%d       ", array_alpnt[ 0 ].size(),
  370.                                             array_alpnt[ 1 ].size(),
  371.                                             array_alpnt[ 2 ].size() );
  372.       MainForm->imgClock->Canvas->TextOutA( 10, 55, text );
  373.  
  374.       text.sprintf( "Целей %d/%d/%d       ", targtmpar[ 0 ]->size(),
  375.                                             targtmpar[ 1 ]->size(),
  376.                                             targtmpar[ 2 ]->size() );
  377.       MainForm->imgClock->Canvas->TextOutA( 10, 70, text );
  378.      }
  379.      __finally
  380.      {
  381.       MainForm->imgClock->Canvas->Unlock();
  382.      }
  383.  
  384.  }
  385. }
  386. //---------------------------------------------------------------------------
  387. void __fastcall TKernel::DeleteOldTarget( TTarget* ptarg )
  388. {
  389.  try
  390.  {
  391.   if( ptarg != NULL && ptarg->Status == ST_LOST )
  392.   {
  393.      DeleteTarget_( lost_targets_, ptarg );
  394.      delete ptarg;
  395.   }
  396.  }
  397.  catch(...)
  398.  {
  399.  
  400.  }
  401. }
  402. //---------------------------------------------------------------------------
  403.  
  404. LPTarget __fastcall TKernel::GetTargetByColor( TColor Color )
  405. {
  406.  for( BYTE n_check=0; n_check < 3; n_check++ )
  407.  {
  408.   if( !VisibleAr[ n_check ] )
  409.       continue;
  410.  
  411.   DQ_LPTarget &lptargets = *targtmpar[ n_check ];
  412.  
  413.   for( WORD nk=0; nk < (int)lptargets.size(); nk++ )
  414.     if( lptargets[ nk ]->Color == Color )
  415.         return lptargets[ nk ];
  416.  }
  417.  
  418.  return NULL;
  419. }
  420. //---------------------------------------------------------------------------
  421.  
  422. void __fastcall TKernel::CheckVisibleArrayClick( TObject* Sender )
  423. {
  424.   TRzBmpButton* btnh = dynamic_cast< TRzBmpButton* >( Sender );
  425.   VisibleAr[ btnh->Tag ] = !VisibleAr[ btnh->Tag ];
  426.   btnh->Down = VisibleAr[ btnh->Tag ];
  427. }
  428. //---------------------------------------------------------------------------
  429.  
  430. void __fastcall TKernel::Process_alarm_points_()
  431. {
  432.  MDGraphic_->ClearPlane();
  433.  
  434.  int nk = 1;
  435.  
  436.  try
  437.  {
  438.   AlgoritmGrowingTargets_( visible_targets_ );
  439.  
  440.   AlgoritmGrowingTargets_( targets_ );
  441.  }
  442.  catch(...)
  443.  {
  444.   //int h=0;
  445.  }
  446.  
  447.  try
  448.  {
  449.   AlgoritmAiming_();
  450.  }
  451.  catch(...)
  452.  {}
  453.  
  454.  try
  455.  {
  456.   ShowInformationOnGrid_();
  457.  }
  458.  catch(...)
  459.  {}
  460.  
  461.  try
  462.  {
  463.   UpdateTargetCom_();
  464.  }
  465.  catch(...)
  466.  {}
  467.  
  468.  ShiftArray( array_alpnt, 15 );
  469.  
  470.  ShiftArray( array_viewpoint_, 700 );
  471. }
  472. //---------------------------------------------------------------------------
  473.  
  474. void __fastcall TKernel::ShiftArray( DQ_DQTBPS &lparray, BYTE Step )
  475. {
  476.   if( (int)lparray.size() == Step )
  477.   {
  478.       lparray[ Step - 1 ].clear();
  479.       lparray.pop_back();
  480.   }
  481.  
  482.   lparray.push_front();
  483.   lparray[ 0 ].clear();
  484. }
  485. //---------------------------------------------------------------------------
  486.  
  487. int __fastcall TKernel::ClearFirstArray_()
  488. {
  489.    int nompnt = 0;
  490.    for( int k=0; k < (int)array_alpnt[ 0 ].size(); k++ )
  491.     for( int kk=k+1; kk < (int)array_alpnt[ 0 ].size(); kk++ )
  492.      if( hypot( array_alpnt[ 0 ][ k ].x - array_alpnt[ 0 ][ kk ].x,
  493.                 array_alpnt[ 0 ][ k ].y - array_alpnt[ 0 ][ kk ].y ) < 0.15 )
  494.      {
  495.          array_alpnt[ 0 ][ k ].x = ( array_alpnt[ 0 ][ k ].x + array_alpnt[ 0 ][ kk ].x ) / 2;
  496.          array_alpnt[ 0 ][ k ].y = ( array_alpnt[ 0 ][ k ].y + array_alpnt[ 0 ][ kk ].y ) / 2;
  497.          if( array_alpnt[ 0 ][ k ].r_fr < array_alpnt[ 0 ][ kk ].r_fr )
  498.              array_alpnt[ 0 ][ k ].Color = array_alpnt[ 0 ][ kk ].Color;
  499.          array_alpnt[ 0 ].erase( array_alpnt[ 0 ].begin() + kk );
  500.          nompnt++;
  501.      }
  502.  
  503.    return nompnt;
  504. }
  505. //---------------------------------------------------------------------------
  506.  
  507. void __fastcall TKernel::Execute()
  508. {
  509.    try
  510.    {
  511.     if( MDConnect_->CicleCounter > 30 )
  512.         Process_alarm_points_();
  513.    }
  514.    catch(...)
  515.    {
  516.    // MainData->LogMessage( new TDebugMessage( "Process_alarm_points FAILED", MDF_WORK | MDF_KERNEL, __FILE__, __LINE__) );
  517.    }
  518.  
  519.    try
  520.    {
  521.      //MDGraphic_->Show( array_alpnt );
  522.      MDGraphic_->Show( array_viewpoint_ );
  523.    }
  524.    catch(...)
  525.    {
  526.     //MainData->LogMessage( new TDebugMessage( "Show( Array_viewpoint_ ) FAILED", MDF_WORK | MDF_KERNEL, __FILE__, __LINE__) );
  527.    }
  528. }
  529. //---------------------------------------------------------------------------
  530.  
  531. void __fastcall TKernel::AlgoritmAiming_() //алгоритм обнаружения
  532. {
  533.  if( array_alpnt.size() == 15 && targets_.size() < 20 )
  534.  {
  535.   for( int nom_point = 0; nom_point < (int)array_alpnt[ 14 ].size(); nom_point++ )         //поиск от первой точки в рабочем массиве точек
  536.   {
  537.    TTarget new_target(0);// = new TTarget( 0 );                  //выделяем память для новой цели
  538.  
  539.    try
  540.    {
  541.     new_target.Points[ NEW_POINT ] = array_alpnt[ 14 ][ nom_point ];      //ставим начальную точку
  542.     array_alpnt[ 14 ][ nom_point ].usingp = true;
  543.    }
  544.    catch(...)
  545.    {
  546.     //int h=0;
  547.    }
  548.  
  549.    LPBsoPoint secondpnt = GetMinimumLengthPoint_( &( new_target.Points[ FIRST_POINT ] ), 20 );
  550.    if( secondpnt != NULL )
  551.        new_target.Points[ NEW_POINT ] = *secondpnt;
  552.    else
  553.        continue;    
  554.  
  555.    int tmpar = array_alpnt.size() - 1;
  556.    while( tmpar >= 0 )
  557.    {
  558.            TryAddPointFront_( &new_target, tmpar );
  559.            tmpar--;
  560.    }
  561.  
  562.    if( new_target.Status == ST_NEW )
  563.    {
  564.         new_target.Visible = true;
  565.         MDGraphic_->Show( &new_target );
  566.  
  567.         targets_.push_back( new TTarget( new_target ) );
  568.         SetUsingPointStatus_( PUS_DELETE );
  569.         DeleteNearPoints_( &new_target );
  570.         continue;
  571.    }
  572.  
  573.    SetUsingPointStatus_( PUS_NOUSING );
  574.   }
  575.  }
  576. }
  577. //---------------------------------------------------------------------------
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top