Скачиваний:
18
Добавлен:
01.05.2014
Размер:
5.34 Кб
Скачать
// Point.cpp: implementation of the TMyPoint class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CH_KS.h"
#include "Point.h"
#include "CH.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

TMyPoint::TMyPoint()
{
   x=0; y=0;
}

TMyPoint::TMyPoint(int cx, int cy)
{
   x = cx;
   y = cy;
}

TMyPoint::TMyPoint(TMyPoint &P)
{
   x=P.x; y=P.y;
}

TMyPoint TMyPoint::operator+=(CPoint P)
{
   x+=P.x;
   y+=P.y;
   return *this;
}

TMyPoint TMyPoint::operator=(TMyPoint P)
{
   x=P.x; y=P.y;
   return *this;
}

 TMyPoint TMyPoint::operator+(TMyPoint P)
  {
    TMyPoint tmp;
   tmp.x=x+P.x; tmp.y=y+P.y;
   return tmp;
  }

 TMyPoint TMyPoint::operator-(TMyPoint P)
  {
    TMyPoint tmp;
   tmp.x=x-P.x; tmp.y=y-P.y;
   return tmp;
  }

 TMyPoint TMyPoint::operator/(Tcoord t)
  {
    TMyPoint tmp;
   tmp.x=x/t; tmp.y=y/t;
   return tmp;
  }

 TMyPoint TMyPoint::operator*(Tcoord t)
  {
    TMyPoint tmp;
   tmp.x=x*t; tmp.y=y*t;
   return tmp;
  }

 BOOL TMyPoint::operator > (TMyPoint P)
  {
   return x-P.x>=Eps;
  }

 BOOL TMyPoint::operator < (TMyPoint P)
  {
   return x-P.x<=-Eps;
  }

 BOOL TMyPoint::operator >= (TMyPoint P)
  {
   return x-P.x>-Eps;
  }

 BOOL TMyPoint::operator <= (TMyPoint P)
  {
   return x-P.x<Eps;
  }

 BOOL TMyPoint::operator == (TMyPoint P)
  {
   return (x-P.x>-Eps)&&(x-P.x<Eps);
  }

 TMyPoint::~TMyPoint()
  {
  }

// TMyPointVector

TMyPointVector::TMyPointVector() : p(0), size(0)
{
}

//TMyPointVector::TMyPointVector(const TMyPointVector &v): p(new TMyPoint[v.size]), size(v.size)
//{
//  for(int i = 0; i < size; i++)
//    p[i] = v.p[i];
//}

const TMyPointVector& TMyPointVector::operator=(const TMyPointVector &v)
{
  if (&v != this)
    {
     if (size > 0) { delete[] p; size = 0; }

     p = new TMyPoint[v.size];
     size = v.size;

     for(int i = 0; i < size; i++)
       p[i] = v.p[i];
    }
    
  return *this;
}

int TMyPointVector::Initialize(int sz)
{
    int res = 0;

    if (sz > 0) {

      if (size > 0) { delete[] p; p = 0; }

      size = sz;
      p = new TMyPoint[size];
      
      for(int i = 0; i < size; i++) { 
        p[i].x = 0; 
        p[i].y = 0; 
      }
    }
    else 
      res = 1;
    
    return res;
}

int TMyPointVector::X(int i)
{
    return (int) p[i].x;
}

int TMyPointVector::Y(int i)
{
    return (int) p[i].y;
}

void TMyPointVector::X(int i, int x)
{
    p[i].x = x;
}

void TMyPointVector::Y(int i, int y)
{
    p[i].y = y;
}

BOOL TMyPointVector::Check(TMyPoint v, int Limit)
{
 BOOL rez=false;

 int limit;
 int h = 5;

 if (Limit != -1) limit = Limit; else limit = size;
 
   for (int i = 0; i < limit && !rez; i++) {
    //if(p[i]==v && p[i].y-v.y>-Eps && p[i].y-v.y<Eps) rez=true;

    if ( !((abs((float) (p[i].x - v.x)) >= (float) h) || (abs((float) (p[i].y - v.y)) >= (float) h)) )
      rez = true;

   }

     //if(p[i]==v && p[i].y-v.y>-Eps && p[i].y-v.y<Eps) rez=true;

 return rez;
}

int TMyPointVector::Resize(int sz)
{
   // Создание динамического массива

   if (sz > 0) 
   {
    if (size > 0) {
      TMyPoint *v = new TMyPoint[sz];
      size = (sz > size) ? size : sz;
     
      for (int i = 0; i < size; i++)
         v[i] = p[i];
       
      size = sz;
      delete[] p;
      p = v;
    }
    else
    {
      size = sz;
      p = new TMyPoint[size];
    }
   }
   // Удаление динамического массива
   else
   {
    if (size > 0) {
      delete[] p;
      size = 0;
    }
   }
   return 1;
}

void TMyPointVector::Add(TMyPoint t)
{
	t.y = gr_y-t.y;
  if (!Check(t)) {
    Resize(size + 1);
    p[N()-1].x = t.x;
	p[N()-1].y = t.y;

  }
}

void TMyPointVector::Add(int x, int y)
{
  if (!Check(TMyPoint(x, y))) {
    Resize(size + 1);
    p[N()-1].x = x;
    p[N()-1].y = y;
	//size++;
  }
}

void TMyPointVector::Delete(int n)
{
  if (size>1 ) {
    TMyPoint *v = new TMyPoint[size - 1];
    for( int i=0; i<n; i++) v[i]=p[i];
    for(i=n+1; i<size; i++) v[i-1]=p[i];
    delete[] p; 
    p=v; size--;
  }
  else 
   if (size ==1) { delete[] p; p=0; size=0;} 
}

TMyPoint& TMyPointVector::operator[] (int N) const
{
   return p[N];
}

int TMyPointVector::Sort()
{
   if (size < 0) return 1;
   
   else
     
     if(!p || !size) return 2;
     
      else
       {
        TMyPoint v;
         for(int i = 0; i < size; i++)
          for(int j = i + 1; j < size; j++)
           
           if(p[i]==p[j])
            {
             if(p[i].y-p[j].y>-Eps)
              {
               if(p[i].y-p[j].y<Eps) return 3;
                else {v=p[i]; p[i]=p[j]; p[j]=v; }
              }
            }
           else
            if(p[i]>p[j]) {v=p[i]; p[i]=p[j]; p[j]=v; }
       }
   return 0;
}

int TMyPointVector::N()
{
  return size;
}

TMyPointVector::~TMyPointVector()
{
	if (size > 0) {
	  delete[] p;
	  size = 0;
	}
}
Соседние файлы в папке Source