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

#include <vcl.h>
#include <math.h>
#pragma hdrstop

#include "Draw_RSU_F.h"
#include "SelectProfilSect.h"
#include "ListConst.h"
#include "ProcExt.h"
#include "pCanvas_func.h"
#include "StandartProfil.h"
#include "Draw3D_beam.h"
#include "Point_dvutavr.h"


//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TDraw_RSU_Frame *Draw_RSU_Frame;
extern  bool flag_image;
static TStandartProfil StandartProfil;


//---------------------------------------------------------------------------
__fastcall TDraw_RSU_Frame::TDraw_RSU_Frame(TComponent* Owner)
		: TFrame(Owner)
{
  CheckListBox_Show->Checked[0] = true;
  CheckListBox_Show->Checked[1] = true;
  CheckListBox_Show->Checked[2] = true;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Нарисовать профиль и оси координат
void __fastcall TDraw_RSU_Frame::Draw_beam0(bool flag_sign, bool flag_sysc)
{
   int rc;
   pBrush_Color(Image1, clBlack);
   pPen_Color(Image1, clBlack);
   double attit, alfa;

   switch (form_profil) {
   case DVUTAVR_STAND:
   // Сварной двутавр
   // Установить тип стандартного сечения
	 type_profil = index_profil + typeGOST_G57837_B;
	 StandartProfil.SetProfil(type_profil);
   // Получить вектор имен профилей и длину вектора
	 //NameProfil = StandartProfil.GetVectorNameProfil(&n_profil);
	 rc = StandartProfil.SetParamProfil(&(com_sect.dvutavr), 0);
	 if (rc>0) return;
	 Draw_dvutavr(Image1, &com_sect.dvutavr, vISOMETR, 4.0, 70, flag_sysc, false, 0, 0, 0);
	 H_beam = com_sect.dvutavr.h + 2*com_sect.dvutavr.h1;
   break;
   case PERFOR_BEAM:
   // Перфорированный двутавр
   // Установить тип стандартного сечения
	 type_profil = index_profil + typeGOST_G57837_B;
	 StandartProfil.SetProfil(type_profil);
   // Получить вектор имен профилей и длину вектора
	 //NameProfil = StandartProfil.GetVectorNameProfil(&n_profil);
	 rc = StandartProfil.SetParamProfil(&(com_sect.dvutavr), 0);

	 attit = 1.5;
	 alfa = 60;

	 com_sect.dvutavr.h *= attit;
	 if (rc>0) return;
	 Draw_dvutavr(Image1, &com_sect.dvutavr, vISOMETR, 4.0, 70, flag_sysc, true, attit, alfa, 0);
	 H_beam = com_sect.dvutavr.h + 2*com_sect.dvutavr.h1;
   break;
   case TRUBA:                                  // Труба
	 StandartProfil.SetProfil_Tube(type_profil);
	 rc = StandartProfil.SetParamProfil_Tube(&(com_sect), type_profil, 0, 0);
	 if (rc>0) return;
	 Draw_tube(Image1, &com_sect, type_profil, vISOMETR, 4.0, 70, flag_sysc, 0);
	 H_beam = com_sect.rect.h + 2*com_sect.rect.h1;
   break;
   case DVUTAVR_WELD:
   // Установить тип стандартного сечения, необходим для рисования сечения
	 type_profil = typeGOST_G57837_B;
	 StandartProfil.SetProfil(type_profil);
   // Получить вектор имен профилей и длину вектора
	 //NameProfil = StandartProfil.GetVectorNameProfil(&n_profil);
	 rc = StandartProfil.SetParamProfil(&(com_sect.dvutavr), 0);
	 if (rc>0) return;
	 Draw_dvutavr_weld(Image1, &com_sect.dvutavr, vISOMETR, 4.0, 70, flag_sysc, 0);
	 H_beam = com_sect.dvutavr.h + 2*com_sect.dvutavr.h1;
   break;
   }
   // Рисование нагрузок
   Draw_load();
}
//------------------------------------------------------------------------------------------------------
// Рисование нагрузок
void __fastcall TDraw_RSU_Frame::Draw_load() {
  TPoint points[10];
  TPoint vert[10];
  TPoint point_0;
  int X1, X2, X3, X4, Y1, Y2, Y3, Y4;
  float shift;
  int k, n;
  float scale_load;
  double Value;
  double coor_g[30][3];
  double xf0[20], xf1[20], xf2[2];
  double coor_load[3];
  double direction[3], Sign;
  double t_ar, l_ar;

  bool flag_sign = CheckListBox_Show->Checked[1];

  double x0, y0, length, scale, X_shift, Y_shift;

  if (!CheckListBox_Show->Checked[0]) {
	 return;
  }
  Mx_plus = 0;
  Qy_plus = 0;
  loads[5] = q_bal;
  if (CheckBox_Centr->Checked) {
	   Mx_plus = q_bal*L_beam*L_beam*0.125*1e-6;
	   Qy_plus = 0;
	   loads[5] = 0;
  }

  if (CheckBox_Side->Checked) {
	   Mx_plus = 0;
	   Qy_plus = q_bal*L_beam*0.5*1e-3;
	   loads[5] = 0;
  }
 // Получить координаты и длину  балки
  Get_XY_Len(&x0, &y0, &length);
  // Получить масштаб и сдвиги
  Get_scale(&scale, &X_shift, &Y_shift);

  //---------------------------------------------------
  Value = 0;
  Value = MAX(Value, (ABS(loads[0])));
  Value = MAX(Value, (ABS(loads[2] + Qy_plus)));
  Value = MAX(Value, (ABS(loads[4])));
  pPen_Width(Image1, 1);
  //pBrush_Color(Image1, clMaroon);
  pBrush_Style(Image1, bsClear);
  l_ar = length/6;
  t_ar = l_ar/5;

	if (loads[5]!=0) { // равномерно распределенная нагрузка
	  float scale_force, delta_x, delta_y;

	  scale_force = length*scale/(8*(ABS(loads[5])));
	  pPen_Color(Image1, clPurple);
	  pBrush_Style(Image1, bsClear);

	  coor_g[0][0] = x0;    coor_g[0][2] = 0;
	  coor_g[1][0] = x0;    coor_g[1][2] = length;

	  switch (index_Qy) {
	  case 0:
		coor_g[0][1] = y0 - H_beam*0.5;
		coor_g[1][1] = y0 - H_beam*0.5;
	  break;
	  case 1:
		coor_g[0][1] = y0 + H_beam*0.5;
		coor_g[1][1] = y0 + H_beam*0.5;
	  break;
	  case 2:
		coor_g[0][1] = y0;
		coor_g[1][1] = y0;
	  break;
	  }
      // получить экранные координаты точек распределенной нагрузки
	  get_point_q(coor_g);

	  n = (coor_g[0][0] - coor_g[1][0])/20;
	  n = ABS(n);
	  delta_x = (coor_g[0][0] - coor_g[1][0])/n;
	  delta_y = (coor_g[0][1] - coor_g[1][1])/n;

	  points[0] = Point(coor_g[0][0], coor_g[0][1]);
	  points[1] = Point(points[0].x, points[0].y - loads[5]*scale_force);
	  for (k=0; k <=n ; k++) {

		vert[1] = Point(points[0].x - k*delta_x, points[0].y - k*delta_y);
		vert[0] = Point(vert[1].x, vert[1].y - loads[5]*scale_force);
		CoorAx.PutArrow(vert, 0, MAX_PIC);
		CoorAx.SetArrow();

		pPen_Width(Image1, 1);
		pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
		pCanvas_Polyline(Image1, CoorAx.Ar, 3);
	  }
	  points[2] = vert[0];
	  pCanvas_Polyline(Image1, points+1, 1);
	  points[1] = Point(coor_g[1][0], coor_g[1][1]);
	  pCanvas_Polyline(Image1, points, 1);

	  //pFont_Color(Image1, clPurple);
	  pBrush_Style(Image1, bsSolid);
	  if (flag_sign) {
		 pCanvas_TextOut(Image1, (points[0].x + points[2].x)/2 + 20 , (points[0].y  + points[2].y)/2 - 10, "qz ="+FloatToStr(loads[5])+" кН/м");
	  }

	}

	//--------------------------------------------------------
	// Сила N
	if (loads[0]!=0) {
	  pPen_Color(Image1, clRed);
	  // N на левом конце
	   direction[0] = direction[1] = 0; direction[2] = 1;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = length;
	   scale_load = ABS(loads[0]/Value);
	   // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_load_ar(loads[0], direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[0], flag_sign, 0, 0);   // изображение силы
	  // N на правом конце
	   direction[0] = direction[1] = 0; direction[2] = -1;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = 0;
	   get_point_load_ar(loads[0], direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[0], flag_sign, 0, 0);   // изображение силы

	}

	if (loads[2] + Qy_plus!=0 ) { // Сила Qy
	   pPen_Color(Image1, clGreen);
	  // Qy на левом конце
	   scale_load = ABS((loads[2]  + Qy_plus)/Value);
	   direction[0] = 0; direction[1] = 1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = length;
	   get_point_load_ar(loads[2]  + Qy_plus, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[2] + Qy_plus, flag_sign, 1, 0);   // изображение силы
	  // Qy на правом конце
	   direction[0] =0;  direction[1] = -1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = 0;
	   get_point_load_ar(loads[2]  + Qy_plus, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[2] + Qy_plus, flag_sign, 1, 0);   // изображение силы
	}

	if (loads[4]!=0) { // Сила Qx
	   pPen_Color(Image1, clBlue);
	  // Qy на левом конце
	   scale_load = ABS(loads[4]/Value);
	   direction[0] = 1; direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = length;
	   get_point_load_ar(loads[4], direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[4], flag_sign, 2, 0);   // изображение силы
	  // Qy на правом конце
	   direction[0] =-1;  direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = 0;
	   get_point_load_ar(loads[4], direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, loads[4], flag_sign, 2, 0);   // изображение силы
	}

	//Image1->Canvas->Pen->Width = 1;
	pPen_Width(Image1, 1);
	if (loads[1] + Mx_plus!=0) {  // Момент Mx
	  pPen_Color(Image1, clBlue);
	  // Mx на левом конце
	   direction[0] = 1; direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = length;
	   get_point_moment(loads[1] + Mx_plus, direction, coor_load, coor_g, length);
	   draw_moment(Image1, coor_g, loads[1] + Mx_plus, flag_sign);   // изображение момента
	  // Mx на правом конце
	   direction[0] = -1; direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = 0;
	   get_point_moment(loads[1] + Mx_plus, direction, coor_load, coor_g, length);
	   draw_moment(Image1, coor_g, loads[1] + Mx_plus, flag_sign);   // изображение момента
	}

	if (loads[3]!=0) {  // Момент My
	  pPen_Color(Image1, clGreen);
	  // My на левом конце
	   direction[0] = 0; direction[1] = 1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = length;
	   get_point_moment(loads[3], direction, coor_load, coor_g, length);
	   draw_moment(Image1, coor_g, loads[3], flag_sign);   // изображение момента
	  // My на правом конце
	   direction[0] = 0; direction[1] = -1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = 0;
	   get_point_moment(loads[3], direction, coor_load, coor_g, length);
	   draw_moment(Image1, coor_g, loads[3], flag_sign);   // изображение момента
	}
	pPen_Width(Image1, 1);
	Image1->Canvas->Pen->Color = clBlack;

}
//------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------
// Рисование нагрузок и опор на балке
void __fastcall TDraw_RSU_Frame::Draw_load_balka(int k_zagr, int length_q, BeamRegion *Aq, int length_N, BeamRegion *AN,
										 int length_loads, Load *Aloads, int length_constr, Constraint *Aconstr,
										 int *index_place, double *b_) {
  TPoint points[10];
  TPoint vert[10];
  TPoint point_0;
  int X1, X2, X3, X4, Y1, Y2, Y3, Y4;
  float shift;
  int i, k, n;
  float scale_load;
  double Value;
  double coor_g[30][3];
  double coor_gN[30][3];
  double xf0[20], xf1[20], xf2[2];
  double coor_load[3];
  double direction[3], Sign;
  double t_ar, l_ar, mult_x;

  bool flag_sign = CheckListBox_Show->Checked[1];

  double x0, y0, length, scale, X_shift, Y_shift;

// Получить координаты и длину балки
  Get_XY_Len(&x0, &y0, &length);
// Получить масштаб и сдвиги
  Get_scale(&scale, &X_shift, &Y_shift);

  //---------------------------------------------------
  Value = 0;
  for (i=0; i<length_loads; i++) {
	Value = MAX(Value, (ABS(Aloads[i].u)));
	Value = MAX(Value, (ABS(Aloads[i].v)));
  }
  pPen_Width(Image1, 1);
  //pBrush_Color(Image1, clMaroon);
  pBrush_Style(Image1, bsClear);
  if (Length_beam > 0)
	mult_x = length/(Length_beam*L1000);
  else
	mult_x = 1;
  l_ar = MAX(H_beam, length/15);          //L_beam
  t_ar = l_ar/8;
  // Рисовать нагрузки
  if (CheckListBox_Show->Checked[0]) {
	pCanvas_TextOut(Image1, 150 , Image1->Height - 20, "Нагрузки на балке. Загружение "+IntToStr(k_zagr+1));
	 //--------------------------------------------------------
	// Сосредоточенные нагрузки

	for (i=0; i<length_loads; i++) {
	  if (Aloads[i].u!=0) {
	   pPen_Color(Image1, clRed);
	  // N
	   direction[0] = direction[1] = 0; direction[2] = -1;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
	   scale_load = ABS(Aloads[i].u/Value);
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_load_ar(Aloads[i].u, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, Aloads[i].u, flag_sign, 0, 1);   // изображение силы
	  }
	  if (Aloads[i].v!=0) {
		pPen_Color(Image1, clGreen);
	  // Q
		direction[0] = direction[1] = 1; direction[2] = 0;
		coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
		switch (index_Qy) {
		case 0:
			coor_load[1] = y0 - H_beam*0.5;
		break;
		case 1:
			coor_load[1] = y0 + H_beam*0.5;
		break;
		case 2:
			coor_load[1] = y0;
		break;
		}
		scale_load = ABS(Aloads[i].v/Value);
	  // получить экранные координаты точек для рисования нагрузок на геометрии
		get_point_load_ar(-Aloads[i].v, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
		draw_load_ar(Image1, coor_g, Aloads[i].v, flag_sign, 1, 1);   // изображение силы
	  }
	  if (Aloads[i].c!=0) {  // Момент My
		pPen_Width(Image1, 1);
		pPen_Color(Image1, clBlue);
	  //
		direction[0] = 1; direction[1] = 0; direction[2] = 0;
		coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
		get_point_moment(Aloads[i].c, direction, coor_load, coor_g, H_beam*4);
		draw_moment(Image1, coor_g, Aloads[i].c, flag_sign);   // изображение момента
	  }
	  if (CheckListBox_Show->Checked[5]) {
		for (int ii=0; ii<length_loads; ii++) {
		  if (Aloads[i].X==0)
			continue;
		  direction[0] = direction[1] = 1; direction[2] = 0;
		  coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		  get_point_dim(direction, coor_load, coor_g);
		  draw_dim(Image1, coor_g, Aloads[i].X);   // изображение размерной линии
		}
	  }
	}
  //--------------------------------------------------------------
  // Погонные поперечные нагрузки
  double Value_max = 0;
  double Value_min = 1e15;
  double xq, yq;
  int    j, nq;

  for (i=0; i<length_q; i++) {
	Value_max = MAX(Value_max, (ABS(Aq[i].begValue)));
	Value_max = MAX(Value_max, (ABS(Aq[i].endValue)));
	Value_min = MIN(Value_min, (ABS(Aq[i].begValue)));
	Value_min = MIN(Value_min, (ABS(Aq[i].endValue)));
  }
  for (i=0; i<length_q; i++) {
	double Value_i = MAX((ABS(Aq[i].begValue)), (ABS(Aq[i].endValue)));
	if (Value_i!=0) {
	  float scale_force, delta_x, delta_y;
	  float delV = Aq[i].begValue - Aq[i].endValue;

	  //scale_force = length*scale/(6*Value_max);
	  //scale_force *= get_scale_mod();

	  scale_force = 0.5*l_ar*scale/Value_max;  //*(ABS(Aq[i].begValue/Value));

	  xq = x0;
	  yq = y0;
	  nq = 1; // количество нагрузок

	  //int index_up = index_Qy;
	  int index_up = index_place[i];
	  double delta_thick;
	  double delta_y0;
	  double b_ax;

	  if (index_composed==0 || index_composed==2 ) {
		 delta_thick = plate_thick;
		 delta_y0 = 0;
		 b_ax = plate_width/2 - b_[i];
	  }
	  else {
		 delta_thick = plate_thick + com_sect.tavr.h2;
		 delta_y0 = -plate_thick;
		 b_ax = com_sect.tavr.b1/2 - b_[i];
	  }
	  switch (index_place[i]) {
	  case placeALL:
		//index_up = 0;
		xq = x0;
		yq = y0;
		nq = 1;
	 break;
	  case  placeUP:
		//index_up = 1;
		xq = x0;
		yq = delta_y0;
		nq = 1;
	  break;
	  case placeDOWN:
		xq = x0;
		yq = H_beam - delta_thick;
		nq = 1;
	  break;
	  case placeDOWN_LEFT_RIGHT:
		xq = x0 - b_ax;
		yq = H_beam - delta_thick;
		nq = 2;
		//index_up = 2;
	  break;
	  case placeDOWN_LEFT:
		xq = x0 - b_ax;
		yq = H_beam - delta_thick;
		nq = 1;
		//index_up = -1;
	  break;
	  case placeDOWN_RIGHT:
		xq = x0 + b_ax;
		yq = H_beam - delta_thick;
		nq = 1;
		//index_up = -1;
	  break;
	  }

	  for (j = 0; j<nq; j++, xq = x0 + b_ax) {

		pPen_Color(Image1, clPurple);
		pBrush_Style(Image1, bsClear);

		coor_g[0][0] = xq;
		coor_g[1][0] = xq;
		coor_g[0][1] = yq;
		coor_g[1][1] = yq;
		coor_g[0][2] = (Length_beam - Aq[i].X0)*L1000*mult_x;
		coor_g[1][2] = (Length_beam - (Aq[i].X0 + Aq[i].Len))*L1000*mult_x;

	  // получить экранные координаты точек распределенной нагрузки
		get_point_q(coor_g);

		n = MAX(1, (ABS(coor_g[1][0] - coor_g[0][0]))/20);
		n = ABS(n);
		delta_x = (coor_g[0][0] - coor_g[1][0])/n;
		delta_y = (coor_g[0][1] - coor_g[1][1])/n;
		delV /= n;

		points[0] = Point(coor_g[0][0], coor_g[0][1]);
		points[1] = Point(points[0].x, points[0].y - Aq[i].begValue*scale_force);
		for (k=0; k <=n ; k++) {

		  vert[1] = Point(points[0].x - k*delta_x, points[0].y - k*delta_y);
		  vert[0] = Point(vert[1].x, vert[1].y - (Aq[i].begValue - delV*k)*scale_force);
		  CoorAx.PutArrow(vert, 0, MAX_PIC);
		  CoorAx.SetArrow();

		  pPen_Width(Image1, 1);
		  pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
		  pCanvas_Polyline(Image1, CoorAx.Ar, 3);
		}
		points[2] = vert[0];
		pCanvas_Polyline(Image1, points+1, 1);
		points[1] = Point(coor_g[1][0], coor_g[1][1]);
		pCanvas_Polyline(Image1, points, 1);

	  //pFont_Color(Image1, clPurple);
		pBrush_Style(Image1, bsSolid);
		if (flag_sign) {
		   pCanvas_TextOut(Image1, (points[0].x + points[2].x)/2 + 20 , (points[0].y  + points[2].y)/2 - 10, "qz ="+FloatToStr((Aq[i].begValue + Aq[i].endValue)/2)+" кН/м");
		}
		if (CheckListBox_Show->Checked[5]) {
		  for (int ii=0; ii<length_q; ii++) {
			direction[0] = direction[1] = 1; direction[2] = 0;
			coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aq[i].X0)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
			get_point_dim(direction, coor_load, coor_g);
			if (Aq[i].X0!=0)
			  draw_dim(Image1, coor_g, Aq[i].X0);   // изображение размерной линии
			if (Aq[i].X0 + Aq[i].Len==0)
			  continue;
			direction[0] = direction[1] = 1; direction[2] = 0;
			coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aq[i].X0 - Aq[i].Len)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
			get_point_dim(direction, coor_load, coor_g);
			draw_dim(Image1, coor_g, Aq[i].X0 + Aq[i].Len);   // изображение размерной линии
		  }
		}
	  }
	}
  }
  //--------------------------------------------------------------
  // Распределенные нагрузки вдоль балки
  Value = 0;
  for (i=0; i<length_N; i++) {
	Value = MAX(Value, (ABS(AN[i].begValue)));
	Value = MAX(Value, (ABS(AN[i].endValue)));
  }
  for (i=0; i<length_N; i++) {
	double Value_i = MAX((ABS(AN[i].begValue)), (ABS(AN[i].endValue)));
	if (Value_i!=0) { // распределенная нагрузка
	  float scale_force, delta_x, delta_y;
	  float delV = AN[i].begValue - AN[i].endValue;

	  scale_force = length*scale/(8*Value);
	  pPen_Color(Image1, clBlue);
	  pBrush_Style(Image1, bsClear);

	  coor_g[0][0] = x0;    coor_g[0][2] = (Length_beam - AN[i].X0)*L1000*mult_x;
	  coor_g[1][0] = x0;    coor_g[1][2] = (Length_beam - (AN[i].X0 + AN[i].Len))*L1000*mult_x;

	  coor_g[0][1] = y0;
	  coor_g[1][1] = y0;

	  coor_gN[0][0] = x0 +  AN[i].begValue*scale_force;  coor_gN[0][1] = coor_g[0][1];  coor_gN[0][2] = coor_g[0][2];
	  coor_gN[1][0] = x0 +  AN[i].endValue*scale_force;  coor_gN[1][1] = coor_g[1][1];  coor_gN[1][2] = coor_g[1][2];

	  // получить экранные координаты точек распределенной нагрузки
	  get_point_q(coor_g);
	  get_point_q(coor_gN);

	  n = MAX(1, (ABS(coor_g[1][0] - coor_g[0][0]))/30);
	  n = ABS(n);
	  delta_x = (coor_g[0][0] - coor_g[1][0])/n;
	  delta_y = (coor_g[0][1] - coor_g[1][1])/n;

	  double delVx = (coor_gN[0][0] - coor_gN[1][0])/n;
	  double delVy = (coor_gN[0][1] - coor_gN[1][1])/n;
	  delV /= n;

	  points[0] = Point(coor_g[0][0], coor_g[0][1]);
	  points[1] = Point(coor_gN[0][0], coor_gN[0][1]);
	  point_0 = points[0];
	  //points[1] = Point(points[0].x + AN[i].begValue*scale_force, points[0].y);
	  for (k=0; k <=n ; k++) {

		vert[1] = Point(points[0].x - k*delta_x, points[0].y - k*delta_y);
		vert[0] = Point(points[1].x - k*delVx,   points[1].y - k*delVy);
		//vert[0] = Point(vert[1].x  + (AN[i].begValue - delV*k)*scale_force, vert[1].y);
		pCanvas_Polyline(Image1, vert, 1);
		points[2] = vert[0]; // для рисования после цикла
		vert[0] = point_0;
		TPoint vert_A[2];
		if (AN[i].begValue - delV*k >0) {
		  vert_A[0] = vert[0];
		  vert_A[1] = vert[1];
		}
		else {
		  vert_A[0] = vert[1];
		  vert_A[1] = vert[0];

		}
		CoorAx.PutArrow(vert_A, 0, MAX_PIC);
		CoorAx.SetArrow();

		pPen_Width(Image1, 1);
		pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
		pCanvas_Polyline(Image1, CoorAx.Ar, 3);

		point_0 = vert[1];
	  }
	  pCanvas_Polyline(Image1, points+1, 1);
	  points[1] = Point(coor_g[1][0], coor_g[1][1]);
	  //pCanvas_Polyline(Image1, points, 1);

	  //pFont_Color(Image1, clPurple);
	  pBrush_Style(Image1, bsSolid);
	  if (flag_sign) {
		 pCanvas_TextOut(Image1, (points[0].x + points[2].x)/2 + 20 , (points[0].y  + points[2].y)/2 - 10,
								  "qN ="+FloatToStr((AN[i].begValue + AN[i].endValue)/2)+" кН/м");
	  }
	  if (CheckListBox_Show->Checked[5]) {
		for (i=0; i<length_N; i++) {
		 direction[0] = direction[1] = 1.0*(SIGN(AN[i].begValue)); direction[2] = 0;
		 coor_load[0] = x0;   coor_load[1] = y0; //- H_beam*0.5;
		 coor_load[2] = (Length_beam - AN[i].X0)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 if (AN[i].X0!=0)
		   draw_dim(Image1, coor_g, AN[i].X0);   // изображение размерной линии
		 coor_load[2] = (Length_beam - AN[i].X0 - AN[i].Len)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 if (AN[i].X0 + AN[i].Len!=0)
		   draw_dim(Image1, coor_g, AN[i].X0 + AN[i].Len);   // изображение размерной линии
		}
	  }
	}
  }
 }
 //--------------------------------------------------------
 // Рисование опор (закреплений)
 if (CheckListBox_Show->Checked[3]) {
	TPoint points[10];
	double sh;
	double scale, x_shift, y_shift;
	double t_c, l_c;
	double x1, y1;

   // Получить масштаб рисования модели
   Get_scale(&scale, &x_shift, &y_shift);
   if (scale > 0.6) {
	   t_c = 6;
	   //l_c = H_beam/3;
	   l_c = 30;
   }
   else {
	   t_c = 6*0.5/scale;
	   //l_c = (H_beam/3)*0.5/scale;
	   l_c = 20/scale;

   }

   for (i=0; i<length_constr; i++) {
	 if (Aconstr[i].u!=0) {  // вдоль оси балки
	   direction[0] = 0; direction[1] = 0; direction[2] = 1;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clFuchsia);
	   pBrush_Color(Image1, clFuchsia);
	   pCanvas_Polygon(Image1, points, 6);
	   pBrush_Color(Image1, clWhite);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
					(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));

	   sh = Round(sh, 0);
	   pCanvas_Ellipse(Image1, coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   pCanvas_Ellipse(Image1, coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	 }

	 if (Aconstr[i].v!=0) {  // вертикальное
	   direction[0] = 0; direction[1] = 1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clFuchsia);
	   pBrush_Color(Image1, clFuchsia);
	   pCanvas_Polygon(Image1, points, 6);
	   pBrush_Color(Image1, clWhite);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
					(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	   sh = Round(sh, 0);
	   pCanvas_Ellipse(Image1, coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   pCanvas_Ellipse(Image1, coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	 }

	 if (Aconstr[i].c!=0) {  // Поворот
	   direction[0] = 1; direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	   // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clBlue);
	   pBrush_Color(Image1, clBlue);
	   pCanvas_Polygon(Image1, points, 6);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	   sh = Round(sh, 0);
	   pBrush_Color(Image1, clWhite);
	   pCanvas_Ellipse(Image1, coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   pCanvas_Ellipse(Image1, coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	  //x1 = (coor_g[0][0] + coor_g[3][0])/2;
	  //y1 = (coor_g[0][1] + coor_g[3][1])/2;
	  //Image1->Canvas->Ellipse(x1-sh, y1-sh, x1+sh, y1+sh);
	 }
   }
   // Рисование размерных линий на балке
   if (CheckListBox_Show->Checked[5]) {
		for (i=0; i<length_constr; i++) {
		 if (Aconstr[i].X==0)
		   continue;
		 direction[0] = direction[1] = 1; direction[2] = 0;
		 coor_load[0] = x0;   coor_load[1] = y0; //- H_beam*0.5;
		 coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 draw_dim(Image1, coor_g, Aconstr[i].X);   // изображение размерной линии
		}
   }
  }
 //-------------------------------------------------------------------------
 //  Рисование раскреплений
 if (CheckListBox_Show->Checked[4]) {
	TPoint points[10];
	double sh;
	double scale, x_shift, y_shift;
	double t_c, l_c;
	double x1, y1;

   // Получить масштаб рисования модели
   Get_scale(&scale, &x_shift, &y_shift);
   if (scale > 0.6) {
	   t_c = 6;
	   //l_c = H_beam/3;
	   l_c = 30;
   }
   else {
	   t_c = 6*0.5/scale;
	   //l_c = (H_beam/3)*0.5/scale;
	   l_c = 20/scale;

   }

   if (Len_XY==0)
	  Len_XY = Length_beam;
   for (i=0; i<=ceil(Length_beam/Len_XY); i++) {
	  direction[0] = -1; direction[1] = 0; direction[2] = 0;
	  coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = MIN((Length_beam - Len_XY*i)*L1000*mult_x, Length_beam*L1000*mult_x) ;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	  get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	  for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	  }
	  pPen_Color(Image1, clGreen);
	  pBrush_Color(Image1, clGreen);
	  pCanvas_Polygon(Image1, points, 6);
	  pBrush_Color(Image1, clWhite);
	  sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	  pCanvas_Ellipse(Image1, coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	  pCanvas_Ellipse(Image1, coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
   }
   /*
   if (Step_up==0)
	  Step_up = Len_XY;
   if (Step_down==0)
	  Step_down = Len_XY;
   */
   /* Рисование раскреплений верхнего пояса
   for (i=0; i<=ceil(Length_beam/Step_up); i++) {
	  direction[0] = -1; direction[1] = 0; direction[2] = 0;
	  coor_load[0] = x0 - B_beam/2;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = MAX((Length_beam - Step_up*i)*L1000*mult_x, 0.0) ;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	  get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	  for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	  }
	  pPen_Color(Image1, clGreen);
	  pBrush_Color(Image1, clGreen);
	  Image1->Canvas->Polygon(points, 6);
	  pBrush_Color(Image1, clWhite);
	  sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	  sh = Round(sh, 0);
	  Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	  Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
   }
   // Рисование раскреплений нижего пояса
   for (i=0; i<=ceil(Length_beam/Step_down); i++) {
	  direction[0] = -1; direction[1] = 0; direction[2] = 0;
	  coor_load[0] = x0 - B_beam/2;   coor_load[1] = y0 + H_beam*0.5;    coor_load[2] = MAX((Length_beam - Step_down*i)*L1000*mult_x, 0.0) ;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	  get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	  for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	  }
	  pPen_Color(Image1, clGreen);
	  pBrush_Color(Image1, clGreen);
	  Image1->Canvas->Polygon(points, 6);
	  pBrush_Color(Image1, clWhite);
	  sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	  sh = Round(sh, 0);
	  Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	  Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
   }
   */
 }
 pPen_Width(Image1, 1);
 pPen_Color(Image1, clBlack);

}

//------------------------------------------------------------------------------------------------------
// Рисование нагрузок и опор на стойке
void __fastcall TDraw_RSU_Frame::Draw_load_rack(int k_zagr, int length_q, BeamRegion *Aq, int length_N, BeamRegion *AN,
										 int length_loads, Load *Aloads, int length_constr, Constraint *Aconstr,
										 double *exc_N, double *exc_L ) {
  TPoint points[10];
  TPoint vert[10];
  TPoint point_0;
  int X1, X2, X3, X4, Y1, Y2, Y3, Y4;
  float shift;
  int i, k, n;
  float scale_load;
  double Value;
  double coor_g[30][3];
  double coor_gN[30][3];
  double xf0[20], xf1[20], xf2[2];
  double coor_load[3];
  double direction[3], Sign;
  double t_ar, l_ar, mult_x;

  // Переписать
  Length_beam = Length_rack;
  Len_XY = 0;       // Шаг раскреплений сжатого пояса, заданный в RackLoad

  bool flag_sign = CheckListBox_Show->Checked[1];

  double x0, y0, length, scale, X_shift, Y_shift;

// Получить координаты и длину стойки
  Get_XY_Len(&x0, &y0, &length);
  // Получить масштаб и сдвиги
  Get_scale(&scale, &X_shift, &Y_shift);

  //---------------------------------------------------
  Value = 0;
  for (i=0; i<length_loads; i++) {
	Value = MAX(Value, (ABS(Aloads[i].u)));
	Value = MAX(Value, (ABS(Aloads[i].v)));
  }
  pPen_Width(Image1, 1);
  //pBrush_Color(Image1, clMaroon);
  pBrush_Style(Image1, bsClear);
  if (Length_beam > 0)
	mult_x = length/(Length_beam*L1000);
  else
	mult_x = 1;
  l_ar = MAX(H_beam, length/15);          //L_beam
  t_ar = l_ar/8;
  // Рисовать нагрузки
  if (CheckListBox_Show->Checked[0]) {
	pCanvas_TextOut(Image1, 150 , Image1->Height - 20, "Нагрузки на стойке. Загружение "+IntToStr(k_zagr+1));
	 //--------------------------------------------------------
	// Сосредоточенные нагрузки
	for (i=0; i<length_loads; i++) {
	  if (Aloads[i].u!=0) {
	   pPen_Color(Image1, clRed);
	  // N
	   direction[0] = direction[1] = 0; direction[2] = -1;
	   coor_load[0] = x0;
	   coor_load[1] = y0 - exc_L[i];
	   coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
	   scale_load = ABS(Aloads[i].u/Value);
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_load_ar(Aloads[i].u, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
	   draw_load_ar(Image1, coor_g, Aloads[i].u, flag_sign, 0, 1);   // изображение силы
	  }
	  if (Aloads[i].v!=0) {
		pPen_Color(Image1, clGreen);
	  // Q
		direction[0] = direction[1] = 1; direction[2] = 0;
		coor_load[0] = x0;
		coor_load[1] = y0 - exc_L[i];
		coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
		/*
		switch (index_Qy) {
		case 0:
			coor_load[1] = y0 - H_beam*0.5;
		break;
		case 1:
			coor_load[1] = y0 + H_beam*0.5;
		break;
		case 2:
			coor_load[1] = y0;
		break;
		}
		*/

		scale_load = ABS(Aloads[i].v/Value);
	  // получить экранные координаты точек для рисования нагрузок на геометрии
		get_point_load_ar(-Aloads[i].v, direction, scale_load, coor_load,
					  t_ar, l_ar, coor_g, &Sign);
		draw_load_ar(Image1, coor_g, Aloads[i].v, flag_sign, 1, 1);   // изображение силы
	  }
	  if (Aloads[i].c!=0) {  // Момент My
		pPen_Width(Image1, 1);
		pPen_Color(Image1, clBlue);
	  //
		direction[0] = 1; direction[1] = 0; direction[2] = 0;
		coor_load[0] = x0;
		coor_load[1] = y0 - exc_L[i];
		coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
		get_point_moment(Aloads[i].c, direction, coor_load, coor_g, H_beam*4);
		draw_moment(Image1, coor_g, Aloads[i].c, flag_sign);   // изображение момента
	  }
	  if (CheckListBox_Show->Checked[5]) {
		for (int ii=0; ii<length_loads; ii++) {
		  if (Aloads[i].X==0)
			continue;
		  direction[0] = direction[1] = 1; direction[2] = 0;
		  coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aloads[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		  get_point_dim(direction, coor_load, coor_g);
		  draw_dim(Image1, coor_g, Aloads[i].X);   // изображение размерной линии
		}
	  }
	}
  //--------------------------------------------------------------
  // Погонные поперечные нагрузки
  double Value_max = 0;
  double Value_min = 1e15;
  double xq, yq;
  int    j, nq;

  for (i=0; i<length_q; i++) {
	Value_max = MAX(Value_max, (ABS(Aq[i].begValue)));
	Value_max = MAX(Value_max, (ABS(Aq[i].endValue)));
	Value_min = MIN(Value_min, (ABS(Aq[i].begValue)));
	Value_min = MIN(Value_min, (ABS(Aq[i].endValue)));
  }
  for (i=0; i<length_q; i++) {
	double Value_i = MAX((ABS(Aq[i].begValue)), (ABS(Aq[i].endValue)));
	if (Value_i!=0) {
	  float scale_force, delta_x, delta_y;
	  float delV = Aq[i].begValue - Aq[i].endValue;

	  //scale_force = length*scale/(6*Value_max);
	  //scale_force *= get_scale_mod();

	  scale_force = 0.5*l_ar*scale/Value_max;  //*(ABS(Aq[i].begValue/Value));

	  xq = x0;
	  yq = y0;
	  nq = 1; // количество нагрузок

	  //int index_up = index_Qy;
	  int index_up = 0;
	  double delta_thick;
	  double delta_y0;
	  double b_ax;

	  if (index_composed==0 || index_composed==2 ) {
		 delta_thick = plate_thick;
		 delta_y0 = 0;
		 b_ax = plate_width/2;
	  }
	  else {
		 delta_thick = plate_thick + com_sect.tavr.h2;
		 delta_y0 = -plate_thick;
		 b_ax = com_sect.tavr.b1/2;
	  }
		//index_up = 0;
	  xq = x0;
	  yq = y0;
	  nq = 1;

	  for (j = 0; j<nq; j++, xq = x0 + b_ax) {

		pPen_Color(Image1, clPurple);
		pBrush_Style(Image1, bsClear);

		coor_g[0][0] = xq;
		coor_g[1][0] = xq;
		coor_g[0][1] = yq;
		coor_g[1][1] = yq;
		coor_g[0][2] = (Length_beam - Aq[i].X0)*L1000*mult_x;
		coor_g[1][2] = (Length_beam - (Aq[i].X0 + Aq[i].Len))*L1000*mult_x;

		double midlAq, len, kx, ky, dx, dy;
		double delVx, delVy;

		midlAq = 0.5*(Aq[i].begValue + Aq[i].endValue)*scale_force;
		//midlAq = Aq[i].begValue*scale_force;
		coor_gN[0][0] = xq;  coor_gN[0][1] = coor_g[0][1] - midlAq;  coor_gN[0][2] = coor_g[0][2];
		coor_gN[1][0] = xq;  coor_gN[1][1] = coor_g[1][1] - midlAq;  coor_gN[1][2] = coor_g[1][2];

	  // получить экранные координаты точек распределенной нагрузки
		get_point_q(coor_g);
		get_point_q(coor_gN);

		n = MAX(1, (ABS(coor_g[1][1] - coor_g[0][1]))/30);
		n = ABS(n);
		delta_x = (coor_g[0][0] - coor_g[1][0])/n;
		delta_y = (coor_g[0][1] - coor_g[1][1])/n;

		points[0] = Point(coor_g[0][0], coor_g[0][1]);
		points[1] = Point(coor_gN[0][0], coor_gN[0][1]);
		dx = coor_g[0][0] -  coor_gN[0][0];
		dy = coor_g[0][1] -  coor_gN[0][1];
		len = sqrt(dx*dx + dy*dy);
		kx = dx/len;
		ky = dy/len;
		point_0 = points[0];
		double ss = (coor_g[0][0] -  coor_gN[0][0])/scale_force;
		ss = 1;
		delVx = ss*(Aq[i].endValue - Aq[i].begValue)*scale_force*kx/n;
		delVy = ss*(Aq[i].endValue - Aq[i].begValue)*scale_force*ky/n;
		double mm = ABS(ss*Aq[i].begValue*scale_force);
		for (k=0; k <=n ; k++) {

		  vert[0] = Point(points[0].x - k*delta_x,      points[0].y - k*delta_y);
		  vert[1] = Point(vert[0].x - mm*kx - delVx*k,  vert[0].y - mm*ky - delVy*k);
		  if (k==0)
			points[1] = vert[1];

		  //vert[1] = Point(points[1].x - k*delta_x - delVx*k, points[1].y - k*delta_y - delVy*ky);
		  //vert[1] = Point(points[1].x - k*delta_x - delVx*k - midlAq*kx, points[1].y - k*delta_y - delVy*k - midlAq*ky);
		  CoorAx.PutArrow(vert, 0, MAX_PIC);
		  CoorAx.SetArrow();

		  pPen_Width(Image1, 1);
		  pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
		  pCanvas_Polyline(Image1, CoorAx.Ar, 3);
		}
		points[2] = vert[1];
		pCanvas_Polyline(Image1, points+1, 1);
		points[1] = Point(coor_g[1][0], coor_g[1][1]);
		pCanvas_Polyline(Image1, points, 1);

	  //pFont_Color(Image1, clPurple);
		pBrush_Style(Image1, bsSolid);
		if (flag_sign) {
		   pCanvas_TextOut(Image1, (points[0].x + points[2].x)/2 + 20 , (points[0].y  + points[2].y)/2 - 10, "qz ="+FloatToStr((Aq[i].begValue + Aq[i].endValue)/2)+" кН/м");
		}
		if (CheckListBox_Show->Checked[5]) {
		  for (int ii=0; ii<length_q; ii++) {
			direction[0] = direction[1] = 1; direction[2] = 0;
			coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aq[i].X0)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
			get_point_dim(direction, coor_load, coor_g);
			if (Aq[i].X0!=0)
			  draw_dim(Image1, coor_g, Aq[i].X0);   // изображение размерной линии
			if (Aq[i].X0 + Aq[i].Len==0)
			  continue;
			direction[0] = direction[1] = 1; direction[2] = 0;
			coor_load[0] = x0;   coor_load[1] = y0 - H_beam*0.5;    coor_load[2] = (Length_beam - Aq[i].X0 - Aq[i].Len)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
			get_point_dim(direction, coor_load, coor_g);
			draw_dim(Image1, coor_g, Aq[i].X0 + Aq[i].Len);   // изображение размерной линии
		  }
		}
	  }
	}
  }
  //--------------------------------------------------------------
  // Распределенные нагрузки вдоль балки
  Value = 0;
  for (i=0; i<length_N; i++) {
	Value = MAX(Value, (ABS(AN[i].begValue)));
	Value = MAX(Value, (ABS(AN[i].endValue)));
  }
  int m = 0;
  double mult_x0 = 0.01;
  for (i=0; i<length_N; i++) {
	double Value_i = MAX((ABS(AN[i].begValue)), (ABS(AN[i].endValue)));
	if (Value_i!=0) { // распределенная продольная нагрузка
	  float scale_force, delta_x, delta_y;
	  float delV = AN[i].begValue - AN[i].endValue;

	  scale_force = 0.5*l_ar*scale/Value;

	  pPen_Color(Image1, clBlue);
	  pBrush_Style(Image1, bsClear);

	  coor_g[0][0] = x0;    coor_g[0][2] = (Length_beam - AN[i].X0)*L1000*mult_x;
	  coor_g[1][0] = x0;    coor_g[1][2] = (Length_beam - (AN[i].X0 + AN[i].Len))*L1000*mult_x;

	  coor_g[0][1] = y0 - exc_N[i];
	  coor_g[1][1] = y0 - exc_N[i];

	  coor_gN[0][0] = x0 +  AN[i].begValue*scale_force;  coor_gN[0][1] = coor_g[0][1];  coor_gN[0][2] = coor_g[0][2];
	  coor_gN[1][0] = x0 +  AN[i].endValue*scale_force;  coor_gN[1][1] = coor_g[1][1];  coor_gN[1][2] = coor_g[1][2];

	  // получить экранные координаты точек распределенной нагрузки
	  get_point_q(coor_g);
	  get_point_q(coor_gN);

	  n = MAX(1, (ABS(coor_g[1][1] - coor_g[0][1]))/30);
	  n = ABS(n);
	  delta_x = (coor_g[0][m] - coor_g[1][m])/n;
	  delta_y = (coor_g[0][1] - coor_g[1][1])/n;

	  double delVx = (coor_gN[0][m] - coor_gN[1][m])/n;
	  double delVy = (coor_gN[0][1] - coor_gN[1][1])/n;
	  delV /= n;

	  points[0] = Point(coor_g[0][m], coor_g[0][1]);
	  points[1] = Point(coor_gN[0][m], coor_gN[0][1]);
	  point_0 = points[0];
	  //points[1] = Point(points[0].x + AN[i].begValue*scale_force, points[0].y);
	  double mul = 40.0/(points[0].x - points[1].x);
	  double delx = (points[0].x - points[1].x)*mul;
	  double dely = (points[0].y - points[1].y)*mul;
	  points[1] = Point(points[0].x - delx, points[0].y - dely);
	  for (k=0; k <=n ; k++) {

		vert[1] = Point(points[0].x - k*delta_x, points[0].y - k*delta_y);
		vert[0] = Point(points[1].x - k*delVx,   points[1].y - k*delVy);
		//vert[0] = Point(vert[1].x  + (AN[i].begValue - delV*k)*scale_force, vert[1].y);
		pCanvas_Polyline(Image1, vert, 1);
		points[2] = vert[0]; // для рисования после цикла
		vert[0] = point_0;
		TPoint vert_A[2];
		if (AN[i].begValue - delV*k >0) {
		  vert_A[0] = vert[0];
		  vert_A[1] = vert[1];
		}
		else {
		  vert_A[0] = vert[1];
		  vert_A[1] = vert[0];

		}
		CoorAx.PutArrow(vert_A, 0, MAX_PIC);
		CoorAx.SetArrow();

		pPen_Width(Image1, 1);
		pCanvas_Polyline(Image1, CoorAx.LArrow, 2);
		pCanvas_Polyline(Image1, CoorAx.Ar, 3);

		point_0 = vert[1];
	  }
	  pCanvas_Polyline(Image1, points+1, 1);
	  points[1] = Point(coor_g[1][0], coor_g[1][1]);
	  //pCanvas_Polyline(Image1, points, 1);

	  //pFont_Color(Image1, clPurple);
	  pBrush_Style(Image1, bsSolid);
	  if (flag_sign) {
		 pCanvas_TextOut(Image1, (points[0].x + points[2].x)/2 + 20 , (points[0].y  + points[2].y)/2 - 10,
								  "qN ="+FloatToStr((AN[i].begValue + AN[i].endValue)/2)+" кН/м");
	  }
	  if (CheckListBox_Show->Checked[5]) {
		for (i=0; i<length_N; i++) {
		 direction[0] = direction[1] = 1.0*(SIGN(AN[i].begValue)); direction[2] = 0;
		 coor_load[0] = x0;   coor_load[1] = y0; //- H_beam*0.5;
		 coor_load[2] = (Length_beam - AN[i].X0)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 if (AN[i].X0!=0)
		   draw_dim(Image1, coor_g, AN[i].X0);   // изображение размерной линии
		 coor_load[2] = (Length_beam - AN[i].X0 - AN[i].Len)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 if (AN[i].X0 + AN[i].Len!=0)
		   draw_dim(Image1, coor_g, AN[i].X0 + AN[i].Len);   // изображение размерной линии
		}
	  }
	}
  }
 }
 //--------------------------------------------------------
 // Рисование опор
 if (CheckListBox_Show->Checked[3]) {
	TPoint points[10];
	double sh;
	double scale, x_shift, y_shift;
	double t_c, l_c;
	double x1, y1;

   // Получить масштаб рисования модели
   Get_scale(&scale, &x_shift, &y_shift);
   if (scale > 0.6) {
	   t_c = 6;
	   //l_c = H_beam/3;
	   l_c = 30;
   }
   else {
	   t_c = 6*0.5/scale;
	   //l_c = (H_beam/3)*0.5/scale;
	   l_c = 20/scale;

   }

   for (i=0; i<length_constr; i++) {
	 if (Aconstr[i].u!=0) {  // вдоль оси балки
	   direction[0] = 0; direction[1] = 0; direction[2] = 1;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clFuchsia);
	   pBrush_Color(Image1, clFuchsia);
	   Image1->Canvas->Polygon(points, 6);
	   pBrush_Color(Image1, clWhite);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
					(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));

	   sh = Round(sh, 0);
	   Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	 }

	 if (Aconstr[i].v!=0) {  // вертикальное
	   direction[0] = 0; direction[1] = 1; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clFuchsia);
	   pBrush_Color(Image1, clFuchsia);
	   Image1->Canvas->Polygon(points, 6);
	   pBrush_Color(Image1, clWhite);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
					(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	   sh = Round(sh, 0);
	   Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	 }

	 if (Aconstr[i].c!=0) {  // Поворот
	   direction[0] = 1; direction[1] = 0; direction[2] = 0;
	   coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	   // получить экранные координаты точек для рисования нагрузок на геометрии
	   get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	   for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	   }
	   pPen_Color(Image1, clBlue);
	   pBrush_Color(Image1, clBlue);
	   Image1->Canvas->Polygon(points, 6);
	   sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	   sh = Round(sh, 0);
	   pBrush_Color(Image1, clWhite);
	   Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	   Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
	  //x1 = (coor_g[0][0] + coor_g[3][0])/2;
	  //y1 = (coor_g[0][1] + coor_g[3][1])/2;
	  //Image1->Canvas->Ellipse(x1-sh, y1-sh, x1+sh, y1+sh);
	 }
   }
   // Рисование размерных линий на стойке
   if (CheckListBox_Show->Checked[5]) {
		for (i=0; i<length_constr; i++) {
		 if (Aconstr[i].X==0)
		   continue;
		 direction[0] = direction[1] = 1; direction[2] = 0;
		 coor_load[0] = x0;   coor_load[1] = y0; //- H_beam*0.5;
		 coor_load[2] = (Length_beam - Aconstr[i].X)*L1000*mult_x;
	  // получить экранные координаты точек для рисования размерной линии
		 get_point_dim(direction, coor_load, coor_g);
		 draw_dim(Image1, coor_g, Aconstr[i].X);   // изображение размерной линии
		}
   }

 }
 //-------------------------------------------------------------------------
 //  Рисование раскреплений
 if (CheckListBox_Show->Checked[4]) {
	TPoint points[10];
	double sh;
	double scale, x_shift, y_shift;
	double t_c, l_c;
	double x1, y1;

   // Получить масштаб рисования модели
   Get_scale(&scale, &x_shift, &y_shift);
   if (scale > 0.6) {
	   t_c = 6;
	   //l_c = H_beam/3;
	   l_c = 30;
   }
   else {
	   t_c = 6*0.5/scale;
	   //l_c = (H_beam/3)*0.5/scale;
	   l_c = 20/scale;

   }

   if (Len_XY==0)
	  Len_XY = Length_beam;
   double Length = Length_beam*L1000;
   for (int j=0; j<N_part + 1; j++) {
	 if (j==N_part && index_TY_up==0)
       break;
	  direction[0] = -1; direction[1] = 0; direction[2] = 0;
	  coor_load[0] = x0;   coor_load[1] = y0;    coor_load[2] = Length*mult_x;
	  if (j<N_part)
		Length -= Length_part[j]*L1000;
	  // получить экранные координаты точек для рисования раскреплений на геометрии
	  get_point_constr(direction, coor_load, t_c, l_c, coor_g);
	  for (int i=0; i<7; i++) {
		 points[i] = Point(coor_g[i][0], coor_g[i][1]);
	  }
	  pPen_Color(Image1, clGreen);
	  pBrush_Color(Image1, clGreen);
	  Image1->Canvas->Polygon(points, 6);
	  pBrush_Color(Image1, clWhite);
	  sh = 0.2*sqrt((coor_g[3][0] - coor_g[0][0])*(coor_g[3][0] - coor_g[0][0]) +
				(coor_g[3][1] - coor_g[0][1])*(coor_g[3][1] - coor_g[0][1]));
	  Image1->Canvas->Ellipse(coor_g[3][0]-sh, coor_g[3][1]-sh, coor_g[3][0]+sh, coor_g[3][1]+sh);
	  Image1->Canvas->Ellipse(coor_g[0][0]-sh, coor_g[0][1]-sh, coor_g[0][0]+sh, coor_g[0][1]+sh);
   }
  }
 pPen_Width(Image1, 1);
 Image1->Canvas->Pen->Color = clBlack;

}

//------------------------------------------------------------------------------------------------------
// Штриховка
void __fastcall TDraw_RSU_Frame::Shtrih(TPoint *points, float s_s, float mx, float my) {
	// points - точки линии
	// s_s - шаг штриховки
	// mx, my: +1 или -1  - множители, определяющие направление штриховки
	float delx, dely;
	int k;
	TPoint vert[2];
	float l_s;

	delx = points[1].x - points[0].x;
	dely = points[1].y - points[0].y;
    l_s = sqrt(delx*delx + dely*dely);

	for (k=0; k < l_s; k += s_s) {
	  vert[0] = Point(points[0].x + delx*k/l_s, points[0].y + dely*k/l_s);
      vert[1] = Point(vert[0].x + mx*s_s, vert[0].y +my*s_s);
	  pCanvas_Polygon(Image1, vert, 1);
	}
}

void __fastcall TDraw_RSU_Frame::CheckBox_CentrClick(TObject *Sender)
{
   //
	if (CheckBox_Centr->Checked) {
	   CheckBox_Side->Checked = false;
	}
}
//---------------------------------------------------------------------------

void __fastcall TDraw_RSU_Frame::CheckBox_SideClick(TObject *Sender)
{
  //
	if (CheckBox_Side->Checked) {
	   CheckBox_Centr->Checked = false;
	}
}
//---------------------------------------------------------------------------



