Геометрический поиск метод локусов / Sources / Unit1

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

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

#include "Unit1.h"


/*
 *	TPointList
 */

MyPoint TPointList::addPoint(const TPoint& point, int number)
{
    MyPoint *myPoint = new MyPoint(point, number);

	TObjectListIterator result, upper_result, lower_result;

    result = upper_bound(_array_points.begin(), _array_points.end(), myPoint, less_my_point<3>());
	_array_points.insert(result, myPoint);

    result = upper_bound(_array_x_sorted.begin(), _array_x_sorted.end(), myPoint, less_my_point<4>());
	_array_x_sorted.insert(result, myPoint);

    result = upper_bound(_array_y_sorted.begin(), _array_y_sorted.end(), myPoint, less_my_point<5>());
	_array_y_sorted.insert(result, myPoint);

    return *myPoint;
}
//---------------------------------------------------------------------------

MyPoint TPointList::addPoint(const TPoint& point)
{
	return addPoint(point, ++_elemCount);
}
//---------------------------------------------------------------------------

void TPointList::deletePoint(const MyPoint& point)
{
    MyPoint *listPoint;
    int number;

	TObjectListIterator result;

    result = lower_bound(_array_x_sorted.begin(), _array_x_sorted.end(), &point, less_my_point<4>());
	_array_x_sorted.erase(result);

    result = lower_bound(_array_y_sorted.begin(), _array_y_sorted.end(), &point, less_my_point<5>());
	_array_y_sorted.erase(result);

    result = lower_bound(_array_points.begin(), _array_points.end(), &point, less_my_point<3>());
    listPoint = *result;
	_array_points.erase(result);

    delete listPoint;
}
//---------------------------------------------------------------------------

void TPointList::deletePoint(int number)
{
    // TODO
}
//---------------------------------------------------------------------------

void TPointList::deletePoints()
{
	_array_x_sorted.clear();
	_array_y_sorted.clear();

	for (TObjectListIterator ii = _array_points.begin(); ii != _array_points.end(); ++ii) {
    	delete (*ii);
    }
    _array_points.clear();
}
//---------------------------------------------------------------------------

MyPoint TPointList::movePoint(const MyPoint& point, TPoint position)
{
	TObjectListIterator result;

    result = lower_bound(_array_x_sorted.begin(), _array_x_sorted.end(), &MyPoint(position), less_my_point<4>());
    if (result != _array_x_sorted.end() && (*result)->point == position) {
	    return point;
    }

	deletePoint(point);
    return addPoint(position, point.number);
}
//---------------------------------------------------------------------------

int TPointList::getPointCount() const
{
	return _array_points.size();
}
//---------------------------------------------------------------------------

MyPoint TPointList::getPointInArea(const TPoint& point, int radius)
{
	MyPoint rsltPoint = NULL_MYPOINT;

    MyPoint myPoint(TPoint(point.x - radius + 1, point.y));

	TObjectListIterator result;
    result = upper_bound(_array_x_sorted.begin(), _array_x_sorted.end(), &myPoint, less_my_point<1>());

	while (result != _array_x_sorted.end() && (*result)->point.x <= point.x + radius - 1) {
        int r = sqrt( pow((*result)->point.x - point.x, 2) + pow((*result)->point.y - point.y, 2));
        if (r <= radius) {
        	rsltPoint = *(*result);
        	break;
        }

    	++result;
    }

    return rsltPoint;
}
//---------------------------------------------------------------------------

MyPoint TPointList::getPoint(int number)
{
	MyPoint rsltPoint = NULL_MYPOINT;

    MyPoint myPoint(NULL_POINT, number);

	TObjectListIterator result;
    result = lower_bound(_array_points.begin(), _array_points.end(), &myPoint, less_my_point<3>());
    if (result != _array_points.end()) rsltPoint = *(*result);

    return rsltPoint;
}
//---------------------------------------------------------------------------


TPointListConstIterator TPointList::begin()
{
	return _array_points.begin();
}
//---------------------------------------------------------------------------

TPointListConstIterator TPointList::end()
{
	return _array_points.end();
}
//---------------------------------------------------------------------------

void TPointList::clear()
{
	for (TObjectListIterator ii = _array_points.begin(); ii != _array_points.end(); ++ii)
    	delete *ii;

    _array_points.clear();
    _array_x_sorted.clear();
    _array_y_sorted.clear();

    _elemCount = 0;
}
//---------------------------------------------------------------------------

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

TLocus TRegionalSearch::preprocessing()
{
	TLocus locus = preprocessingStep(1);

    while (locus != NULL_LOCUS)
    	locus = preprocessingStep(0);

	return locus;
}
//---------------------------------------------------------------------------

