void OGRCompoundCurve::Value( double dfDistance, OGRPoint *poPoint ) const
{
if( dfDistance < 0 )
{
StartPoint( poPoint );
return;
}
double dfLength = 0.0;
for( int iGeom = 0; iGeom < oCC.nCurveCount; iGeom++ )
{
const double dfSegLength = oCC.papoCurves[iGeom]->get_Length();
if( dfSegLength > 0 )
{
if( (dfLength <= dfDistance) && ((dfLength + dfSegLength) >=
dfDistance) )
{
oCC.papoCurves[iGeom]->Value(dfDistance - dfLength, poPoint);
return;
}
dfLength += dfSegLength;
}
}
EndPoint( poPoint );
}
void inputData(int dataDimension, int dataCount) { // [!!!] Not catching failed
int i, j;
int bitValid;
S = StartPoint(S, &SSize, &SHead, &STail, dataDimension);
tmpIntStar = (int **)malloc(sizeof(int*) * dataCount);
for (i = 0; i < dataCount; i++) {
tmpInput = StartPoint(tmpInput, &tmpSize, &tmpHead, &tmpTail, dataDimension);
tmpInput->dimension = dataDimension;
tmpIntStar[i] = (int *)malloc(sizeof(int) * dataDimension);
tmpInput->data = &(tmpIntStar[i]);
for(j = 0; j < dataDimension; j++) {
*(*(tmpInput->data) + j) = (i+1) * (j+1); // Input Actual Data
printf("%d ", *(*(tmpInput->data) + j));
}
printf("\n");
// for(int j = 0; j < dataDimension; j++) {
// printf("%d ", *(*(tmpInput->data) + j));
// }
// printf("\n");
tmpInput->bitmap = 0;
for(j = 0; j < dataDimension; j++) { // Set Bit Map
bitValid = (j + 1) % 2;
if (bitValid != 1) {
*(*(tmpInput->data) + j) = 0;
tmpInput->bitmap <<= 1;
} else {
tmpInput->bitmap <<= 1;
tmpInput->bitmap |= 1;
}
//printf("%d ", tmpInput->bitmap);
}
//for(int j = 0; j < dataDimension; j++) {
// printf("%d\n", *(*(tmpInput->data) + j));
//}
PushPoint(tmpInput, &SSize, &STail);
//S.push_back(tmpInput[i]);
}
}
void OGRLineString::Value( double dfDistance, OGRPoint * poPoint ) const
{
double dfLength = 0;
int i;
if( dfDistance < 0 )
{
StartPoint( poPoint );
return;
}
for( i = 0; i < nPointCount-1; i++ )
{
double dfDeltaX, dfDeltaY, dfSegLength;
dfDeltaX = paoPoints[i+1].x - paoPoints[i].x;
dfDeltaY = paoPoints[i+1].y - paoPoints[i].y;
dfSegLength = sqrt(dfDeltaX*dfDeltaX + dfDeltaY*dfDeltaY);
if (dfSegLength > 0)
{
if( (dfLength <= dfDistance) && ((dfLength + dfSegLength) >=
dfDistance) )
{
double dfRatio;
dfRatio = (dfDistance - dfLength) / dfSegLength;
poPoint->setX( paoPoints[i].x * (1 - dfRatio)
+ paoPoints[i+1].x * dfRatio );
poPoint->setY( paoPoints[i].y * (1 - dfRatio)
+ paoPoints[i+1].y * dfRatio );
if( getCoordinateDimension() == 3 )
poPoint->setZ( padfZ[i] * (1 - dfRatio)
+ padfZ[i] * dfRatio );
return;
}
dfLength += dfSegLength;
}
}
EndPoint( poPoint );
}
void ON_Arc::Dump( ON_TextLog& dump ) const
{
dump.Print("Arc: normal = ");
dump.Print(plane.zaxis);
dump.Print(" center = ");
dump.Print(plane.origin);
dump.Print(" start = ");
dump.Print( StartPoint() );
dump.Print(" end = ");
dump.Print( EndPoint() );
dump.Print(" radius = ");
dump.Print(Radius());
dump.Print(" angle = [");
dump.Print(m_angle[0]);
dump.Print(",");
dump.Print(m_angle[1]);
dump.Print("]\n");
}
int OGRCurve::get_IsClosed() const
{
OGRPoint oStartPoint, oEndPoint;
StartPoint( &oStartPoint );
EndPoint( &oEndPoint );
if( oStartPoint.getX() == oEndPoint.getX()
&& oStartPoint.getY() == oEndPoint.getY() )
{
return TRUE;
}
else
{
return FALSE;
}
}
OGRErr OGRLinearRing::transform( OGRCoordinateTransformation *poCT )
{
const bool bIsClosed = getNumPoints() > 2 && CPL_TO_BOOL(get_IsClosed());
OGRErr eErr = OGRLineString::transform(poCT);
if( bIsClosed && eErr == OGRERR_NONE && !get_IsClosed() )
{
CPLDebug("OGR", "Linearring is not closed after coordinate "
"transformation. Forcing last point to be identical to "
"first one");
// Force last point to be identical to first point.
// This is a safety belt in case the reprojection of the same coordinate
// isn't perfectly stable. This can for example happen in very rare cases
// when reprojecting a cutline with a RPC transform with a DEM that
// is a VRT whose sources are resampled...
OGRPoint oStartPoint;
StartPoint( &oStartPoint );
setPoint( getNumPoints()-1, &oStartPoint);
}
return eErr;
}
static void
TestAATPoint()
{
OrderedTask task(task_behaviour);
task.Append(StartPoint(new CylinderZone(wp1->location, 500),
WaypointPtr(wp1),
task_behaviour,
ordered_task_settings.start_constraints));
task.Append(AATPoint(new CylinderZone(wp2->location, 10000),
WaypointPtr(wp2),
task_behaviour));
task.Append(FinishPoint(new CylinderZone(wp3->location, 500),
WaypointPtr(wp3),
task_behaviour,
ordered_task_settings.finish_constraints));
task.SetActiveTaskPoint(1);
task.UpdateGeometry();
ok1(task.CheckTask());
AATPoint &ap = (AATPoint &)task.GetPoint(1);
ok1(!ap.IsTargetLocked());
ok1(equals(ap.GetTargetLocation(), wp2->location));
ap.LockTarget(true);
ok1(ap.IsTargetLocked());
ok1(equals(ap.GetTargetLocation(), wp2->location));
GeoPoint target = MakeGeoPoint(0, 45.31);
ap.SetTarget(target);
ok1(ap.IsTargetLocked());
ok1(equals(ap.GetTargetLocation(), wp2->location));
ap.SetTarget(target, true);
ok1(ap.IsTargetLocked());
ok1(equals(ap.GetTargetLocation(), target));
RangeAndRadial rar = ap.GetTargetRangeRadial();
ok1(equals(rar.range, 0.1112, 1000));
ok1(equals(rar.radial.Degrees(), 0, 200));
target = MakeGeoPoint(0, 45.29);
ap.SetTarget(target, true);
rar = ap.GetTargetRangeRadial();
ok1(equals(rar.range, -0.1112, 1000));
ok1(equals(rar.radial.Degrees(), 180, 200) ||
equals(rar.radial.Degrees(), -180, 200));
target = MakeGeoPoint(-0.05, 45.3);
ap.SetTarget(target, true);
rar = ap.GetTargetRangeRadial();
ok1(equals(rar.range, 0.39217));
ok1(equals(rar.radial.Degrees(), -89.98));
target = MakeGeoPoint(0.05, 45.3);
ap.SetTarget(target, true);
rar = ap.GetTargetRangeRadial();
ok1(equals(rar.range, 0.39217));
ok1(equals(rar.radial.Degrees(), 89.98));
for (int radial = -170; radial <= 170; radial += 10) {
const Angle radial2 = Angle::Degrees(radial);
for (int range = 10; range <= 100; range += 10) {
const double range2((radial >= -90 && radial <= 90
? range : -range) / 100.);
ap.SetTarget(RangeAndRadial{range2, radial2}, task.GetTaskProjection());
rar = ap.GetTargetRangeRadial();
ok1(equals(rar.range, range2, 100));
ok1(equals(rar.radial.Degrees(), radial2.Degrees(), 100));
}
}
}
void OGRCircularString::Value( double dfDistance, OGRPoint * poPoint ) const
{
if( dfDistance < 0 )
{
StartPoint( poPoint );
return;
}
double dfLength = 0;
for( int i = 0; i < nPointCount - 2; i += 2 )
{
const double x0 = paoPoints[i].x;
const double y0 = paoPoints[i].y;
const double x1 = paoPoints[i+1].x;
const double y1 = paoPoints[i+1].y;
const double x2 = paoPoints[i+2].x;
const double y2 = paoPoints[i+2].y;
double R = 0.0;
double cx = 0.0;
double cy = 0.0;
double alpha0 = 0.0;
double alpha1 = 0.0;
double alpha2 = 0.0;
// We have strong constraints on the number of intermediate points
// we can add.
if( OGRGeometryFactory::GetCurveParmeters(x0, y0, x1, y1, x2, y2,
R, cx, cy,
alpha0, alpha1, alpha2) )
{
// It is an arc circle.
const double dfSegLength = fabs(alpha2 - alpha0) * R;
if( dfSegLength > 0 )
{
if( (dfLength <= dfDistance) && ((dfLength + dfSegLength) >=
dfDistance) )
{
const double dfRatio =
(dfDistance - dfLength) / dfSegLength;
const double alpha =
alpha0 * (1 - dfRatio) + alpha2 * dfRatio;
const double x = cx + R * cos(alpha);
const double y = cy + R * sin(alpha);
poPoint->setX( x );
poPoint->setY( y );
if( getCoordinateDimension() == 3 )
poPoint->setZ( padfZ[i] * (1 - dfRatio)
+ padfZ[i+2] * dfRatio );
return;
}
dfLength += dfSegLength;
}
}
else
{
// It is a straight line.
const double dfSegLength = dist(x0, y0, x2, y2);
if( dfSegLength > 0 )
{
if( (dfLength <= dfDistance) && ((dfLength + dfSegLength) >=
dfDistance) )
{
const double dfRatio =
(dfDistance - dfLength) / dfSegLength;
poPoint->setX( paoPoints[i].x * (1 - dfRatio)
+ paoPoints[i+2].x * dfRatio );
poPoint->setY( paoPoints[i].y * (1 - dfRatio)
+ paoPoints[i+2].y * dfRatio );
if( getCoordinateDimension() == 3 )
poPoint->setZ( padfZ[i] * (1 - dfRatio)
+ padfZ[i+2] * dfRatio );
return;
}
dfLength += dfSegLength;
}
}
}
EndPoint( poPoint );
}
void thicknessWarehouse(int dataDimension, int kValue) {
int i, j, k,flag;
int bucketSize = 0;
int bucketCount = 1;
int iterCount = 0, iterCountB;
struct gtPoint *iterA;
struct gtPoint *iterB;
struct gtPoint *tmpPoint = NULL;
struct gtPoint *tmpPoint2 = NULL;
struct gtPoint *tmpPoint3 = NULL;
struct gtPoint *tmpPointNext;
struct gtPoint **tmpPointArray;
struct gtBucket *tmpBucket = NULL;
struct gtBucket *bucketHead, *bucketTail;
Stwh = StartPoint(Stwh, &StwhSize, &StwhHead, &StwhTail, dataDimension);
Ses = StartPoint(Ses, &SesSize, &SesHead, &SesTail, dataDimension);
Sg = StartPoint(Sg, &SgSize, &SgHead, &SgTail, dataDimension);
// [STEP 1] Push all points in S to every bucket according to bitmap
for (i = 0; i < dataDimension; i++)
bucketCount *= 2;
////////////////////////////////////////////////////
// Origin: bucket = new gtBucket[bucketCount];
bucket = StartBucket(bucket, &bucketSize, &bucketHead, &bucketTail, dataDimension);
for (i = 0; i < bucketCount; i++) {
tmpBucket = (struct gtBucket *)malloc(sizeof(struct gtBucket));
InitBucket(tmpBucket, dataDimension);
PushBucket(tmpBucket, &bucketSize, &bucketTail);
}
////////////////////////////////////////////////////
////////////////////////////////////////////////////
// Origin: bucket[S[i]->bitmap].data.push_back(S[i]);
tmpPoint = S;
tmpPointNext = tmpPoint->next;
while (tmpPointNext != NULL) {
tmpPoint = tmpPointNext;
tmpPointNext = tmpPoint->next;
tmpBucket = GetBucket(tmpPoint->bitmap, bucketHead);
PushPoint(tmpPoint, &tmpBucket->dataSize, &tmpBucket->dataTail);
}
////////////////////////////////////////////////////
// [STEP 2] Divide points in every bucket into Sl and Sln
tmpBucket = bucket;
tmpPointArray = (struct gtPoint **)malloc(sizeof(struct gtPoint*) * tmpBucket->dataSize);
for (i = 1; i < bucketCount; i++) {
tmpBucket->bitmap = i;
tmpPoint = tmpBucket->data;
tmpPointArray[0] = tmpPoint;
for (j = 1; j < tmpBucket->dataSize; j++) {
tmpPoint = tmpPoint->next;
tmpPointArray[j] = tmpPoint;
}
for (j = 1; j < tmpBucket->dataSize; j++) {
tmpPoint = tmpPointArray[j];
for (k = 1; k < tmpBucket->dataSize; k++) {
tmpPoint2 = tmpPointArray[k];
if (j != k ) {
if (isPoint1DominatePoint2(tmpPoint2, tmpPoint)) {
tmpPoint->domainatedCount++;
if (tmpPoint->domainatedCount >= kValue) {
PushPoint(tmpPoint, &tmpBucket->SlnSize, &tmpBucket->SlnTail);
break;
}
}
}
}
if (k == tmpBucket->dataSize) { // which means data[j] is not dominted more than k times, then put it into Sl.
PushPoint(tmpPoint, &tmpBucket->SlSize, &tmpBucket->SlTail);
// I think we do not need the above line code, because every point in Sl will be pushed
// to Stwh, therefore, we can just put it to Stwh directly. is that right???
//////////////////////////////////////////////////////////////////////////////////////////////////
// [STEP 3] Push Bucket.Sl -> Stwh
// Origin:
// for (int j = 0; j < bucket[i].SlSize(); j++) {
// PushPoint(bucket[i].Sl[j],&StwhSize,&StwhTail);
// }
PushPoint(tmpPoint, &StwhSize, &StwhTail);
//////////////////////////////////////////////////////////////////////////////////////////////////
}
}
tmpBucket = tmpBucket->next;
}
// [STEP 4] Push Swth -> Ses
// std::sort(Stwh.begin(), Stwh.end(), gtSortAlgo);
/////////////////////////////////////////////////////////////////////////////////////
// Origin:
// vector<gtPoint *>::iterator itHead, itTail;
// for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
// if(!*itHead) continue;
// for (itTail = Stwh.end(); itTail != Stwh.begin(); itTail--) {
// if(!*itTail) continue;
// if (isPoint1DominatePoint2(*itTail, *itHead)) (*itHead)->domainatedCount ++;
// if ((*itHead)->domainatedCount > kValue) {
// Ses.push_back(*itHead);
// Stwh.erase(itHead);
// break;
// }
// if (isPoint1DominatePoint2(*itHead, *itTail)) (*itTail)->domainatedCount ++;
// if ((*itTail)->domainatedCount > kValue) {
// Ses.push_back(*itTail);
// Stwh.erase(itTail);
// }
// }
// }
iterA = Stwh;
while (iterA->next != NULL) {
iterA = iterA->next;
iterCount++;
iterB = StwhTail;
iterCountB = 0;
while (iterB->previous != NULL) {
iterB = iterB->previous;
iterCountB++;
if (isPoint1DominatePoint2(iterB, iterA)) {
iterA->domainatedCount++;
if (iterA->domainatedCount > kValue) {
PushPoint(iterA, &SesSize, &SesTail);
DeletePoint(iterCount, &StwhHead, &StwhSize);
break;
}
}
if (isPoint1DominatePoint2(iterA, iterB)) {
iterB->domainatedCount++;
if (iterB->domainatedCount > kValue) {
PushPoint(iterB, &SesSize, &SesTail);
DeletePoint(iterCountB, &StwhHead, &StwhSize);
}
}
}
}
//////////////////////////////////////////////////////////////////////////////////////
//[STEP 5] (Stwh, Ses) -> Sg
/////////////////////////////////////////////////////////////////////////////////////
// Origin:
// for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
// for (itTail = Ses.begin(); itTail != Ses.end(); itTail++) {
// if (isPoint1DominatePoint2(*itTail, *itHead)) (*itHead)->domainatedCount ++;
// if ((*itHead)->domainatedCount > kValue) {
// Stwh.erase(itHead);
// }
// }
// }
/*
iterCount = 0;
iterA = Stwh;
while (iterA->next != NULL) {
iterA = iterA->next;
iterCount++;
iterB = Ses;
while (iterB->next != NULL) {
iterB = iterB->next;
if (isPoint1DominatePoint2(iterB, iterA)) {
iterA->domainatedCount++;
if (iterA->domainatedCount >= kValue) {
DeletePoint(iterCount, &StwhHead, &StwhSize);
break;
}
}
}
}
*/
//////////////////////////////////////////////////////////////////////////////////////
tmpPoint = Stwh->next;
i = 1;
do{ //To compare all the points in Stwh with all points in Stwh and Ses, to see whether they need to compare Slns in some Buckets.
dominateBucket = (int *)malloc(bucketCount*sizeof(int));
tmpPoint3 = tmpPoint->next;
tmpPoint2 = Ses->next;
while (tmpPoint2 != NULL){
if (isPoint1DominatePoint2(tmpPoint2, tmpPoint)){
tmpPoint->domainatedCount++;
*(dominateBucket + tmpPoint2->bitmap)=1;
}
if (tmpPoint->domainatedCount >= kValue){
tmpPoint->previous->next = tmpPoint->next;
PushPoint(tmpPoint,SesSize,SesTail);
free(dominateBucket);
break;
}
tmpPoint2 = tmpPoint2->next;
}
if (tmpPoint2 == NULL){
tmpPoint2 = Stwh->next;
while (tmpPoint2 != NULL){
if (isPoint1DominatePoint2(tmpPoint2, tmpPoint)){
*(dominateBucket + tmpPoint2->bitmap) = 1;
}
tmpPoint2 = tmpPoint2->next;
}
for (j = 1; j < bucketCount; j++){
if (*(dominateBucket + j) == 1){
tmpPoint2 = (bucket + *(dominateBucket + j))->Sln->next;
while (tmpPoint2 != NULL){
if (isPoint1DominatePoint2(tmpPoint2, tmpPoint))
tmpPoint->domainatedCount++;
if (tmpPoint->domainatedCount >= kValue){
tmpPoint->previous->next = tmpPoint->next;
PushPoint(tmpPoint, SesSize, SesTail);
free(dominateBucket);
break;
}
}
if (tmpPoint2 != NULL)
break;
}
}
if (j == bucketCount)
PushPoint(tmpPoint, &SgSize, &SgTail);
}
tmpPoint = tmpPoint3;
} while (tmpPoint);
/*
gtBucket *Stwh_b = new gtBucket [bucketCount];
gtBucket *Ses_b = new gtBucket [bucketCount];
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) (Stwh_b[(*itHead)->bitmap]).StwhSes.push_back((*itHead));
for (itHead = Ses.begin(); itHead != Ses.end(); itHead++) (Ses_b[(*itHead)->bitmap]).StwhSes.push_back((*itHead));
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
vector<gtPoint *> cmpS;
for (int i = 0; i < bucketCount; i++) {
if (i == (*itHead)->bitmap) continue;
else {
for (int j = 0; j < Stwh_b[i].StwhSes.size(); j++) cmpS.push_back(Stwh_b[i].StwhSes[j]);
for (int j = 0; j < Ses_b[i].StwhSes.size(); j++) cmpS.push_back(Ses_b[i].StwhSes[j]);
}
}
for (int i = 0; i < cmpS.size(); i++) {
bool isIteratorErased = false;
if (isPoint1DominatePoint2(*itHead, cmpS[i])) continue;
else {
for (int j = 0; j < bucket[cmpS[i]->bitmap].Sln.size(); j++) {
if (isPoint1DominatePoint2(bucket[cmpS[i]->bitmap].Sln[j], *itHead)) (*itHead)->domainatedCount ++;
if ((*itHead)->domainatedCount > kValue) {;
Stwh.erase(itHead);
isIteratorErased = true;
break;
}
}
}
if (isIteratorErased) break;
}
}
Sg = Stwh;
*/
}
void thicknessWarehouse(int dataDimension, int kValue) {
int i,j,k;
struct gtPoint *tmpPoint = NULL;
struct gtBucket *tmpBucket;
int bucketSize = 0;
int bucketCount = 1;
struct gtBucket *bucketHead, *bucketTail;
Stwh = StartPoint(Stwh, &StwhSize, &StwhHead, &StwhTail, dataDimension);
Ses = StartPoint(Ses, &SesSize, &SesHead, &SesTail, dataDimension);
Sg = StartPoint(Sg, &SgSize, &SgHead, &SgTail, dataDimension);
// [STEP 1]
for (i = 0; i < dataDimension; i++)
bucketCount *= 2;
////////////////////////////////////////////////////
// Origin: bucket = new gtBucket[bucketCount];
bucket = StartBucket(bucket, &bucketSize, &bucketHead, &bucketTail);
for (i = 0; i < bucketCount; i++) {
tmpBucket = (struct gtBucket *)malloc(sizeof(struct gtBucket));
InitBucket(tmpBucket);
PushBucket(tmpBucket, &bucketSize, &bucketTail);
}
////////////////////////////////////////////////////
/*
for (int i = 0; i < SSize; i++){
////////////////////////////////////////////////////
// Origin: bucket[S[i]->bitmap].data.push_back(S[i]);
tmpPoint = GetPoint(i, SHead);
tmpBucket = GetBucket(tmpPoint->bitmap, bucketHead);
//Armour: tmpBucket->data = tmpPoint;There seems to have some problems.
tmpBucket->data->PushPoint(tmpPoint,&i,&bucketTail);
////////////////////////////////////////////////////
}*/
for (i = 0; i < SSize; ){ //i will automatically increment in tmpBucket->data->PushPint();
////////////////////////////////////////////////////
// Origin: bucket[S[i]->bitmap].data.push_back(S[i]);
tmpPoint = GetPoint(i, SHead);
tmpBucket = GetBucket(tmpPoint->bitmap, bucketHead);
//Armour: tmpBucket->data = tmpPoint;There seems to have some problems.
//tmpBucket->data->PushPoint(tmpPoint,&i,&bucketTail);
//PushPoint(tmpPoint,&i,&bucketTail);
////////////////////////////////////////////////////
}
// [STEP 2]
for (i = 0; i < bucketCount; i++) {
////////////////////////////////////////////////////
// Origin: bucket[i].bitmap = i;
tmpBucket = GetBucket(i, bucketHead);
tmpBucket->bitmap = i; // Set Bitmap
////////////////////////////////////////////////////
//Calculate DominanceCount and put each node into Sl or Sln
for (j = 0; j < SSize; j++) {
for (k = 0; k < SSize; k++) { //Changed
if (isPoint1DominatePoint2(&bucket[i].data[k], &bucket[i].data[j])){
bucket[i].data[j]->domainatedCount++;
}
if (bucket[i].data[j]->domainatedCount >= kValue){
PushPoint(&bucket[i].data[j],&(bucket[i].SlnSize),bucket[i].SlnTail);
break;
}
}
if (k == SSize) // which means data[j] is not dominted more than k times, then put it into Sl.
PushPoint(&bucket[i].data[j],&(bucket[i].SlTaillSize),bucket[i].SlTail);
}
FreeAllPoints(bucket[i].data,&(bucket[i].dataSize);
/*
// [STEP 3] Push Bucket.Sl -> Stwh
for (int j = 0; j < bucket[i].SlSize(); j++) Stwh.push_back(bucket[i].Sl[j]);
}
*/
// [STEP 3] Push Bucket.Sl -> Stwh
//for (int j = 0; j < bucket[i].Sl.size(); j++)
// Stwh.push_back(bucket[i].Sl[j]);
/*
// [STEP 4] Push Swth -> Ses
std::sort(Stwh.begin(), Stwh.end(), gtSortAlgo);
vector<gtPoint *>::iterator itHead, itTail;
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
if(!*itHead) continue;
for (itTail = Stwh.end(); itTail != Stwh.begin(); itTail--) {
if(!*itTail) continue;
if (isPoint1DominatePoint2(*itTail, *itHead)) (*itHead)->domainatedCount ++;
if ((*itHead)->domainatedCount > kValue) {
Ses.push_back(*itHead);
Stwh.erase(itHead);
break;
}
if (isPoint1DominatePoint2(*itHead, *itTail)) (*itTail)->domainatedCount ++;
if ((*itTail)->domainatedCount > kValue) {
Ses.push_back(*itTail);
Stwh.erase(itTail);
}
}
}
// [STEP 5] (Stwh, Ses) -> Sg
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
for (itTail = Ses.begin(); itTail != Ses.end(); itTail++) {
if (isPoint1DominatePoint2(*itTail, *itHead)) (*itHead)->domainatedCount ++;
if ((*itHead)->domainatedCount > kValue) {
Stwh.erase(itHead);
}
}
}
gtBucket *Stwh_b = new gtBucket [bucketCount];
gtBucket *Ses_b = new gtBucket [bucketCount];
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) (Stwh_b[(*itHead)->bitmap]).StwhSes.push_back((*itHead));
for (itHead = Ses.begin(); itHead != Ses.end(); itHead++) (Ses_b[(*itHead)->bitmap]).StwhSes.push_back((*itHead));
for (itHead = Stwh.begin(); itHead != Stwh.end(); itHead++) {
vector<gtPoint *> cmpS;
for (int i = 0; i < bucketCount; i++) {
if (i == (*itHead)->bitmap) continue;
else {
for (int j = 0; j < Stwh_b[i].StwhSes.size(); j++) cmpS.push_back(Stwh_b[i].StwhSes[j]);
for (int j = 0; j < Ses_b[i].StwhSes.size(); j++) cmpS.push_back(Ses_b[i].StwhSes[j]);
}
}
for (int i = 0; i < cmpS.size(); i++) {
bool isIteratorErased = false;
if (isPoint1DominatePoint2(*itHead, cmpS[i])) continue;
else {
for (int j = 0; j < bucket[cmpS[i]->bitmap].Sln.size(); j++) {
if (isPoint1DominatePoint2(bucket[cmpS[i]->bitmap].Sln[j], *itHead)) (*itHead)->domainatedCount ++;
if ((*itHead)->domainatedCount > kValue) {;
Stwh.erase(itHead);
isIteratorErased = true;
break;
}
}
}
if (isIteratorErased) break;
}
}
Sg = Stwh;
*/
}
int main(int argc, const char * argv[]) {
/*
cin >> dataCount >> kValue >> dataDimension;
cout << "Count: [" << dataCount << "]data in " << dataDimension << "-Dimensions\n";
cout << "K-Value: " << kValue << endl;
*/
scanf("%d %d", &dataDimension, &dataCount);
inputData(dataDimension, dataCount);
kValue = 1;
thicknessWarehouse(dataDimension, kValue);
/*
for (int i = 0; i < Sg.size(); i++) {
Sg[i]->printPoint();
}
*/
return 0;
}
