API tools faq
paste
Advertisement
mon0l1t

фигуры

mon0l1t
Sep 29th, 2020
699
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 37.24 KB | None | 0 0
raw download clone embed print report
  1. //---------------------------------------------------------------------------
  2. #include <math.h>
  3. #include <float.h>
  4. #include "UECCore.h"
  5.  
  6. #pragma hdrstop
  7.  
  8. #include "UCFloatPoint.h"
  9. #include <Math.hpp>
  10.  
  11. //---------------------------------------------------------------------------
  12.  
  13. #pragma package(smart_init)
  14. //---------------------------------------------------------------------------
  15. void CFloatPoint::RotatePoint(double angle,bool radian)
  16. {
  17.   double rad;
  18.  
  19.   if (!radian) rad=(M_PI*angle)/180;
  20.   else rad=angle;
  21.  
  22.   double cosa=cos(rad),
  23.          sina=sin(rad);
  24.   double x,y;
  25.   x=m_X; y=m_Y;
  26.   m_X=x*cosa+y*sina;
  27.   m_Y=y*cosa-x*sina;
  28. }
  29. //---------------------------------------------------------------------------
  30. int CFloatPoint::DetectNumChetvertByPoint(CFloatPoint p)
  31. {
  32.   if (p.m_X<m_X)
  33.   {
  34.     if (p.m_Y>m_Y) return 2;
  35.     else return 3;
  36.   }
  37.   else
  38.   {
  39.     if (p.m_Y>m_Y) return 1;
  40.     else return 4;
  41.   }
  42. }
  43. //---------------------------------------------------------------------------
  44. void CFloatPoint::Minus(double x,double y)
  45. {
  46.   m_X-=x;
  47.   m_Y-=y;
  48. }
  49. //---------------------------------------------------------------------------
  50. void CFloatPoint::ChangeValuesKoef(double kx,double ky,int typek,bool mult)
  51. {
  52.   if (kx==0 && ky==0) return;
  53.   if (mult)
  54.   {
  55.     if (typek==0)
  56.     {
  57.       m_X=m_X*(1+kx);
  58.       m_Y=m_Y*(1+ky);
  59.     }
  60.     else if (typek==1)
  61.     {
  62.       m_X=m_X/(1-kx);
  63.       m_Y=m_Y/(1-ky);
  64.     }
  65.   }
  66.   else
  67.   {
  68.     if (typek==0)
  69.     {
  70.       m_X=m_X/(1+kx);
  71.       m_Y=m_Y/(1+ky);
  72.     }
  73.     else if (typek==1)
  74.     {
  75.       m_X=m_X*(1-kx);
  76.       m_Y=m_Y*(1-ky);
  77.     }
  78.   }
  79. }
  80. //---------------------------------------------------------------------------
  81. void CFloatPoint::ChangeEdinIzm(double k)
  82. {
  83.   if (m_X!=MyDBL_MAX) m_X=RoundTo(m_X*k,-1);
  84.   if (m_Y!=MyDBL_MAX) m_Y=RoundTo(m_Y*k,-1);
  85. }
  86. //---------------------------------------------------------------------------
  87. void CFloatPointArray::ChangeEdinIzm(double k)
  88. {
  89.   int i,q=GetCount();
  90.   for (i=0;i<q;i++)
  91.     Get(i)->ChangeEdinIzm(k);
  92. }
  93. //---------------------------------------------------------------------------
  94. void CFloatPointArray::ChangeEdinIzm(int curtype,int type)
  95. {
  96. //  double k=GetKoefEdinIzm(curtype,type);
  97. //  ChangeEdinIzm(k);
  98. }
  99. //---------------------------------------------------------------------------
  100. void CFloatPointArray::Append(CFloatPointArray *parray)
  101. {
  102.   int i,q=parray->GetCount();
  103.   CFloatPoint *p;
  104.   for (i=0;i<q;i++)
  105.   {
  106.     p=parray->Get(i);
  107.     if (GetByXY(p->m_X,p->m_Y)==NULL) Append(p);
  108.   }
  109. }
  110. //---------------------------------------------------------------------------
  111. void CFloatPointArray::CopyAll(CFloatPointArray *parray)
  112. {
  113.   int i,q=parray->GetCount();
  114.   CFloatPoint *p,*fp;
  115.   for (i=0;i<q;i++)
  116.   {
  117.     p=parray->Get(i);
  118.     fp=new CFloatPoint(p);
  119.     Add(fp);
  120.   }
  121. }
  122. //---------------------------------------------------------------------------
  123. int CFloatPointArray::Insert(int ind,CFloatPoint *p)
  124. {
  125.   if (ind>0) {CObectArray::Insert(ind,p); return ind;}
  126.   else { Append(p); return GetCount()-1;}
  127. }
  128. //---------------------------------------------------------------------------
  129. CFloatPoint *CFloatPointArray::GetByXY(double x,double y)
  130. {
  131.   int i,q=GetCount();
  132.   CFloatPoint *p;
  133.   x=RoundTo(x,-2); y=RoundTo(y,-2);
  134.   double px,py;
  135.   for (i=0;i<q;i++)
  136.   {
  137.     p=Get(i);
  138.     px=RoundTo(p->m_X,-2); py=RoundTo(p->m_Y,-2);
  139.     if (px==x && py==y) return p;
  140.   }
  141.   return NULL;
  142. }
  143. //---------------------------------------------------------------------------
  144. CFloatPoint *CFloatPointArray::GetByName(AnsiString name)
  145. {
  146.   int i,q=GetCount();
  147.   CFloatPoint *p;
  148.   for (i=0;i<q;i++)
  149.   {
  150.     p=Get(i);
  151.     if (p->m_Name==name) return p;
  152.   }
  153.   return NULL;
  154. }
  155. //---------------------------------------------------------------------------
  156. CFloatPoint *CFloatPointArray::GetNext(int ind)
  157. {
  158.   int q=GetCount(),i=ind+1;
  159.   if (i<q) return Get(i);
  160.   else return Get(0);
  161. }
  162. //---------------------------------------------------------------------------
  163. CFloatPoint *CFloatPointArray::GetPrev(int ind)
  164. {
  165.   int q=GetCount()-1,i=ind-1;
  166.   if (i<0) return Get(q);
  167.   else return Get(i);
  168. }
  169. //---------------------------------------------------------------------------
  170. CFloatPoint *CFloatPointArray::GetNext(CFloatPoint *p)
  171. {
  172.   int ind=IndexByPoint(p);
  173.   return GetNext(ind);
  174. }
  175. //---------------------------------------------------------------------------
  176. CFloatPoint *CFloatPointArray::GetPrev(CFloatPoint *p)
  177. {
  178.   int ind=IndexByPoint(p);
  179.   return GetPrev(ind);
  180. }
  181. //---------------------------------------------------------------------------
  182. int CFloatPointArray::IndexByName(AnsiString name)
  183. {
  184.   int i,q=GetCount();
  185.   for (i=0;i<q;i++)
  186.     if (Get(i)->m_Name==name) return i;
  187.   return -1;
  188. }
  189. //---------------------------------------------------------------------------
  190. int CFloatPointArray::IndexByPoint(CFloatPoint *p)
  191. {
  192.   int i,q=GetCount();
  193.   for (i=0;i<q;i++)
  194.     if (Get(i)==p) return i;
  195.   return -1;
  196. }
  197. //---------------------------------------------------------------------------
  198. bool CFloatPointArray::PointInLine(double x,double y,CFloatPoint *fp1,CFloatPoint *fp2)
  199. {
  200.   /*double d,px,py;
  201.   //высчитываем дельту...
  202.   double Drob=sqrt((fp2->m_X-fp1->m_X)*(fp2->m_X-fp1->m_X)+(fp2->m_Y2-m_Y1)*(m_Y2-m_Y1));
  203.   if (Drob==0) return false;
  204.   d=fabs(((m_Y1-m_Y2)*x+(m_X2-m_X1)*y+(m_X1*m_Y2-m_X2*m_Y1))/Drob);
  205.  
  206.   if (d<=RECTSIZE*2)
  207.   {
  208.     double a1,b1,c1,a2,b2,c2;
  209.     a1=m_Y1-m_Y2;
  210.     b1=m_X2-m_X1;
  211.     c1=-(m_X1*a1+m_Y1*b1);
  212.  
  213.     a2=b1;
  214.     b2=-a1;
  215.     c2=-(a2*x+b2*y);
  216.  
  217.     if (a1==0.)
  218.     {
  219.       py=-c1/b1;
  220.       px=(-c2-b2*py)/a2;
  221.     }
  222.     else if (b1==0.)
  223.     {
  224.       px=-c1/a1;
  225.       py=(-c2-a2*px)/b2;
  226.     }
  227.     else
  228.     {
  229.       py=(a2*c1-a1*c2)/(a1*b2-a2*b1);
  230.       px=(-b1*py-c1)/a1;
  231.     }
  232.  
  233.     //проверяем принадлежит ли точка отрезку, через сумму длин...
  234.     double len1=ECCore::CalcLengthLine(px,py,m_X1,m_Y1),
  235.            len2=ECCore::CalcLengthLine(px,py,m_X2,m_Y2),
  236.            len =ECCore::CalcLengthLine(m_X1,m_Y1,m_X2,m_Y2);
  237.     double tmp1=RoundTo((len1+len2),-1),tmp2=RoundTo(len,-1);
  238.     if (tmp1>tmp2) return false;
  239.  
  240.     return true;
  241.   }
  242.  
  243.   return false; */
  244. }
  245. //---------------------------------------------------------------------------
  246. bool CFloatPointArray::CheckedLine(double x1,double y1,double x2,double y2)
  247. {
  248.   int i,q=GetCount();
  249.   CFloatPoint *fp1,*fp2;
  250.   double tmp1,tmp2,tmp3,tmp4;
  251.   double tmp5,tmp6,tmp7,tmp8;
  252.   tmp5=ECCore::RoundToCalc(x1,-2); tmp6=ECCore::RoundToCalc(y1,-2);
  253.   tmp7=ECCore::RoundToCalc(x2,-2); tmp8=ECCore::RoundToCalc(y2,-2);
  254.  
  255.   for (i=0;i<q;i++)
  256.   {
  257.     fp1=Get(i);
  258.     fp2=GetNext(i);
  259.  
  260.     tmp1=ECCore::RoundToCalc(fp1->m_X,-2); tmp2=ECCore::RoundToCalc(fp1->m_Y,-2);
  261.     tmp3=ECCore::RoundToCalc(fp2->m_X,-2); tmp4=ECCore::RoundToCalc(fp2->m_Y,-2);
  262.     if (((CompareValue(tmp1,tmp5)==0 && CompareValue(tmp2,tmp6)==0) &&
  263.          (CompareValue(tmp3,tmp7)==0 && CompareValue(tmp4,tmp8)==0)) ||
  264.         ((CompareValue(tmp1,tmp7)==0 && CompareValue(tmp2,tmp8)==0) &&
  265.          (CompareValue(tmp3,tmp5)==0 && CompareValue(tmp4,tmp6)==0)))
  266.     return true;
  267.   }
  268.   return false;
  269. }
  270. //---------------------------------------------------------------------------
  271. double CFloatPointArray::CheckedLineForMFShov(double x1, double y1, double x2, double y2)
  272. {
  273.   double len=0,angle,delta,ll;
  274.  
  275.   CFloatPoint *p1=new CFloatPoint(),
  276.               *p2=new CFloatPoint(),*pp1,*pp2;
  277.   CFloatPoint fp1,fp2;
  278.   fp1.m_X=x1; fp1.m_Y=y1;
  279.   fp2.m_X=x2; fp2.m_Y=y2;
  280.  
  281.   fp1.m_X=0; fp1.m_Y=0;
  282.   fp2.Minus(x1,y1);
  283.  
  284.   angle=ECCore::DetectAngle(fp1.m_X,fp1.m_Y,fp2.m_X,fp2.m_Y,fp2.m_X,fp1.m_Y);
  285.  
  286.   int chet=ECCore::DetectChetvertPoint(fp2.m_X,fp2.m_Y);
  287.   if (chet==2) angle=180-angle;
  288.   else if (chet==3) angle=180+angle;
  289.   else if (chet==4) angle=360-angle;
  290.  
  291.   fp2.RotatePoint(angle);
  292.   Minus(x1,y1);
  293.   RotateAllPoint(angle);
  294.   //функция для подсчета пользовательских швов...
  295.   len=ECCore::CalcLengthLine(fp1.m_X,fp1.m_Y,fp2.m_X,fp2.m_Y);
  296.  
  297.  
  298.  
  299.   int i,q=Count-1;
  300.   for (i=0;i<q;i+=2)
  301.   {
  302.     pp1=Get(i);
  303.     pp2=Get(i+1);
  304.  
  305.     delta=fabs(pp1->m_Y-pp2->m_Y);
  306.     if (delta>3) continue;//если прямая не параллельна оси ОХ
  307.  
  308.     if (pp1->m_X>pp2->m_X) { p1->m_X=pp2->m_X; p2->m_X=pp1->m_X; }
  309.     else { p1->m_X=pp1->m_X; p2->m_X=pp2->m_X; }
  310.  
  311.     p1->m_Y=pp1->m_Y; p2->m_Y=pp2->m_Y;
  312.  
  313.     delta=fabs(p1->m_Y-fp1.m_Y);
  314.     if (delta>3) continue;//3сантиметра погрешность
  315.  
  316.     //идем проверять все случаии, а их 8 штук, строго слева на право!!
  317.  
  318.     //fp1*----------*fp2
  319.     //                      p1*--------------*p2
  320.     if (fp1.m_X<p1->m_X && fp2.m_X<p1->m_X) ll=0;
  321.     //                      fp1*----------*fp2
  322.     //p1*--------------*p2
  323.     else if (fp1.m_X>p1->m_X && fp1.m_X>p2->m_X) ll=0;
  324.     //fp1*-----------------*fp2
  325.     //          p1*----------------*p2
  326.     else if (fp1.m_X<=p1->m_X && fp2.m_X>p1->m_X && fp2.m_X<=p2->m_X)
  327.       ll=ECCore::CalcLengthLine(p1->m_X,p1->m_Y,fp2.m_X,fp2.m_Y);
  328.     //          fp1*-----------------*fp2
  329.     // p1*-----------------*p2
  330.     else if (fp1.m_X>=p1->m_X && fp1.m_X<p2->m_X && fp2.m_X>=p2->m_X)
  331.       ll=ECCore::CalcLengthLine(fp1.m_X,fp1.m_Y,p2->m_X,p2->m_Y);
  332.     //       fp1*-----------------*fp2
  333.     // p1*--------------------------------*p2
  334.     else if (fp1.m_X>=p1->m_X && fp1.m_X<p2->m_X && fp2.m_X<=p2->m_X)
  335.       ll=ECCore::CalcLengthLine(fp1.m_X,fp1.m_Y,fp2.m_X,fp2.m_Y);
  336.     //fp1*-------------------------*fp2
  337.     //       p1*------------*p2
  338.     else if (fp1.m_X<=p1->m_X && fp2.m_X>=p2->m_X)
  339.       ll=ECCore::CalcLengthLine(p1->m_X,p1->m_Y,p2->m_X,p2->m_Y);
  340.     else ll=0;
  341.     len-=ll;
  342.   }
  343.   RotateAllPoint(-angle);
  344.   Minus(-x1,-y1);
  345.  
  346.   if (len<0) len=0;
  347.   return len;
  348. }
  349. //---------------------------------------------------------------------------
  350. void CFloatPointArray::GetGPCPolygon(gpc_polygon *polygon)
  351. {
  352.   CFloatPoint *p;
  353.   int i,ind,q=GetCount(),countpolygon;
  354.   countpolygon=1;
  355.   int *cPoints=new int[q];
  356.   cPoints[0]=q;
  357.   ind=0;
  358.   for (i=0;i<q;i++)
  359.   {
  360.     p=Get(i);
  361.     if (p->m_BeginVirez)
  362.     {
  363.       cPoints[countpolygon-1]=ind;
  364.       countpolygon++;
  365.       ind=0;
  366.     }
  367.     ind++;
  368.   }
  369.   if (countpolygon>1) cPoints[countpolygon-1]=ind;
  370.  
  371.   polygon->num_contours=countpolygon;
  372.   polygon->contour=new gpc_vertex_list[countpolygon];
  373.  
  374.   ind=0;
  375.   polygon->contour[ind].num_vertices=cPoints[ind];
  376.   polygon->contour[ind].vertex=new gpc_vertex[cPoints[ind]];
  377.   int ii=0;
  378.   for (i=0;i<q;i++)
  379.   {
  380.     p=Get(i);
  381.     if (p->m_BeginVirez)
  382.     {
  383.       ind++;
  384.       polygon->contour[ind].num_vertices=cPoints[ind];
  385.       polygon->contour[ind].vertex=new gpc_vertex[cPoints[ind]];
  386.       ii=0;
  387.     }
  388.     polygon->contour[ind].vertex[ii].x=p->m_X;
  389.     polygon->contour[ind].vertex[ii].y=p->m_Y;
  390.     ii++;
  391.   }
  392. }
  393. //---------------------------------------------------------------------------
  394. void CFloatPointArray::ConvertGPCPolygon(gpc_polygon polygon)
  395. {
  396.   int i,j,q,qp=polygon.num_contours;
  397.   CFloatPointArray *array;
  398.   CFloatPoint *fp;
  399.   for (i=0;i<qp;i++)
  400.   {
  401.     fp=new CFloatPoint();
  402.     if (i!=0) fp->m_BeginVirez=true;
  403.     q=polygon.contour[i].num_vertices;
  404.     for (j=0;j<q;j++)
  405.     {
  406.       fp->m_X=polygon.contour[i].vertex[j].x;
  407.       fp->m_Y=polygon.contour[i].vertex[j].y;
  408.       Append(fp);
  409.       fp->m_BeginVirez=false;
  410. //    array->Append(polygon.contour[i].vertex[j].x,polygon.contour[i].vertex[j].y,"",false);//не проверять на одинаковые точки...
  411.     }
  412.   }
  413. }
  414. //---------------------------------------------------------------------------
  415. //---------------------------------------------------------------------------
  416. bool CFloatPointArray::RotateAllPoint(double angle,bool radian)
  417. {
  418.   if (angle==0) return false;
  419.   int i,q=GetCount();
  420.   CFloatPoint *p;
  421.   for (i=0;i<q;i++)
  422.   {
  423.     p=Get(i);
  424.     p->RotatePoint(angle,radian);
  425.   }
  426.   return true;
  427. }
  428.  
  429. //---------------------------------------------------------------------------
  430. void CFloatPointArray::Swap(int ind1,int ind2)
  431. {
  432.   int q=GetCount();
  433.   if (ind1>q || ind2>q || ind1==ind2) return;
  434.  
  435.   CFloatPoint *p1=Get(ind1),*p2=Get(ind2);
  436.   /*CFloatPoint tp(p1->m_X,p1->m_Y);
  437.   tp.m_Name=p1->m_Name;
  438.   tp.m_BeginVirez=p1->m_BeginVirez;
  439.   */
  440.   CFloatPoint tp=*p1;
  441.  
  442.   p1->m_X=p2->m_X;
  443.   p1->m_Y=p2->m_Y;
  444.   p1->m_Name=p2->m_Name;
  445.   p1->m_BeginVirez=p2->m_BeginVirez;
  446.  
  447.   p2->m_X=tp.m_X;
  448.   p2->m_Y=tp.m_Y;
  449.   p2->m_Name=tp.m_Name;
  450.   p2->m_BeginVirez=tp.m_BeginVirez;
  451. }
  452. //---------------------------------------------------------------------------
  453. int CFloatPointArray::Move(int cur,int npos)
  454. {
  455.   int i;
  456.  
  457.   if (cur>npos)
  458.   {
  459.     for (i=cur;i>npos;i--) Swap(i,(i-1));
  460.     return (npos-1);
  461.   }
  462.   else
  463.   {
  464.     for (i=cur;i<npos;i++) Swap(i,(i+1));
  465.     return (npos+1);
  466.   }
  467. }
  468. //---------------------------------------------------------------------------
  469. bool CFloatPointArray::PointInPolygon(double x,double y)
  470. {
  471.   int i,q=GetCount();
  472.   if (q<3) return false;
  473.  
  474.   double xnew,ynew;
  475.   double xold,yold;
  476.   double x1,y1;
  477.   double x2,y2;
  478.   bool inside=false;
  479.   CFloatPoint *fp=Get(q-1);
  480.   xold=fp->m_X;
  481.   yold=fp->m_Y;
  482.  
  483.   for (i=0;i<q;i++)
  484.   {
  485.     fp=Get(i);
  486.     xnew=fp->m_X;
  487.     ynew=fp->m_Y;
  488.  
  489.     if (xnew > xold)
  490.     {
  491.       x1=xold; x2=xnew;
  492.       y1=yold; y2=ynew;
  493.     }
  494.     else
  495.     {
  496.       x1=xnew; x2=xold;
  497.       y1=ynew; y2=yold;
  498.     }
  499.  
  500.     if ((xnew < x) == (x <= xold)         /* edge "open" at left end */
  501.      && (y-y1)*(x2-x1)
  502.       < (y2-y1)*(x-x1))
  503.     {
  504.       inside=!inside;
  505.     }
  506.     xold=xnew;
  507.     yold=ynew;
  508.   }
  509.   return inside;
  510. }
  511. //---------------------------------------------------------------------------
  512. void CFloatPointArray::DeletePointNotPolotno(double shov1,double shov2)
  513. {
  514.   int i,q=GetCount();
  515.   CFloatPoint *p;
  516.   for (i=0;i<q;i++)
  517.   {
  518.     p=Get(i);
  519.     if (shov1<=p->m_Y && p->m_Y<=shov2) continue;
  520.  
  521.     Remove(i); q--; i--;
  522.   }
  523. }
  524. //---------------------------------------------------------------------------
  525. void CFloatPointArray::SortByX()
  526. {
  527.   int i,q=GetCount()-1;
  528.   CFloatPoint *f1,*f2;
  529.   double tmp1,tmp2;
  530.   for (i=0;i<q;i++)
  531.   {
  532.     f1=Get(i); f2=Get(i+1);
  533.     tmp1=RoundTo(f1->m_X,0); tmp2=RoundTo(f2->m_X,0);
  534.     if (tmp1>tmp2)
  535.     {
  536.       Swap(i,i+1);
  537.       i=-1;
  538.     }
  539.   }
  540. }
  541. //---------------------------------------------------------------------------
  542. void CFloatPointArray::SortByYAndX()
  543. {
  544.   int i,j,q=GetCount()-1;
  545.   CFloatPoint *p1,*p2;
  546.   //сортируем по Y (группируя по линиям)
  547.   for (i=0;i<q;i++)
  548.   {
  549.     p1=Get(i); p2=Get(i+1);
  550.     //if (p1->m_Y>p2->m_Y) {Move(i,i+1); i=-1;}
  551.     if (p1->m_Y<p2->m_Y) {Swap(i,i+1); i=-1;}
  552.   }
  553.   //
  554.   double tmp1,tmp2;
  555.   for (i=0;i<q;i++)
  556.   {
  557.     p1=Get(i); p2=Get(i+1);
  558.     tmp1=RoundTo(p1->m_Y,-4); tmp2=RoundTo(p2->m_Y,-4);
  559.     if (tmp1!=tmp2) continue;
  560.  
  561.     if (p1->m_X>p2->m_X) {Swap(i,i+1); i=-1;}
  562.   }
  563. }
  564. //---------------------------------------------------------------------------
  565. void CFloatPointArray::SortByXHight()
  566. {
  567.   int i,j,q=GetCount()-1;
  568.   CFloatPoint *p1,*p2;
  569.   //сортируем по X
  570.   for (i=0;i<q;i++)
  571.   {
  572.     p1=Get(i); p2=Get(i+1);
  573.     //if (p1->m_Y>p2->m_Y) {Move(i,i+1); i=-1;}
  574.     if (p1->m_X>p2->m_X) {Swap(i,i+1); i=-1;}
  575.   }
  576. }
  577. //---------------------------------------------------------------------------
  578. void CFloatPointArray::SortNameInPoints()
  579. {
  580.   int i,j,q=GetCount()-1;
  581.   CFloatPoint *p1,*p2;
  582.   AnsiString tp;
  583.   //сортируем по Y (группируя по линиям)
  584.   for (i=0;i<q;i++)
  585.   {
  586.     p1=Get(i); p2=Get(i+1);
  587.     if (p1->m_Name=="" || p2->m_Name=="") continue;
  588.  
  589.     if (p1->m_Name>p2->m_Name)
  590.     {
  591.       tp=p1->m_Name;
  592.       p1->m_Name=p2->m_Name;
  593.       p2->m_Name=tp;
  594.       i=-1;
  595.     }
  596.   }
  597. }
  598. //---------------------------------------------------------------------------
  599. void CFloatPointArray::SortByName()
  600. {
  601.   int i,q=GetCount()-1;
  602.   CFloatPoint *f1,*f2;
  603.   for (i=0;i<q;i++)
  604.   {
  605.     f1=Get(i); f2=Get(i+1);
  606.     if (f1->m_Name>f2->m_Name)
  607.     {
  608.       Swap(i,i+1);
  609.       i=-1;
  610.     }
  611.   }
  612. }
  613. //---------------------------------------------------------------------------
  614. void CFloatPointArray::ChangeBaseAngle(int PosXY)
  615. {
  616.   CFloatPoint Min,Max,*point;
  617.   double tdx,tdy;
  618.   GetMinMaxXY(Min,Max);
  619.   int i,q=GetCount();
  620.   for (i=0;i<q;i++)
  621.   {
  622.     point=Get(i);
  623.     if (PosXY==2 || PosXY==3) { tdx=Max.m_X-point->m_X; point->m_X=tdx;}
  624.     if (PosXY==1 || PosXY==3) { tdy=Max.m_Y-point->m_Y; point->m_Y=tdy;}
  625.   }
  626. }
  627. //---------------------------------------------------------------------------
  628. void CFloatPointArray::DeleteDuplicate()
  629. {
  630.   //изменил в версии 1.35
  631.   /*int i,j,q=GetCount();
  632.   CFloatPoint *p1,*p2;
  633.  
  634.   for (i=0;i<q;i++)
  635.   {
  636.     p1=Get(i);
  637.     for (j=i+1;j<q;j++)
  638.     {
  639.       if (i==j) continue;
  640.       p2=Get(j);
  641.  
  642.       if (p1->m_Name!="" && p1->m_Name==p2->m_Name)
  643.       {
  644.         Remove(j);
  645.         i--; q--;
  646.         break;
  647.       }
  648.     }
  649.   }*/
  650.   int i,j,q=GetCount();
  651.   CFloatPoint *p1,*p2;
  652.  
  653.   for (i=0;i<q;i++)
  654.   {
  655.     p1=Get(i);
  656.     p2=GetNext(i);
  657.     if (p1->m_Name!="" && p1->m_Name==p2->m_Name)
  658.     {
  659.       Remove(i);
  660.       i--; q--;
  661.     }
  662.   }
  663.  
  664. }
  665. //---------------------------------------------------------------------------
  666. void CFloatPointArray::GetMinMaxXY(CFloatPoint &Min,CFloatPoint &Max)
  667. {
  668.   int i,q=GetCount();
  669.   Min.m_X=Min.m_Y=Max.m_X=Max.m_Y=MyDBL_MAX;
  670.   CFloatPoint *p;
  671.   for (i=0;i<q;i++)
  672.   {
  673.     p=Get(i);
  674.     if (Min.m_X==MyDBL_MAX || p->m_X<Min.m_X) Min.m_X=p->m_X;
  675.     if (Min.m_Y==MyDBL_MAX || p->m_Y<Min.m_Y) Min.m_Y=p->m_Y;
  676.     if (Max.m_X==MyDBL_MAX || p->m_X>Max.m_X) Max.m_X=p->m_X;
  677.     if (Max.m_Y==MyDBL_MAX || p->m_Y>Max.m_Y) Max.m_Y=p->m_Y;
  678.   }
  679. }
  680. //---------------------------------------------------------------------------
  681. UnicodeString CFloatPointArray::LoadFromString(UnicodeString str)
  682. {
  683.   int pos=0,q=str.Length();
  684.   UnicodeString res;
  685.   int i,qq,v;
  686.   CFloatPoint *fp;
  687.  
  688.   pos=str.Pos(";");
  689.   qq=StrToInt(str.SubString(1,pos-1));
  690.   str=str.SubString(pos+1,q-pos);
  691.  
  692.   for (i=0;i<qq;i++)
  693.   {
  694.     fp=new CFloatPoint();
  695.  
  696.     pos=str.Pos(";");
  697.     fp->m_Name=str.SubString(1,pos-1);
  698.     str=str.SubString(pos+1,q-pos);
  699.  
  700.     pos=str.Pos(";");
  701.     fp->m_X=ECCore::MyStrToFloat(str.SubString(1,pos-1));
  702.     str=str.SubString(pos+1,q-pos);
  703.  
  704.     pos=str.Pos(";");
  705.     fp->m_Y=ECCore::MyStrToFloat(str.SubString(1,pos-1));
  706.     str=str.SubString(pos+1,q-pos);
  707.  
  708.     pos=str.Pos(";");
  709.     v=StrToInt(str.SubString(1,pos-1));
  710.     str=str.SubString(pos+1,q-pos);
  711.  
  712.     if (v==0) fp->m_BeginVirez=false;
  713.     else fp->m_BeginVirez=true;
  714.  
  715.     Add(fp);
  716.   }
  717.  
  718.   return str;
  719. }
  720. //---------------------------------------------------------------------------
  721. void CFloatPointArray::SaveToDXF(UnicodeString FileName)
  722. {
  723. //  PolygonsArray polygonArray;
  724. //  MyPolygon *polygon=new MyPolygon();
  725. //  Vertex2D vertex;
  726. //  int i,q=Count;
  727. //  CFloatPoint *curpoint;
  728. //  for (i=0;i<q;i++)
  729. //  {
  730. //  curpoint=Get(i);
  731. //  if (curpoint->m_BeginVirez)
  732. //  {
  733. //    polygon->closed = true;
  734. //    polygonArray.push_back(*polygon);
  735. //    polygon=new MyPolygon();
  736. //  }
  737. //  vertex.x = curpoint->m_X; vertex.y = curpoint->m_Y;
  738. //  polygon->vertices.push_back(vertex);
  739. //  }
  740. //  polygon->closed = true;
  741. //  polygonArray.push_back(*polygon);
  742. //
  743. //  AnsiString file=FileName;
  744. //  CFloatPoint min,max;
  745. //  GetMinMaxXY(min,max);
  746. //  bool result = writePolygonDXF(file.c_str(), polygonArray,min.m_X,min.m_Y,max.m_X,max.m_Y);
  747.  
  748.   /*#define DXF_HEADER "0\r\nSECTION\r\n2\r\nENTITIES\r\n"
  749.   #define DXF_LINEHEADER "0\r\LINE\r\n10\r\n%.06f\r\n20\r\n%.06f\r\n"
  750.   #define DXF_LINEFOOTER "11\r\n%.06f\r\n21\r\n%.06f\r\n"
  751.   #define DXF_FOOTER "0\r\nENDSEC"*/
  752.  
  753.  
  754.   /*HANDLE hFile;
  755.   if((hFile = CreateFileW(FileName.w_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL)) != INVALID_HANDLE_VALUE)
  756.   {
  757.     DWORD dwWritten;
  758.     WriteFile(hFile, DXF_HEADER, lstrlen(DXF_HEADER), &dwWritten, NULL);
  759.     CFloatPoint *firstpoint = Get(0);
  760.     CHAR * buf = new CHAR[256];
  761.     CFloatPoint *curpoint;
  762.     CFloatPoint *prevpoint;
  763.     int i,q=Count;
  764.     for (i = 1; i <= q; i++)
  765.     {
  766.       if (i == Count)
  767.       {
  768.         curpoint = (CFloatPoint *)Get(i-1);
  769.         prevpoint = firstpoint;
  770.       }
  771.       else
  772.       {
  773.         curpoint = (CFloatPoint *)Get(i);
  774.         if(curpoint->m_BeginVirez)
  775.         {
  776.           curpoint = (CFloatPoint *)Get(i-1);
  777.           prevpoint = firstpoint;
  778.         }
  779.         else
  780.           prevpoint = (CFloatPoint *)Get(i-1);
  781.  
  782.         if(prevpoint->m_BeginVirez)
  783.         {
  784.           firstpoint = prevpoint;
  785.         }
  786.       }
  787.       sprintf((CHAR *)&buf[0], DXF_LINEHEADER, curpoint->m_X, curpoint->m_Y);
  788.             WriteFile(hFile, buf, lstrlen((CHAR *)&buf[0]), &dwWritten, NULL);
  789.       sprintf((CHAR *)&buf[0], DXF_LINEFOOTER, prevpoint->m_X, prevpoint->m_Y);
  790.             WriteFile(hFile, buf, lstrlen((CHAR *)&buf[0]), &dwWritten, NULL);
  791.     }
  792.  
  793.     WriteFile(hFile, DXF_FOOTER, lstrlen(DXF_FOOTER), &dwWritten, NULL);
  794.     delete[] buf;
  795.   }
  796.   CloseHandle(hFile);  */
  797.  
  798. }
  799. //---------------------------------------------------------------------------
  800. void CFloatPointArray::Minus(double x,double y)
  801. {
  802.   int i,q=GetCount();
  803.   for (i=0;i<q;i++)
  804.     Get(i)->Minus(x,y);
  805. }
  806. //---------------------------------------------------------------------------
  807. void CFloatPointArray::Invert()
  808. {
  809.   int i,q=GetCount();
  810.   CFloatPoint *p;
  811.   for (i=0;i<q;i++)
  812.   {
  813.     p=Get(i);
  814.     p->m_X*=-1;
  815.   }
  816. }
  817. //---------------------------------------------------------------------------
  818. UnicodeString CFloatPointArray::SaveToStr()
  819. {
  820.   UnicodeString str;
  821.   int i,q=GetCount();
  822.   CFloatPoint *fp;
  823.   str=q; str+=";";
  824.   for (i=0;i<q;i++)
  825.   {
  826.     fp=Get(i);
  827.  
  828.     str+=fp->m_Name; str+=";";
  829.     str+=fp->m_X;    str+=";";
  830.     str+=fp->m_Y;    str+=";";
  831.  
  832.     if (fp->m_BeginVirez) str+="1;";
  833.     else str+="0;";
  834.   }
  835.   return str;
  836. }
  837. //---------------------------------------------------------------------------
  838. double CFloatPointArray::CalcPlochad(bool virez)
  839. {
  840.   int i,q=GetCount(),qp=q;
  841.   if (virez)
  842.   {
  843.     for (i=0;i<q;i++)
  844.       if (Get(i)->m_BeginVirez) {qp=i; break;}
  845.   }
  846.  
  847.   double s,sresv=0,resv=0,res=0,sd;
  848.   // Расчет площади многоугольника через сумму площадей трапеций
  849.   for (i = 0; i < qp; i++)
  850.   {
  851.     if (i == 0)
  852.     {
  853.       s = Get(i)->m_X*(Get(qp-1)->m_Y - Get(i+1)->m_Y); //если i == 0, то y[i-1] заменяем на y[n-1]
  854.       res += s;
  855.     }
  856.     else if (i == qp-1)
  857.     {
  858.       s = Get(i)->m_X*(Get(i-1)->m_Y - Get(0)->m_Y); // если i == n-1, то y[i+1] заменяем на y[0]
  859.       res += s;
  860.     }
  861.     else
  862.     {
  863.       s = Get(i)->m_X*(Get(i-1)->m_Y - Get(i+1)->m_Y);
  864.       res += s;
  865.     }
  866.   }
  867.   sd = fabs(res/2);
  868.  
  869.   //внутренний вырез
  870.   if (virez)
  871.   {
  872.     int ib=qp;
  873.     for (i = qp; i < q; i++)
  874.     {
  875.       if (i == ib)
  876.       {
  877.         s = Get(i)->m_X*(Get(q-1)->m_Y - Get(i+1)->m_Y); //если i == 0, то y[i-1] заменяем на y[n-1]
  878.         resv += s;
  879.       }
  880.       else if ((i == q-1) || Get(i+1)->m_BeginVirez)
  881.       {
  882.         s = Get(i)->m_X*(Get(i-1)->m_Y - Get(ib)->m_Y); // если i == n-1, то y[i+1] заменяем на y[0]
  883.         resv += s;
  884.         ib=i+1; sresv+=fabs(resv/2); resv=0;
  885.       }
  886.       else
  887.       {
  888.         s = Get(i)->m_X*(Get(i-1)->m_Y - Get(i+1)->m_Y);
  889.         resv += s;
  890.       }
  891.     }
  892.     sd-=sresv;
  893.   }
  894.  
  895.   return sd;
  896. }
  897. //---------------------------------------------------------------------------
  898. double CFloatPointArray::SideLength(double x1,double y1,double x2,double y2)
  899. {
  900.   double a = sqrt((x2-x1)/10*(x2-x1)/10+(y2-y1)/10*(y2-y1)/10);
  901.   return a*10;
  902. }
  903. //---------------------------------------------------------------------------
  904. int CFloatPointArray::GetPointByCircle(double x1,double y1,double r1,double x2,double y2,double r2,
  905.                                          double &rx1,double &ry1,double &rx2,double &ry2)
  906. {
  907.   const double EPS = 0.000001;
  908.  
  909.   x2-=x1; y2-=y1;
  910.   //
  911.   double a=-2*x2, b=-2*y2, c=x2*x2+y2*y2+r1*r1-r2*r2,ab;
  912.  
  913.   if ((a*a+b*b)==0.) return 0;
  914.  
  915.   double x0 = -a*c/(a*a+b*b), y0 = -b*c/(a*a+b*b),tmp;
  916.  
  917.   double res1=c*c,
  918.          res2=r1*r1*(a*a+b*b);
  919.   //if (c*c>(r1*r1*(a*a+b*b)+EPS)) return ccNone;
  920.   //else if (fabs(c*c-r1*r1*(a*a+b*b))<EPS)
  921.   if (CompareValue(res1,res2+EPS)>0) return 0;
  922.   else if (CompareValue(fabs(res1-res2),EPS)<0)
  923.   {
  924.     rx1=x1+x0;
  925.     ry1=y1+y0;
  926.     return 1;
  927.   }
  928.   else
  929.   {
  930.     double d = r1*r1 - c*c*1.0/(a*a+b*b);
  931.     double mult; //double mult = sqrt (d / (a*a+b*b));
  932.     if (d<=0.) mult=0;
  933.     else mult = sqrt (d / (a*a+b*b));
  934.     double ax,ay,bx,by;
  935.     ax = x0 + b * mult;
  936.     bx = x0 - b * mult;
  937.     ay = y0 - a * mult;
  938.     by = y0 + a * mult;
  939.  
  940.     rx1=x1+ax; ry1=y1+ay;
  941.     rx2=x1+bx; ry2=y1+by;
  942.     return 2;
  943.   }
  944. }
  945. //---------------------------------------------------------------------------
  946. CFloatPoint *CFloatPointArray::GetCrossPointTwoLine(CFloatPoint p1,CFloatPoint p2,CFloatPoint P1,CFloatPoint P2)
  947. {
  948.   //проверяем на наличее общей точки...
  949.   if ((CompareValue(p1.m_X,P1.m_X,0.0001)==0 && CompareValue(p1.m_Y,P1.m_Y,0.0001)==0) ||
  950.       (CompareValue(p1.m_X,P2.m_X,0.0001)==0 && CompareValue(p1.m_Y,P2.m_Y,0.0001)==0))
  951.     return new CFloatPoint(p1.m_X,p1.m_Y);
  952.   else if ((CompareValue(p2.m_X,P2.m_X,0.0001)==0 && CompareValue(p2.m_Y,P2.m_Y,0.0001)==0) ||
  953.            (CompareValue(p2.m_X,P1.m_X,0.0001)==0 && CompareValue(p2.m_Y,P1.m_Y,0.0001)==0))
  954.     return new CFloatPoint(p2.m_X,p2.m_Y);
  955.   //
  956.   CFloatPoint b,d,c,dd,I;
  957.   b.m_X=p2.m_X-p1.m_X;
  958.   b.m_Y=p2.m_Y-p1.m_Y;
  959.  
  960.   d.m_X=P2.m_X-P1.m_X;
  961.   d.m_Y=P2.m_Y-P1.m_Y;
  962.  
  963.   c.m_X=P1.m_X-p1.m_X;
  964.   c.m_Y=P1.m_Y-p1.m_Y;
  965.  
  966.   dd.m_X=-d.m_Y;
  967.   dd.m_Y= d.m_X;
  968.  
  969.   double ddxc,ddxb,t;
  970.   ddxc=dd.m_X*c.m_X+dd.m_Y*c.m_Y;
  971.   ddxb=dd.m_X*b.m_X+dd.m_Y*b.m_Y;
  972.  
  973.   if (ddxb==0) return NULL;//отрезки паралельны...
  974.  
  975.   t=ddxc/ddxb;
  976.  
  977.   I.m_X=p1.m_X+t*b.m_X;
  978.   I.m_Y=p1.m_Y+t*b.m_Y;
  979.  
  980.   double x,y;
  981.   x=RoundTo(I.m_X,-4); y=RoundTo(I.m_Y,-4);
  982.  
  983.   //проверяем является ли эти две отрезка одно прямой...
  984.   //double maxX,minX,maxY,minY;
  985.   //if (p2.m_X>P2.m_X) maxX=p2.m_X
  986.  
  987.   return new CFloatPoint(x,y);
  988. }
  989. //---------------------------------------------------------------------------
  990. CFloatPointArray *CFloatPointArray::GetCrossPoint(CFloatPoint P1,CFloatPoint P2,bool line2point,bool NotPointLine,bool TwinsPoint,bool Epsilon)
  991. {
  992.   //TwinsPoint - избегать такого же отрезока
  993.   CFloatPointArray *PointArray=new CFloatPointArray();
  994.   CFloatPoint *p1,*p2;
  995.   CFloatPoint *newp,*tp;
  996.   //перебераем точки в основной схеме...
  997.   int i,i2,q=GetCount();
  998.   AnsiString s;
  999.   double t1,t2,t3,t4;
  1000.   for (i=0;i<q;i++)
  1001.   {
  1002.     p1=Get(i);
  1003.     i2=i+1;
  1004.     if (i2==q) p2=Get(0);
  1005.     else p2=Get(i2);
  1006.  
  1007.     if (TwinsPoint)
  1008.     {
  1009.       if (CompareValue(p1->m_X,P1.m_X)==0 && CompareValue(p1->m_Y,P1.m_Y)==0 &&
  1010.           CompareValue(p2->m_X,P2.m_X)==0 && CompareValue(p2->m_Y,P2.m_Y)==0) continue;
  1011.     }
  1012.  
  1013.     newp=GetCrossPoint(p1,p2,P1,P2,line2point,NotPointLine);
  1014.     if (newp==NULL) continue;
  1015.     else if (TwinsPoint)
  1016.     {
  1017.       t1=RoundTo(p1->m_X,-4); t2=RoundTo(p1->m_Y,-4);
  1018.       t3=RoundTo(p2->m_X,-4); t4=RoundTo(p2->m_Y,-4);
  1019.       if ((CompareValue(t1,newp->m_X)==0 && CompareValue(t2,newp->m_Y)==0) ||
  1020.           (CompareValue(t3,newp->m_X)==0 && CompareValue(t4,newp->m_Y)==0)) continue;
  1021.     }
  1022.  
  1023.     if (Epsilon)
  1024.     {
  1025.       t1=fabs(fabs(p1->m_X-p2->m_X)-fabs(P1.m_X-P2.m_X));
  1026.       t2=fabs(fabs(p1->m_Y-p2->m_Y)-fabs(P1.m_Y-P2.m_Y));
  1027.       if (CompareValue(t1,5.)<=0 || CompareValue(t2,5.)<=0) continue;//2 это сантиметры, допустимое окно для пересечения на случай мнимого разреза...
  1028.     }
  1029.     s=p1->m_Name; s+=p2->m_Name;
  1030.     newp->m_Name=s;
  1031.     PointArray->Append(newp);
  1032.   }
  1033.   return PointArray;
  1034. }
  1035. //---------------------------------------------------------------------------
  1036. CFloatPoint *CFloatPointArray::GetCrossPoint(CFloatPoint *p1,CFloatPoint *p2,CFloatPoint P1,CFloatPoint P2,bool line2point,bool NotPointLine)
  1037. {
  1038.   try
  1039.   {
  1040.     CFloatPoint b,d,c,dd,I;
  1041.     b.m_X=p2->m_X-p1->m_X;
  1042.     b.m_Y=p2->m_Y-p1->m_Y;
  1043.  
  1044.     if (CompareValue(p2->m_X,p1->m_X)==0) b.m_X=0.;
  1045.     if (CompareValue(p2->m_Y,p1->m_Y)==0) b.m_Y=0.;
  1046.  
  1047.     d.m_X=P2.m_X-P1.m_X;
  1048.     d.m_Y=P2.m_Y-P1.m_Y;
  1049.  
  1050.     c.m_X=P1.m_X-p1->m_X;
  1051.     c.m_Y=P1.m_Y-p1->m_Y;
  1052.  
  1053.     dd.m_X=-d.m_Y;
  1054.     dd.m_Y= d.m_X;
  1055.  
  1056.     double ddxc,ddxb,t;
  1057.     ddxc=dd.m_X*c.m_X+dd.m_Y*c.m_Y;
  1058.     ddxb=dd.m_X*b.m_X+dd.m_Y*b.m_Y;
  1059.  
  1060.     //if (CompareValue(ddxb,0.)==0) return NULL;//отрезки паралельны...
  1061.     if (RoundTo(ddxb,-4)==0.) return NULL;//отрезки паралельны...
  1062.     if (ddxb==DBL_MAX) return NULL;//отрезки паралельны...
  1063.  
  1064.     t=ddxc/ddxb;
  1065.  
  1066.     //if (t>1 || t<0) return NULL;
  1067.  
  1068.     I.m_X=p1->m_X+t*b.m_X;
  1069.     I.m_Y=p1->m_Y+t*b.m_Y;
  1070.  
  1071.     //проверка на пренадлежность точек отрезкам...
  1072.     //формируем правельную область пряпоугольников...
  1073.     double x,y,xA,xB,yA,yB,xC,xD,yC,yD;
  1074.  
  1075.     xA=RoundTo(p1->m_X,-4); yA=RoundTo(p1->m_Y,-4);
  1076.     xB=RoundTo(p2->m_X,-4); yB=RoundTo(p2->m_Y,-4);
  1077.     //
  1078.     xC=RoundTo(P1.m_X,-4); yC=RoundTo(P1.m_Y,-4);
  1079.     xD=RoundTo(P2.m_X,-4); yD=RoundTo(P2.m_Y,-4);
  1080.  
  1081.     x=RoundTo(I.m_X,-4);
  1082.     y=RoundTo(I.m_Y,-4);
  1083.  
  1084.     if (xA>xB) {t=xB; xB=xA; xA=t;}
  1085.     if (yA>yB) {t=yB; yB=yA; yA=t;}
  1086.  
  1087.     if (xC>xD) {t=xD; xD=xC; xC=t;}
  1088.     if (yC>yD) {t=yD; yD=yC; yC=t;}
  1089.  
  1090.     bool yes=false;
  1091.     //if ((xA<=x && x<=xB)&&(yA<=y && y<=yB))
  1092.     if ((CompareValue(xA,x)<=0 && CompareValue(x,xB)<=0)&&
  1093.         (CompareValue(yA,y)<=0 && CompareValue(y,yB)<=0))
  1094.     {
  1095.       //проверка на пренодлежность найденой точки ОТРЕЗКУ!!!
  1096.       if (line2point)
  1097.       {
  1098.         //if ((xC<=x && x<=xD)&&(yC<=y && y<=yD)) yes=true;
  1099.         if ((CompareValue(xC,x)<=0 && CompareValue(x,xD)<=0)&&
  1100.             (CompareValue(yC,y)<=0 && CompareValue(y,yD)<=0)) yes=true;
  1101.         else yes=false;
  1102.       }
  1103.       else yes=true;
  1104.  
  1105.       //проверка является ли найденая точка одной из точккой концов отреков...
  1106.       if (NotPointLine)
  1107.       {
  1108.         /*if ((CompareValue(xC,x)==0 && CompareValue(yC,y)==0) ||
  1109.             (CompareValue(x,xD)==0 && CompareValue(y,yD)==0) ||
  1110.             (CompareValue(xA,x)==0 && CompareValue(yA,y)==0) ||
  1111.             (CompareValue(x,xB)==0 && CompareValue(y,yB)==0)) yes=false;*/
  1112.          double tx=RoundTo(p1->m_X,-4),ty=RoundTo(p1->m_Y,-4);
  1113.          if (CompareValue(tx,x)==0 && CompareValue(ty,y)==0) yes=false;
  1114.  
  1115.          tx=RoundTo(p2->m_X,-4),ty=RoundTo(p2->m_Y,-4);
  1116.          if (CompareValue(tx,x)==0 && CompareValue(ty,y)==0) yes=false;
  1117.  
  1118.          tx=RoundTo(P1.m_X,-4),ty=RoundTo(P1.m_Y,-4);
  1119.          if (CompareValue(tx,x)==0 && CompareValue(ty,y)==0) yes=false;
  1120.  
  1121.          tx=RoundTo(P2.m_X,-4),ty=RoundTo(P2.m_Y,-4);
  1122.          if (CompareValue(tx,x)==0 && CompareValue(ty,y)==0) yes=false;
  1123.       }
  1124.  
  1125.       if (!yes) return NULL;
  1126.       CFloatPoint *newP=new CFloatPoint(x,y);
  1127.       return newP;
  1128.     }
  1129.     return NULL;
  1130.   }
  1131.   catch(...)
  1132.   {return NULL;}
  1133. }
  1134. //---------------------------------------------------------------------------
  1135. CFloatPointArrayArray::CFloatPointArrayArray(CFloatPointArrayArray *mass)
  1136. {
  1137.   int i,j,q,q1;
  1138.   CFloatPointArray *array,*newarray;
  1139.  
  1140.   q1=mass->GetCount();
  1141.   for (j=0;j<q1;j++)
  1142.   {
  1143.     array=mass->Get(j);
  1144.     q=array->GetCount();
  1145.     newarray=new CFloatPointArray();
  1146.     for (i=0;i<q;i++)
  1147.       newarray->Append(array->Get(i),false);
  1148.     newarray->m_GPC=array->m_GPC;
  1149.     Append(newarray);
  1150.   }
  1151. }
  1152. //---------------------------------------------------------------------------
  1153. bool CFloatPointArrayArray::CheckedLine(double x1,double y1,double x2,double y2)
  1154. {
  1155.   int i,q=GetCount();
  1156.   CFloatPointArray *array;
  1157.   bool res;
  1158.  
  1159.   for (i=0;i<q;i++)
  1160.   {
  1161.     array=Get(i);
  1162.     res=array->CheckedLine(x1,y1,x2,y2);
  1163.     if (res) return true;
  1164.   }
  1165.   return false;
  1166. }
  1167. //---------------------------------------------------------------------------
  1168. int CFloatPointArrayArray::GetCountPoints()
  1169. {
  1170.   int i,j,q1,q=GetCount(),count=0;
  1171.   CFloatPointArray *pol;
  1172.   for (i=0;i<q;i++)
  1173.   {
  1174.     pol=Get(i);
  1175.     count+=pol->GetCount();
  1176.   }
  1177.   return count;
  1178. }
  1179. //---------------------------------------------------------------------------
  1180. void CFloatPointArrayArray::Append(CFloatPointArrayArray *array)
  1181. {
  1182.   int i,q=array->GetCount();
  1183.   for (i=0;i<q;i++)
  1184.     Append(array->Get(i));
  1185. }
  1186. //---------------------------------------------------------------------------
  1187. void CFloatPointArrayArray::GetMinMaxXY(CFloatPoint &Min,CFloatPoint &Max)
  1188. {
  1189.   int i,q=GetCount();
  1190.   Min.m_X=Min.m_Y=MyDBL_MAX;
  1191.   Max.m_X=Max.m_Y=MyDBL_MAX;
  1192.  
  1193.   CFloatPoint tMin,tMax;
  1194.  
  1195.  
  1196.   for (i=0;i<q;i++)
  1197.   {
  1198.     Get(i)->GetMinMaxXY(tMin,tMax);
  1199.     if (Min.m_X==MyDBL_MAX || Min.m_X>tMin.m_X) Min.m_X=tMin.m_X;
  1200.     if (Min.m_Y==MyDBL_MAX || Min.m_Y>tMin.m_Y) Min.m_Y=tMin.m_Y;
  1201.  
  1202.     if (Max.m_X==MyDBL_MAX || Max.m_X<tMax.m_X) Max.m_X=tMax.m_X;
  1203.     if (Max.m_Y==MyDBL_MAX || Max.m_Y<tMax.m_Y) Max.m_Y=tMax.m_Y;
  1204.   }
  1205. }
  1206. //---------------------------------------------------------------------------
  1207. void CFloatPointArrayArray::ChangeValuesKoef(double kx,double ky, int typek,bool mult)
  1208. {
  1209.   int i,q=GetCount();
  1210.   for (i=0;i<q;i++)
  1211.     Get(i)->ChangeValuesKoef(kx,ky,typek,mult);
  1212. }
  1213. //---------------------------------------------------------------------------
  1214. //void CFloatPointArrayArray::ConvertGPCPolygon(gpc_polygon polygon)
  1215. //{
  1216. //  int i,j,q,qp=polygon.num_contours;
  1217. //  CFloatPointArray *array;
  1218. //  for (i=0;i<qp;i++)
  1219. //  {
  1220. //    array=new CFloatPointArray();
  1221. //    q=polygon.contour[i].num_vertices;
  1222. //    for (j=0;j<q;j++)
  1223. //    {
  1224. //      array->Append(polygon.contour[i].vertex[j].x,polygon.contour[i].vertex[j].y,"",false);//не проверять на одинаковые точки...
  1225. //    }
  1226. //    Append(array);
  1227. //  }
  1228. //}
  1229. ////---------------------------------------------------------------------------
  1230. //void CFloatPointArrayArray::GetGPCPolygon(gpc_polygon *polygon)
  1231. //{
  1232. //  CFloatPoint *p;
  1233. //  CFloatPointArray *parray;
  1234. //  int i,j,ind,q=GetCount(),qp;
  1235. //  polygon->num_contours=q;
  1236. //  polygon->contour=new gpc_vertex_list[q];
  1237. //  ind=0;
  1238. //  for (i=0;i<q;i++)
  1239. //  {
  1240. //    parray=Get(i);
  1241. //    qp=parray->GetCount();
  1242. //    polygon->contour[ind].num_vertices=qp;
  1243. //    polygon->contour[ind].vertex=new gpc_vertex[qp];
  1244. //    for (j=0;j<qp;j++)
  1245. //    {
  1246. //      p=parray->Get(j);
  1247. //      polygon->contour[ind].vertex[j].x=p->m_X;
  1248. //      polygon->contour[ind].vertex[j].y=p->m_Y;
  1249. //    }
  1250. //    ind++;
  1251. //  }
  1252. //}
  1253.  
  1254. //---------------------------------------------------------------------------
  1255. void CFloatPointArrayArray::RotateAllPoint(double angle,bool radian)
  1256. {
  1257.   int i,q=GetCount();
  1258.   for (i=0;i<q;i++)
  1259.     Get(i)->RotateAllPoint(angle,radian);
  1260. }
  1261. //---------------------------------------------------------------------------
  1262. void CFloatPointArrayArray::SortPointByCentr()
  1263. {
  1264.   //сортируем точки в полотнах...
  1265.   CFloatPoint Min,Max;
  1266.   double ycur;
  1267.   int indb,i,j,q,qp,pos;
  1268.   CFloatPoint ttp,*fp;
  1269.   CFloatPointArray *array;
  1270.   q=GetCount();
  1271.   double tmp1,tmp2;
  1272.  
  1273.   for (i=0;i<q;i++)
  1274.   {
  1275.     ycur=100000;
  1276.     indb=-1;
  1277.     array=Get(i);
  1278.     array->GetMinMaxXY(Min,Max);
  1279.     qp=array->GetCount();
  1280.     //находим минимальную точку(самую левую-нижнюю)
  1281.     for (j=0;j<qp;j++)
  1282.     {
  1283.       fp=array->Get(j);
  1284.       tmp1=RoundTo(fp->m_X,-1); tmp2=RoundTo(Min.m_X,-1);
  1285.       if (tmp1!=tmp2) continue;//Max.m_X потому что мы отражаем полотна (раскрой с лицевой стороны)...
  1286.  
  1287.       tmp1=RoundTo(fp->m_Y,-1); tmp2=RoundTo(Min.m_Y,-1);
  1288.       if (tmp1==tmp2) {indb=j; ycur=fp->m_Y; break;}
  1289.  
  1290.       tmp1=RoundTo(ycur,-1); tmp2=RoundTo(fp->m_Y,-1);
  1291.       if (ycur==100000 || tmp1>tmp2) {indb=j; ycur=fp->m_Y;}
  1292.     }
  1293.  
  1294.     //определяем последнюю точку (до внутреннего выреза)
  1295.     pos=qp-1;
  1296.     for (j=0;j<qp;j++)
  1297.     {
  1298.       if (array->Get(j)->m_BeginVirez) {pos=j-1; break;}
  1299.     }
  1300.  
  1301.     //перемещаем точки...
  1302.     for (j=0;j<indb;j++)
  1303.     {
  1304.       //ttp=*array->Get(0);
  1305.       //array->Remove(0);
  1306.       fp=array->Get(0);
  1307.       if (pos<(qp-1)) array->Insert(pos+1,fp);//просто pos, потому что мы удалили до этого и индекс сместился...
  1308.       else array->Append(fp,false);
  1309.  
  1310.       array->Remove(0);
  1311.  
  1312.       fp=array->Get(pos);
  1313.     }
  1314.     //сортируем по часовой стрелке...
  1315.     //переворачиваем...
  1316.     for (j=1;j<pos;j++)
  1317.     {
  1318.       if (j>=pos) break;
  1319.  
  1320.       fp=array->Get(j);
  1321.       fp=array->Get(pos);
  1322.  
  1323.       array->Swap(j,pos);
  1324.       pos--;
  1325.     }
  1326.     /*for (j=0;j<qp;j++)
  1327.     {
  1328.       fp=array->Get(j);
  1329.     }*/
  1330.   }
  1331. }
  1332. //---------------------------------------------------------------------------
  1333. void CFloatPointArrayArray::Minus(double x,double y)
  1334. {
  1335.   int i,q=GetCount();
  1336.   for (i=0;i<q;i++)
  1337.     Get(i)->Minus(x,y);
  1338. }
  1339. //---------------------------------------------------------------------------
  1340. void CFloatPointArrayArray::Invert()
  1341. {
  1342.   int i,q=GetCount();
  1343.   for (i=0;i<q;i++) Get(i)->Invert();
  1344. }
  1345. //---------------------------------------------------------------------------
  1346. void CFloatPointArrayArray::ChangeEdinIzm(double k)
  1347. {
  1348.   int i,q=GetCount();
  1349.   for (i=0;i<q;i++)
  1350.     Get(i)->ChangeEdinIzm(k);
  1351. }
  1352. //---------------------------------------------------------------------------
  1353. void CFloatPointArrayArray::ChangeEdinIzm(int curtype,int type)
  1354. {
  1355. //  double k=GetKoefEdinIzm(curtype,type);
  1356. //  ChangeEdinIzm(k);
  1357. }
  1358. //---------------------------------------------------------------------------
  1359. double CFloatPointArrayArray::CalcPlochad()
  1360. {
  1361.   CFloatPointArray *array;
  1362.   int i,q=Count;
  1363.   double sum=0;
  1364.   for (i=0;i<q;i++)
  1365.   {
  1366.     sum+=Get(i)->CalcPlochad();
  1367.   }
  1368.   return sum;
  1369. }
  1370. //---------------------------------------------------------------------------
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!