void SgIncrementalStack::PushPt(int type, SgEmptyBlackWhite col, SgPoint pt) // same as PushPts for a single point AR: could be optimized for space by // using different type tags for single and multiple point { PushPoint(pt); PushInt(col); PushInt(1);// nu pts PushInt(type); }
void CPointfile::saxEndElement (message_info_t *ctx, const xmlChar *name) { if(string_equal(reinterpret_cast<const char*>(name), "polyline")) { // we are done GenerateDisplayList(); SceneChangeNotify(); } else if(string_equal(reinterpret_cast<const char*>(name), "point")) { Vector3 v; sscanf(m_characters.c_str(), "%f %f %f\n", &v[0], &v[1], &v[2]); PushPoint(v); m_characters.clear(); } }
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 SgIncrementalStack::PushPts(int type, SgEmptyBlackWhite col, const SgPointSet& pts) // Events relevant for maintaining the state in an ExecuteMove or UndoMove // are stored in and retrieved from a stack. Each event consists of // 1. an event type // 2. the number of points for the event on the stack // 3. a color (SG_EMPTY, SG_BLACK or SG_WHITE, meaning depends on event // type) // 4. a list of points (as many as given in 2.) // Events are pushed in reverse order, and popped in the right order // (e.g. number of items before list of items) { int nu = 0; for (SgSetIterator it(pts); it; ++it) { PushPoint(*it); ++nu; } PushInt(col); PushInt(nu); PushInt(type); }
// only "point" is expected to have characters around here void CPointfile::saxCharacters( message_info_t *ctx, const xmlChar *ch, int len ) { vec3_t v; sscanf( (char *)ch, "%f %f %f\n", &v[0], &v[1], &v[2] ); PushPoint( v ); }
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; }