TLocus TRegionalSearch::preprocessingStep(int isStart)
{
	TLocus locus;
    int flag = 0;

	if (isStart) {
		_locus_list.clear();

        pps.init();

        if (*_array_x_sorted.back() != INFINITY_MYPOINT) _array_x_sorted.push_back(&pointInfinity);
        if (*_array_y_sorted.back() != INFINITY_MYPOINT) _array_y_sorted.push_back(&pointInfinity);
	    isModified = 1;

       	ix = _array_x_sorted.begin();
       	iy = _array_y_sorted.begin();
    }

    if (iy == _array_y_sorted.end()) {
		if (!pps.pred_x.x) {
        	pps.ilocusy = _locus_list.begin();
            pps.locus_y = *pps.ilocusy;
        }

	    pps.pred_x = (*ix)->point;
        ++ix;
	    if (ix == _array_x_sorted.end())
        {
	        _array_x_sorted.pop_back();
	        _array_y_sorted.pop_back();
		    isModified = 0;
        	return NULL_LOCUS;
        }

        pps.locus_x = NULL_LOCUS;

       	if (pps.pred_x.x == (*ix)->point.x)
        	return preprocessingStep(0);
        else
        	pps.ixpoints++;

		iy = _array_y_sorted.begin();
        pps.pred_y = TPoint(0,0);
    }

    if (pps.pred_y.y == (*iy)->point.y) {
    	while (1) {
        	if (pps.pred_y.x == pps.pred_x.x) {
            	flag = 1;
            }
		    pps.pred_y = (*iy)->point;
	    	++iy;
            if (iy == _array_y_sorted.end()) return preprocessingStep(0);
            if (pps.pred_y.y < (*iy)->point.y) break;
        }
    }

	locus.rect.left  = pps.pred_x.x;
    locus.rect.top   = pps.pred_y.y;
    locus.rect.right = (*ix)->point.x;
    locus.rect.bottom= (*iy)->point.y;

    int xdom = pps.locus_x.domination;
    int ydom = (pps.locus_y != NULL_LOCUS) ? pps.ilocusy->domination : 0;
    int xydom = 0;
    if (!flag) flag = (pps.pred_y.x == pps.pred_x.x && (pps.pred_x != TPoint(0,0) && pps.pred_y != TPoint(0, 0)));
    if (pps.locus_y != NULL_LOCUS) {
    	TObjectListIterator ii = pps.ilocusy;
        if (ii != _locus_list.begin() && pps.ilocusy->rect.top)
        	xydom = (--ii)->domination;

    }
    locus.domination = xdom + ydom - xydom + flag;

    _locus_list.push_back(locus);

    pps.locus_x = locus;
    pps.pred_y = (*iy)->point;
    pps.iypoints++;
    if (pps.locus_y != NULL_LOCUS) ++pps.ilocusy;

    ++iy;

    return locus;
}
//---------------------------------------------------------------------------

TLocus TRegionalSearch::getLocus(const TPoint& point)
{
	TLocus locus = NULL_LOCUS;

    TObjectListIterator result = lower_bound(_locus_list.begin(), _locus_list.end(), point, less_locus());

    if (result != _locus_list.end()) locus = *result;

    return locus;
}
//---------------------------------------------------------------------------

int TRegionalSearch::getPointCountInRect(const MyRect& rect, TLocus& locus1, TLocus& locus2, TLocus& locus3, TLocus& locus4)
{
	int rslt;

	if (isModified) preprocessing();

	locus1 = getLocus(TPoint(rect.rect.right, rect.rect.bottom));
	locus2 = getLocus(TPoint(rect.rect.left,  rect.rect.bottom));
	locus3 = getLocus(TPoint(rect.rect.left,  rect.rect.top));
	locus4 = getLocus(TPoint(rect.rect.right, rect.rect.top));

   	rslt = locus1.domination - locus2.domination - locus4.domination + locus3.domination;

	return rslt;

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


void TRegionalSearch::clear()
{
	TPointList::clear();
    _locus_list.clear();
}
//---------------------------------------------------------------------------

MyPoint TRegionalSearch::addPoint(const TPoint& point)
{
    isModified = 1;
	return TPointList::addPoint(point);
}
//---------------------------------------------------------------------------

void TRegionalSearch::deletePoint(const MyPoint& point)
{
    isModified = 1;
	TPointList::deletePoint(point);
}
//---------------------------------------------------------------------------

MyPoint TRegionalSearch::movePoint(const MyPoint& point, TPoint newpoint)
{
    isModified = 1;
	return TPointList::movePoint(point, newpoint);
}
//---------------------------------------------------------------------------


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


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