/////////////////////////////////////////////////////////////////////////////
// if points are close to each other, make them a single point
// to turn off merging, set DefaultMergeDistance to a negative value
void CCurve::MergePoint(int Index)
{ // Set iCurrent to after completion
if (Index <= 0 || Index >= (NumPoints-1))
return; // nochange on endpoints
if (Distance(Points[Index], Points[Index-1]) <= DefaultMergeDistance)
{ // merge them
DeletePoint(Index);
iCurrent = Index - 1;
}
else
if (Distance(Points[Index], Points[Index+1]) <= DefaultMergeDistance)
{ // merge them
DeletePoint(Index);
iCurrent = Index;
}
}
void cX11_Interface::_DeletePoint(cSP_PointGlob * aSG)
{
if (! mZFON->Get("Kill " + aSG->PG()->Name() + "?")) return;
DeletePoint(aSG);
RedrawAllWindows();
}
void PolyLine2::Refine()
{
int cP = 0;
while (cP < m_Points.size())
{
const Vec2& pc = GetPoint( cP );
const Vec2& pn = GetPoint( cP + 1 );
if (pc.equal( pn ))
{
DeletePoint( cP );
}
else
{
cP++;
}
}
}
void DeletePickedPoint::operate()
{
vtkIdType id_node = GuiMainWindow::pointer()->getPickedPoint();
cout << "You picked " << id_node << endl;
if( id_node<0 || GuiMainWindow::pointer()->getPickedObject()!=1 ) {
QApplication::restoreOverrideCursor();
EG_ERR_RETURN("Error: No node picked.");
}
char type;
QVector <vtkIdType> PSP;
//IMPORTANT: to make sure only unselected nodes become fixed (redundant with previous line, but more readable)
this->m_BoundaryCodes = GuiMainWindow::pointer()->getAllBoundaryCodes();
qWarning()<<"m_BoundaryCodes="<<m_BoundaryCodes;
updateNodeInfo();
QMessageBox msgBox;
msgBox.setText("Delete point?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
switch (msgBox.exec()) {
case QMessageBox::Yes:
cout<<"yes was clicked"<<endl;
DeletePoint(id_node);
break;
case QMessageBox::No:
cout<<"no was clicked"<<endl;
cout<<"=== Topological neighbours ==="<<endl;
PSP = getPotentialSnapPoints(id_node);
cout<<"id_node="<<id_node<<" PSP="<<PSP<<endl;
cout<<"=== NODE TYPE ==="<<endl;
type = getNodeType(id_node);
cout<<"id_node="<<id_node<<" is of type="<<(int)type<<"="<<VertexType2Str(type)<<endl;
break;
default:
// should never be reached
break;
}
}
int main()
{
ProfTimer mProfTimer;
unsigned char *sTextData = TextData();
float mArrVecParser_CSV[nWidthParser];
float mArrVecParserCopy[nWidthParser];
float mArrVecParserCopy2[nWidthParser];
DataOpen("1909175498_image_profile.csv", mArrVecParser_CSV);
//DataOpen("-1916029922_image_profile.csv", mArrVecParser_CSV);
while (1)
{
memcpy(mArrVecParserCopy, mArrVecParser_CSV, sizeof(float)* nWidthParser);
Global::Image mImageParser(nWidthParser, nheightParser, Global::TYPE::BYTE, 3);
Global::Image mImageParser2(nWidthParser, nheightParser, Global::TYPE::BYTE, 3);
Global::Image mImageParserReSize(img_wid, img_hig, Global::TYPE::BYTE, 3);
for (int i = 0; i < nWidthParser; i++)
{
Global::Circle(&mImageParser, i, mArrVecParserCopy[i], 1, RGB8(0, 0, 255));
}
#if 0
int nXTest0 = 800;
int nXTest1 = 900;
int nTest;
Sample sSample;
sSample.nX0 = nXTest0;
sSample.nX1 = nXTest1;
Line(&mImageParser, mArrVecParserCopy, sSample,true);
nXTest0 = 400;
nXTest1 = 810;
//Line(&mImageParser, nXTest0, nXTest1, mArrVecParserCopy, nTest, true);
//DeletePoint(nWidthParser, nheightParser, 400, 700, mArrVecParserCopy);
#endif
#if 1
int nLineCount(1);
const int nSample = 1000;
Sample sSample[nSample];
while (nLineCount)
{
mProfTimer.Start();
nLineCount--;
int nArrNumderSize(0);
int nSampleCount(0);
memset(sSample, 0, sizeof(Sample)* nSample);
int nMaxSample = 0;
int nMaxSampleArrNum = 0;
while (nSample - nArrNumderSize)
{
float fCutLine = nheightParser / 1.2;
int nRandX0 = (std::rand() % nWidthParser);//중복은 나중에 고려
int nRandX1 = (std::rand() % nWidthParser);//중복은 나중에 고려
if (nRandX0 == nRandX1 || mArrVecParserCopy[nRandX0] < fCutLine || mArrVecParserCopy[nRandX1] < fCutLine)
{
continue;
}
sSample[nSampleCount].nX0 = nRandX0;
sSample[nSampleCount].nX1 = nRandX1;
if (Line(&mImageParser, mArrVecParserCopy, sSample[nSampleCount]))
{
if (sSample[nSampleCount].nSn > nMaxSample && sSample[nSampleCount].nSn > 10)
{
nMaxSample = sSample[nSampleCount].nSn;
nMaxSampleArrNum = nSampleCount;
nSampleCount++;
//printf(" nMaxSampleArrNum : %d \n", nMaxSampleArrNum);
}
nArrNumderSize++;
}
}
//mVecParserCopy
if (nSampleCount > 0)
{
Line(0, mArrVecParserCopy, sSample[nMaxSampleArrNum], true);
memcpy(mArrVecParserCopy2, mArrVecParser_CSV, sizeof(float)* nWidthParser);
ReAgainst(nWidthParser, nheightParser, sSample[nMaxSampleArrNum], mArrVecParserCopy2);
}
mProfTimer.Stop();
printf("mProfTimer : %f \n", mProfTimer.GetDurationInSecs());
if (nSampleCount > 0)
{
Line(&mImageParser, mArrVecParserCopy, sSample[nMaxSampleArrNum], true);
DeletePoint(nWidthParser, nheightParser, sSample[nMaxSampleArrNum], mArrVecParserCopy);
for (int i = 0; i < nWidthParser; i++)
{
Global::Circle(&mImageParser2, i, mArrVecParserCopy2[i], 2, RGB8(0, 0, 255));
}
}
//break;
}
#endif
#if 0
Global::Show("Parser ", &mImageParser);
Global::Show("Test ", &mImageParser2);
#else
Global::Filter2D(&mImageParser2, &mImageParser2, Global::FILTER::GAUSSIAN, 1);
Global::ReSize(&mImageParser2, &mImageParserReSize);
Global::Show("Test ", &mImageParserReSize);
Global::Filter2D(&mImageParser, &mImageParser, Global::FILTER::GAUSSIAN, 1);
Global::ReSize(&mImageParser, &mImageParserReSize);
Global::Show("Parser ", &mImageParserReSize);
#endif
//Sleep(1);
}
delete sTextData;
return 0;
}
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;
*/
}
