// ----------------------------------------------- // ProgressBar // ----------------------------------------------- void * ehzProgressBar(struct OBJ *objCalled,EN_MESSAGE cmd,LONG info,void *ptr) { EH_DISPEXT *DExt=ptr; // SINT *lpi; SINT iLx,iLy; SINT iRiemp; SINT iPos; SINT iBar; SINT iDiv; SINT a; SINT ThePoint; SINT iMyShadow; SINT iEnd; EH_PROGRESS_BAR * psBar; //lpi=(SINT *) objCalled->text; psBar=(EH_PROGRESS_BAR *) objCalled->pOther; switch(cmd) { case WS_INF: return NULL; case WS_CREATE: psBar=objCalled->pOther=ehAllocZero(sizeof(EH_PROGRESS_BAR)); psBar->iMax=100; psBar->cBar=sys.Color3DHighLight; if (!strcmp(objCalled->text,"WIN")) { objCalled->hWnd=CreateWindowEx(0, PROGRESS_CLASS, NULL, WS_CHILD|WS_VISIBLE, 0,0, 10,10,//-(MENU_HEIGHT), WindowNow(),//sGMSetup.hwAnagTB,//sGMSetup.hwAnag, (HMENU) NULL, sys.EhWinInstance, NULL); SendMessage(objCalled->hWnd, PBM_SETRANGE,0,MAKELPARAM(0,100)); SendMessage(objCalled->hWnd, PBM_SETSTEP, MAKEWPARAM(1, 0), 0); } else objCalled->hWnd=NULL; break; case WS_DESTROY: ehFreePtr(&objCalled->pOther); if (objCalled->hWnd) DestroyWindow(objCalled->hWnd); break; case WS_DO: // Spostamento / Ridimensionamento MoveWindow(objCalled->hWnd,DExt->px,DExt->py,DExt->lx,DExt->ly,TRUE); break; case WS_SETFLAG: if (!strcmp(ptr,"MAX")) // Setta lo stile della finestra { if (info<1) info=1; //*psBar->iMax=info; psBar->iMax=info; } if (!strcmp(ptr,"COL")) // Setta lo stile della finestra { // *(lpi+3)=info; psBar->cBar=info; obj_vedisolo(objCalled->nome); } if (!strcmp(ptr,"CNT")) // Setta lo stile della finestra { //*lpi=info; psBar->iCount=info; // Calcolo percentuale iRiemp=psBar->iCount; if (iRiemp>(psBar->iMax)) iRiemp=psBar->iMax; iPos=0; if (psBar->iMax) iPos=100*iRiemp/psBar->iMax;// calcolo percntuale di riempimento // Se la percentuale è cambiata ristampo il tutto if (psBar->iPerc!=iPos) { psBar->iPerc=iPos; if (objCalled->hWnd) SendMessage(objCalled->hWnd, PBM_SETPOS, psBar->iPerc, 0); else obj_vedisolo(objCalled->nome); } //if (*lpi!=info) {*lpi=info; obj_vedisolo(objCalled->nome);} } break; case WS_DISPLAY: if (objCalled->hWnd) {InvalidateRect(objCalled->hWnd,NULL,TRUE); break;} iLx=DExt->px+DExt->lx-1; iLy=DExt->py+DExt->ly-1; iRiemp=psBar->iCount; if (iRiemp>(psBar->iMax)) iRiemp=psBar->iMax; iPos=100*iRiemp/psBar->iMax;// calcolo percentuale di riempimento iBar=(DExt->lx-3)*iRiemp/psBar->iMax;// Calcolo dimensione barra pieno iDiv=(DExt->px+iBar); //Tbox(DExt->px,DExt->py,iLx,iLy,0,SET); box3d(DExt->px,DExt->py,iLx,iLy,1); // dispf(iText,DExt->py,15,-1,ON,"SMALL F",3,szServ); ThePoint=(DExt->ly/3); iMyShadow=ColorLum(sys.Color3DShadow,-30); if (iBar>0) { Tline(DExt->px+1,DExt->py+1,iDiv,DExt->py+1,iMyShadow,SET); for (a=2;a<DExt->ly-2;a++) { LONG Col; if (a<ThePoint) Col=ColorFusion(sys.Color3DShadow,psBar->cBar,(100/ThePoint*a)); else Col=ColorFusion(sys.Color3DShadow,psBar->cBar,(100/(DExt->ly-ThePoint)*(DExt->ly-a))); // iEnd=iDiv+a-2; if (iEnd>iLx-1) iEnd=iLx-1; iEnd=iDiv-2; if (iEnd>iLx-1) iEnd=iLx-1; Tline(DExt->px+2,DExt->py+a,iEnd,DExt->py+a,Col,SET); } Tline(DExt->px+1,iLy-1,iEnd,iLy-1,ColorLum(sys.Color3DShadow,-40),SET); } ThePoint=DExt->ly-ThePoint; if (iBar<(DExt->lx-2)) {//Tboxp(iDiv+1,DExt->py+2,iDiv+1,iLy-2,0,SET); //Tboxp(iDiv+2,DExt->py+1,iLx-1,iLy-1,ColorLum(sys.Color3DShadow,-10),SET); for (a=1;a<DExt->ly-1;a++) { LONG Col; if (a<ThePoint) Col=ColorFusion(iMyShadow,sys.Color3DLight,(100/ThePoint*a)); else Col=ColorFusion(iMyShadow,sys.Color3DLight,(100/(DExt->ly-ThePoint)*(DExt->ly-a))); // if (iBar>0) {iEnd=iDiv+a; if (iEnd>iLx-1) iEnd=iLx-1;} else iEnd=iDiv+1; if (iBar>0) {iEnd=iDiv-1; if (iEnd>iLx-1) iEnd=iLx-1;} else iEnd=iDiv+1; Tline(iEnd,DExt->py+a,iLx-1,DExt->py+a,Col,SET); } } //sys.fFontBold=FALSE; break; } return NULL; }
/* * This method is the implementation of the HyCon3D algorithm. * This algorithm computes the exclusive contribution to the hypervolume by every point, using an efficient HyCon3D algorithm by Emmerich and Fonseca. * * @see "Computing hypervolume contribution in low dimensions: asymptotically optimal algorithm and complexity results", Michael T. M. Emmerich, Carlos M. Fonseca * * @param[in] points vector of points containing the 3-dimensional points for which we compute the hypervolume * @param[in] r_point reference point for the points * @return vector of exclusive contributions by every point */ std::vector<double> hv3d::contributions(std::vector<fitness_vector> &points, const fitness_vector &r_point) const { // Make a copy of the original set of points std::vector<fitness_vector> p(points.begin(), points.end()); std::vector<std::pair<fitness_vector, unsigned int> > point_pairs; point_pairs.reserve(p.size()); for(unsigned int i = 0 ; i < p.size() ; ++i) { point_pairs.push_back(std::make_pair(p[i], i)); } if (m_initial_sorting) { sort(point_pairs.begin(), point_pairs.end(), hycon3d_sort_cmp); } for(unsigned int i = 0 ; i < p.size() ; ++i) { p[i] = point_pairs[i].first; } typedef std::multiset<std::pair<fitness_vector, int>, hycon3d_tree_cmp > tree_t; unsigned int n = p.size(); const double INF = std::numeric_limits<double>::max(); // Placeholder value for undefined lower z value. const double NaN = INF; // Contributions std::vector<double> c(n, 0.0); // Sentinel points fitness_vector s_x(3, -INF); s_x[0] = r_point[0]; // (r,oo,oo) fitness_vector s_y(3, -INF); s_y[1] = r_point[1]; // (oo,r,oo) fitness_vector s_z(3, -INF); s_z[2] = r_point[2]; // (oo,oo,r) p.push_back(s_z); // p[n] p.push_back(s_x); // p[n + 1] p.push_back(s_y); // p[n + 2] tree_t T; T.insert(std::make_pair(p[0], 0)); T.insert(std::make_pair(s_x, n + 1)); T.insert(std::make_pair(s_y, n + 2)); // Boxes std::vector<std::deque<box3d> > L(n + 3); box3d b(r_point[0], r_point[1], NaN, p[0][0], p[0][1], p[0][2]); L[0].push_front(b); for (unsigned int i = 1 ; i < n + 1 ; ++i) { std::pair<fitness_vector, int> pi(p[i], i); tree_t::iterator it = T.lower_bound(pi); // Point is dominated if (p[i][1] >= (*it).first[1]) { return wfg(2).contributions(points, r_point); } tree_t::reverse_iterator r_it(it); std::vector<int> d; while((*r_it).first[1] > p[i][1]) { d.push_back((*r_it).second); ++r_it; } int r = (*it).second; int t = (*r_it).second; T.erase(r_it.base(), it); // Process right neighbor region, region R while(!L[r].empty()) { box3d& b = L[r].front(); if(b.ux >= p[i][0]) { b.lz = p[i][2]; c[r] += box_volume(b); L[r].pop_front(); } else if(b.lx > p[i][0]) { b.lz = p[i][2]; c[r] += box_volume(b); b.lx = p[i][0]; b.uz = p[i][2]; b.lz = NaN; break; } else { break; } } // Process dominated points, region M double xleft = p[t][0]; std::vector<int>::reverse_iterator r_it_idx = d.rbegin(); std::vector<int>::reverse_iterator r_it_idx_e = d.rend(); for(;r_it_idx != r_it_idx_e ; ++r_it_idx) { int jdom = *r_it_idx; while(!L[jdom].empty()) { box3d& b = L[jdom].front(); b.lz = p[i][2]; c[jdom] += box_volume(b); L[jdom].pop_front(); } L[i].push_back(box3d(xleft, p[jdom][1], NaN, p[jdom][0], p[i][1], p[i][2])); xleft = p[jdom][0]; } L[i].push_back(box3d(xleft, p[r][1], NaN, p[i][0], p[i][1], p[i][2])); xleft = p[t][0]; // Process left neighbor region, region L while(!L[t].empty()) { box3d &b = L[t].back(); if(b.ly > p[i][1]) { b.lz = p[i][2]; c[t] += box_volume(b); xleft = b.lx; L[t].pop_back(); } else { break; } } if (xleft > p[t][0]) { L[t].push_back(box3d(xleft, p[i][1], NaN, p[t][0], p[t][1], p[i][2])); } T.insert(std::make_pair(p[i], i)); } // Fix the indices std::vector<double> contribs(n, 0.0); for(unsigned int i=0;i < c.size();++i) { contribs[point_pairs[i].second] = c[i]; } return contribs; }