void AllSubsets::reset(Matrix2D* m, Matrix2D& points, Vector& mu) { reset(); //create first subset matrix for(int j = 0; j <= sizeOfSubsample; j++) m->setValue(0, j, 1.0); for(int i = 1; i <= sizeOfSubsample; i++) { m->setValue(i, 0, mu.getValue(i-1)); } for(int j = 0; j < sizeOfSubsample - 1; j++) { selectedElements[j] = j; for(int i = 0; i < sizeOfSubsample; i++) { m->setValue(i+1, j+1, points.getValue(i,j)); } } selectedElements[numberOfElements - 1] = sizeOfSubsample - 1; for(int i = 0; i < sizeOfSubsample; i++) m->setValue(i+1, sizeOfSubsample, points.getValue(i, numberOfElements - 1)); }
//#define DEBUG void ProgSSNR::run() { show(); produceSideInfo(); Matrix2D<double> output; if (!radial_avg) { if (!generate_VSSNR) estimateSSNR(1, output); else estimateSSNR(2, output); if (fn_out == "") fn_out=fn_S.insertBeforeExtension("_SSNR").removeLastExtension().addExtension("xmd"); } else { radialAverage(output); if (fn_out == "") fn_out=fn_VSSNR.insertBeforeExtension("_radial_avg").removeLastExtension().addExtension("xmd"); } #ifdef DEBUG output.write(fn_out); #endif MetaData MD; for (size_t i=1; i<MAT_YSIZE(output); ++i) { size_t id=MD.addObject(); MD.setValue(MDL_RESOLUTION_FREQ,output(i,1),id); MD.setValue(MDL_RESOLUTION_SSNR,output(i,2),id); MD.setValue(MDL_RESOLUTION_FREQREAL,1.0/output(i,1),id); } MD.write(fn_out); }
int MatrixBinder::setTy(lua_State* L) { Binder binder(L); Matrix2D* matrix = static_cast<Matrix2D*>(binder.getInstance("Matrix", 1)); matrix->setTy(luaL_checknumber(L, 2)); return 0; }
int MatrixBinder::getTx(lua_State* L) { Binder binder(L); Matrix2D* matrix = static_cast<Matrix2D*>(binder.getInstance("Matrix", 1)); lua_pushnumber(L, matrix->tx()); return 1; }
void TextureTest::ProcessEvent(SDL_Event* event) { switch(event->type) { case SDL_MOUSEBUTTONDOWN: { if(event->button.button == 4) { } else if(event->button.button == 5) { } break; } case SDL_KEYDOWN: { if(event->key.keysym.sym == SDLK_UP) { Vector2D oldSteer = v->GetVelocity(); Vector2D temp = v->GetVelocity(); temp.Normalize(); v->SetVelocity(oldSteer+temp*16); //v->SetHeading(v->GetVelocity()); } if(event->key.keysym.sym == SDLK_DOWN) { Vector2D oldSteer = v->GetVelocity(); Vector2D temp = v->GetVelocity(); temp.Normalize(); v->SetVelocity(oldSteer-temp*163); } if(event->key.keysym.sym == SDLK_LEFT) { Matrix2D mat; //Vector2D vec = v->GetVelocity(); Vector2D vecH = v->GetVelocity(); //Vec2DRotateAroundO(vecH,angle); mat.Rotate(angle); // //mat.Rotate(angle); mat.TransformVector(vecH); // / mat.TransformVector(vecH); // //v->SetVelocity(vec); // v->RotateHeadingToFacePosition(vecH); //v->SetSteeringForce(vecH); v->SetVelocity(vecH); angle=0.07; } break; } //case SDL_KEYUP } }
void GaussJordan::print(Matrix2D const & A) const { std::cout << std::endl; for (IMatrix2D::size_type i = 0; i < A.rows(); ++i) { IMatrix2D::size_type row = logicalToPhysicalRowIndex(i); for (IMatrix2D::size_type j = 0; j < A.cols(); ++j) { std::cout << std::setw(10) << A(row, j); } std::cout << std::endl; } }
/* Interface to numerical recipes: svbksb ---------------------------------- */ void svbksb(Matrix2D<double> &u, Matrix1D<double> &w, Matrix2D<double> &v, Matrix1D<double> &b, Matrix1D<double> &x) { // Call to the numerical recipes routine. Results will be stored in X svbksb(u.adaptForNumericalRecipes2(), w.adaptForNumericalRecipes(), v.adaptForNumericalRecipes2(), u.mdimy, u.mdimx, b.adaptForNumericalRecipes(), x.adaptForNumericalRecipes()); }
Matrix2D GetImageLineMatrix(double x1, double y1, double x2, double y2, const Image& image) { Matrix2D m; Size sz = image.GetSize(); m.scale(agg::calc_distance(x1, y1, x2, y2) / sz.cx); if(fabs(x2 - x1) < fabs(y2 - y1) * 1e-6) m.rotate(y2 > y1 ? M_PI_2 : -M_PI_2); else m.rotate(atan((y2 - y1) / (x2 - x1))); m.translate(x1, y1); return m; }
// Get matrix ============================================================== void SymList::get_matrices(int i, Matrix2D<DOUBLE> &L, Matrix2D<DOUBLE> &R) const { int k, l; L.initZeros(4, 4); R.initZeros(4, 4); for (k = 4 * i; k < 4*i + 4; k++) for (l = 0; l < 4; l++) { L(k - 4*i, l) = __L(k, l); R(k - 4*i, l) = __R(k, l); } }
void optimiseTransformationMatrixContinuous() { // Get coordinates of all pairs: Matrix2D<double> Au, Bt; Au.initZeros(3, 3); Bt.initZeros(3, 3); Pass.initZeros(4,4); // Add all pairs to dependent matrices (adapted from add_point in Xmipps micrograph_mark main_widget_mark.cpp) for (int t = 0; t < pairs_t2u.size(); t++) { int u = pairs_t2u[t]; if (u >= 0) { Au(0, 0) += (double)(p_unt[2*u] * p_unt[2*u]); Au(0, 1) += (double)(p_unt[2*u] * p_unt[2*u+1]); Au(0, 2) += (double)(p_unt[2*u]); Au(1, 0) = Au(0, 1); Au(1, 1) += (double)(p_unt[2*u+1] * p_unt[2*u+1]); Au(1, 2) += (double)(p_unt[2*u+1]); Au(2, 0) = Au(0, 2); Au(2, 1) = Au(1, 2); Au(2, 2) += 1.; Bt(0, 0) += (double)(p_til[2*t] * p_unt[2*u]); Bt(0, 1) += (double)(p_til[2*t+1] * p_unt[2*u]); Bt(0, 2) = Au(0, 2); Bt(1, 0) += (double)(p_til[2*t] * p_unt[2*u+1]); Bt(1, 1) += (double)(p_til[2*t+1] * p_unt[2*u+1]); Bt(1, 2) = Au(1, 2); Bt(2, 0) += (double)(p_til[2*t]); Bt(2, 1) += (double)(p_til[2*t+1]); Bt(2,2) += 1.; } } // Solve equations solve(Au, Bt, Pass); Pass = Pass.transpose(); std::cout << " Optimised passing matrix= " << Pass << std::endl; //These values can be complete CRAP. Better not show them at all.... //double rotp, tiltp, psip; //tiltp = acos(Pass(1,1)); //rotp = acos(Pass(1,0)/sin(tiltp)); //psip = acos(Pass(0,1)/-sin(tiltp)); //std::cout << " Optimised tilt angle= " << RAD2DEG(tiltp) << std::endl; //std::cout << " Optimised in-plane rot angles= " << RAD2DEG(rotp) <<" and "<< RAD2DEG(psip) << std::endl; // Map using the new matrix mapOntoTilt(); }
double JPetRecoImageTools::calculateProjection(const Matrix2D& emissionMatrix, double angle, int scanNumber, int nScans, InterpolationFunc& interpolationFunction) { int N = scanNumber - nScans / 2 ; const int kInputMatrixSize = emissionMatrix.size(); //if no. nScans is greater than the image width, then scale will be <1 const double scale = kInputMatrixSize / nScans; const double kSin45or125deg = std::sqrt(2) / 2; /// sin(45) deg const double kEpsilon = 0.0000001; const double kDegToRad = M_PI / 180.; double sin = std::sin(angle * kDegToRad - M_PI / 2.); sin = setToZeroIfSmall(sin, kEpsilon); double cos = std::cos(angle * kDegToRad - M_PI / 2.); cos = setToZeroIfSmall(cos, kEpsilon); double a = 0.; double b = 0.; /// The line over which we integrate is perpendicular to any line with the slope = tg(angle), so it is always -1/tg(angle). /// If the angle is between (45 to 125) /// we use y = a * x + b, and we iterate over rows of the matrix (x). /// If the angle is between [0 to 45 ] or [125 to 180] /// we use x = a* y +b, and we iterate over columns of the matrix (y) bool angleRange45To125 = std::abs(sin) > kSin45or125deg; double divided = 1.; std::function<double(int, int)> matrixGet; if (angleRange45To125) { assert(sin); a = -cos / sin; b = (N - cos - sin) / sin; b *= scale; matrixGet = matrixGetterFactory(emissionMatrix, false); // The matrix elements will be taken as (x,y). divided = std::abs(sin); } else { assert(cos); a = -sin / cos; b = (N - cos - sin) / cos; b *= scale; matrixGet = matrixGetterFactory(emissionMatrix, true); // The matrix elements will be taken as (y, x) - transposed. divided = std::abs(cos); } const int kMatrixCenter = emissionMatrix.size() / 2; double value = 0.; for (auto i = -kMatrixCenter; i < kMatrixCenter; i++) { value += interpolationFunction(i + kMatrixCenter , a * i + b + kMatrixCenter, matrixGet); } value /= divided; return value; }
int MatrixBinder::setElements(lua_State* L) { Binder binder(L); Matrix2D* matrix = static_cast<Matrix2D*>(binder.getInstance("Matrix", 1)); lua_Number m11 = luaL_optnumber(L, 2, 1); lua_Number m12 = luaL_optnumber(L, 3, 0); lua_Number m21 = luaL_optnumber(L, 4, 0); lua_Number m22 = luaL_optnumber(L, 5, 1); lua_Number tx = luaL_optnumber(L, 6, 0); lua_Number ty = luaL_optnumber(L, 7, 0); matrix->set(m11, m12, m21, m22, tx, ty); return 0; }
void GaussJordan::rearrangeDueToPivoting(Matrix2D & A, Matrix2D & AInverse, Vector & rhs) const { decltype(partial_pivoting_map_) physical_map(partial_pivoting_map_.size()); for (auto i = 0; i < partial_pivoting_map_.size(); ++i) { physical_map[i] = physicalToLogicalRowIndex(i); } for (auto i = 0; i < physical_map.size(); ++i) { auto j = std::distance(std::begin(physical_map), std::find(std::begin(physical_map), std::end(physical_map), i)); if (i == j) continue; // Swap rows for (auto col = 0; col < A.cols(); ++col) { std::swap(AInverse(i, col), AInverse(j, col)); std::swap(A(i, col), A(j, col)); } // AInverse.print(); // print(AInverse); // Swap rows on the r.h.s. std::swap(rhs(i), rhs(j)); std::swap(physical_map[i], physical_map[j]); } // AInverse.print(); // print(AInverse); }
JPetRecoImageTools::Matrix2DProj JPetRecoImageTools::sinogram(Matrix2D& emissionMatrix, int nViews, int nScans, double angleBeg, double angleEnd, InterpolationFunc interpolationFunction, RescaleFunc rescaleFunc, int minCutoff, int scaleFactor ) { assert(emissionMatrix.size() > 0); assert(emissionMatrix.size() == emissionMatrix[0].size()); assert(nViews > 0); assert(nScans > 0); assert(angleBeg < angleEnd); assert(minCutoff < scaleFactor); //create vector of size nViews, initialize it with vector of size nScans Matrix2DProj proj(nViews, std::vector<double>(nScans)); float stepsize = (angleEnd - angleBeg) / nViews; assert(stepsize > 0); //maybe != 0 ? int viewIndex = 0; for (auto phi = angleBeg; phi < angleEnd; phi = phi + stepsize, viewIndex++) { for (auto scanNumber = 0; scanNumber < nScans; scanNumber++) { proj[viewIndex][nScans - 1 - scanNumber] = JPetRecoImageTools::calculateProjection(emissionMatrix, phi, scanNumber, nScans, interpolationFunction); } } rescaleFunc(proj, minCutoff, scaleFactor); return proj; }
Matrix2D operator *( const Matrix2D &first, const Matrix2D &second ) { Matrix2D returnVal; for( int n = 0; n < Matrix2D::SIDE_LENGTH; n++ ) { for( int p = 0; p < Matrix2D::SIDE_LENGTH; p++ ) { float val = 0.0; for( int m = 0; m < Matrix2D::SIDE_LENGTH; m++ ) { val += first.Get( n, m ) + second.Get( m, p ); } returnVal.Set( n, p, val ); } } return returnVal; }
void AllSubsets::reset(Matrix2D* m, Matrix2D* m2, Matrix2D& points, Vector& mu) { reset(); reset(m, points, mu); //create first subset matrix for(int j = 0; j < sizeOfSubsample; j++) m2->setValue(0, j, 1.0); for(int j = 0; j < sizeOfSubsample - 1; j++) { for(int i = 0; i < sizeOfSubsample; i++) { m2->setValue(i+1, j, points.getValue(i,j)); } } for(int i = 0; i < sizeOfSubsample; i++) m2->setValue(i+1, sizeOfSubsample - 1, points.getValue(i, numberOfElements - 1)); }
std::function<double(int, int)> JPetRecoImageTools::matrixGetterFactory(const Matrix2D& emissionMatrix, bool isTransposed) { if (!isTransposed) { return [& emissionMatrix](int i, int j) { if (i >= 0 && i < (int) emissionMatrix[0].size() && j >= 0 && j < (int) emissionMatrix.size() ) { return emissionMatrix[i][j]; } else { return 0; } }; } else { return [& emissionMatrix](int i, int j) { if (i >= 0 && i < (int) emissionMatrix.size() && j >= 0 && j < (int) emissionMatrix[0].size() ) { return emissionMatrix[j][i]; } else { return 0; } }; } }
double FieldVariableDescriptor::GetComponent(const Matrix2D & m) const { //EK 2012-03-02 assert bug fix - if component_index_1 == FVCI_magnitude, component_index_2 does not matter assert(component_index_1 != FVCI_none && component_index_2 != FVCI_magnitude); assert(component_index_2 != FVCI_none || component_index_1 == FVCI_magnitude); if(component_index_1 == FVCI_magnitude) return sqrt(m.InnerProduct(m)); if(component_index_1 == FVCI_z || component_index_2 == FVCI_z) return FIELD_VARIABLE_NO_VALUE; // this may happen if there are 3D and 2D elements mixed in the system return m(component_index_1, component_index_2); }
/* Euler angles --> matrix ------------------------------------------------- */ void Euler_angles2matrix(DOUBLE alpha, DOUBLE beta, DOUBLE gamma, Matrix2D<DOUBLE> &A, bool homogeneous) { DOUBLE ca, sa, cb, sb, cg, sg; DOUBLE cc, cs, sc, ss; if (homogeneous) { A.initZeros(4, 4); MAT_ELEM(A, 3, 3) = 1; } else if (MAT_XSIZE(A) != 3 || MAT_YSIZE(A) != 3) A.resize(3, 3); alpha = DEG2RAD(alpha); beta = DEG2RAD(beta); gamma = DEG2RAD(gamma); ca = cos(alpha); cb = cos(beta); cg = cos(gamma); sa = sin(alpha); sb = sin(beta); sg = sin(gamma); cc = cb * ca; cs = cb * sa; sc = sb * ca; ss = sb * sa; A(0, 0) = cg * cc - sg * sa; A(0, 1) = cg * cs + sg * ca; A(0, 2) = -cg * sb; A(1, 0) = -sg * cc - cg * sa; A(1, 1) = -sg * cs + cg * ca; A(1, 2) = sg * sb; A(2, 0) = sc; A(2, 1) = ss; A(2, 2) = cb; }
void HessianLLE::completeYt(const Matrix2D<double> &V, const Matrix2D<double> &Yi, Matrix2D<double> &Yt_complete) { size_t Xdim = 1+MAT_XSIZE(V)+MAT_XSIZE(Yi); size_t Ydim = MAT_YSIZE(Yi); Yt_complete.resizeNoCopy(Ydim, Xdim); for (size_t i=0; i<Ydim; ++i) { MAT_ELEM(Yt_complete,i,0)=1.; memcpy(&MAT_ELEM(Yt_complete,i,1), &MAT_ELEM(V,i,0), MAT_XSIZE(V)*sizeof(double)); memcpy(&MAT_ELEM(Yt_complete,i,MAT_XSIZE(V)+1),&MAT_ELEM(Yi,i,0),MAT_XSIZE(Yi)*sizeof(double)); } }
void printMatrix(Matrix2D<double> &mat2, string name = "Matrix:") { cout << name << endl; for (int i = 0; i < mat2.get_cols(); i++) { cout << "| "; cout << '\t'; for (int j = 0; j < mat2.get_rows(); j++) { cout << mat2(j, i); if (j != mat2.get_rows() - 1) { cout << '\t'; } } cout << '\t'; cout << " |"; cout << endl; } cout << endl; cout.clear(); return; }
int MatrixBinder::getElements(lua_State* L) { Binder binder(L); Matrix2D* matrix = static_cast<Matrix2D*>(binder.getInstance("Matrix", 1)); lua_pushnumber(L, matrix->m11()); lua_pushnumber(L, matrix->m12()); lua_pushnumber(L, matrix->m21()); lua_pushnumber(L, matrix->m22()); lua_pushnumber(L, matrix->tx()); lua_pushnumber(L, matrix->ty()); return 6; }
bool SaveMatrixToFile( const Matrix2D<T>& m, std::string fileName ) { bool ok = true; std::ofstream ofs( fileName.c_str(), ios::out | ios::binary ); if( ofs.is_open() ) { ok = m.WriteTo( ofs ); ofs.close(); } else { std::cerr << "Unable to write matrix to file \'" << fileName << "\'" << std::endl; ok = false; } return ok; }
bool ReadMatrixFromFile( Matrix2D<T>& m, std::string fileName ) { bool ok = true; std::ifstream ifs( fileName.c_str(), ios::in | ios::binary ); if( ifs.is_open() ) { ok = m.ReadFrom( ifs ); ifs.close(); } else { std::cerr << "Unable to read matrix from file \'" << fileName << "\'" << std::endl; ok = false; } return ok; }
bool Line:: Collides( const Line &other, const Placement &thisPlacement, const Placement &otherPlacement ) const { Matrix2D thisTransform = thisPlacement.Get2DMatrix(); Matrix2D otherTransform = otherPlacement.Get2DMatrix(); Vec2D thisStart = thisTransform.Transform( start - thisPlacement.GetRotationPivot() ); Vec2D thisEnd = thisTransform.Transform( end - thisPlacement.GetRotationPivot() ); Vec2D otherStart = otherTransform.Transform( other.start - otherPlacement.GetRotationPivot() ); Vec2D otherEnd = otherTransform.Transform( other.end - otherPlacement.GetRotationPivot() ); return Collides( thisStart, thisEnd, other.origin, otherStart, otherEnd ); }
void HessianLLE::buildYiHessianEstimator(const Matrix2D<double> &V, Matrix2D<double> &Yi, size_t no_dim, size_t dp) { size_t ct = 0; Yi.resizeNoCopy(MAT_YSIZE(V),dp); for(size_t mm=0; mm<no_dim; mm++) { size_t length = no_dim-mm; size_t indle=mm; for(size_t nn=0; nn<length; nn++) { size_t column = ct+nn; for(size_t element = 0; element<MAT_YSIZE(V); element++) MAT_ELEM(Yi, element, column) = MAT_ELEM(V, element, mm)*MAT_ELEM(V, element, indle); ++indle; } ct += length; } }
IMatrix2D::size_type GaussJordan::getPivotElementsRowIndex(Matrix2D const & A, IMatrix2D::size_type column_index) const { /* Return the largest element in the column. * Note that no row can be pivot row more than once. * This is */ IMatrix2D::size_type max_row = A.rows(); IMatrix2D::size_type pivot_index = 0; double pivot_value = 0; double val; for (auto row_index = column_index; row_index < max_row; ++row_index) { auto mapped_row_index = logicalToPhysicalRowIndex(row_index); val = std::fabs(A(mapped_row_index, column_index)); if (val > pivot_value) { pivot_index = mapped_row_index; pivot_value = val; } } return pivot_index; }
void RandomSubsets::reset(Matrix2D* m, Matrix2D* m2, Matrix2D& points, Vector& mu) { reset(m, points, mu); reset(); //create first subset matrix for(int j = 0; j < sizeOfSubsample; j++) m2->setValue(0, j, 1.0); for(int j = 0; j < sizeOfSubsample - 1; j++) { for(int i = 0; i < sizeOfSubsample; i++) { m2->setValue(i+1, j, points.getValue(i,j)); } } getNextSubset(m,m2,points); count=0; }
void Initialize<T>::operator()( Matrix2D<T>& mtx ) { srand48( seed ); int nTileRows = mtx.GetNumRows() - 2 * haloWidth; if( (rowPeriod != -1) && (rowPeriod < nTileRows) ) { nTileRows = rowPeriod; } int nTileCols = mtx.GetNumColumns() - 2 * haloWidth; if( (colPeriod != -1) && (colPeriod < nTileCols) ) { nTileCols = colPeriod; } // initialize first tile for( unsigned int i = 0; i < nTileRows; i++ ) { for( unsigned int j = 0; j < nTileCols; j++ ) { #ifndef READY mtx.GetData()[i+haloWidth][j+haloWidth] = i * j; #else mtx.GetData()[i+haloWidth][j+haloWidth] = (T)drand48(); #endif // READY } } // initialize any remaining tiles // first we fill along rows a tile at a time, // then fill out along columns a row at a time if( colPeriod != -1 ) { int nTiles = (mtx.GetNumColumns() - 2*haloWidth) / colPeriod; if( (mtx.GetNumColumns() - 2*haloWidth) % colPeriod != 0 ) { nTiles += 1; } for( unsigned int t = 1; t < nTiles; t++ ) { for( unsigned int i = 0; i < nTileRows; i++ ) { memcpy( &(mtx.GetData()[haloWidth + i][haloWidth + t*nTileCols]), &(mtx.GetData()[haloWidth + i][haloWidth]), nTileCols * sizeof(T) ); } } } if( rowPeriod != -1 ) { int nTiles = (mtx.GetNumRows() - 2*haloWidth) / rowPeriod; if( (mtx.GetNumRows() - 2*haloWidth) % rowPeriod != 0 ) { nTiles += 1; } for( unsigned int t = 1; t < nTiles; t++ ) { for( unsigned int i = 0; i < nTileRows; i++ ) { memcpy( &(mtx.GetData()[haloWidth + t*nTileRows + i][haloWidth]), &(mtx.GetData()[haloWidth + i][haloWidth]), (mtx.GetNumColumns() - 2*haloWidth) * sizeof(T) ); } } } // initialize halo for( unsigned int i = 0; i < mtx.GetNumRows(); i++ ) { for( unsigned int j = 0; j < mtx.GetNumColumns(); j++ ) { bool inHalo = false; if( (i < haloWidth) || (i > mtx.GetNumRows() - 1 - haloWidth) ) { inHalo = true; } else if( (j < haloWidth) || (j > mtx.GetNumColumns() - 1 - haloWidth) ) { inHalo = true; } if( inHalo ) { mtx.GetData()[i][j] = haloVal; } } } }
ModifyConstraintSubactivitiesPreferredStartingTimesForm::ModifyConstraintSubactivitiesPreferredStartingTimesForm(QWidget* parent, ConstraintSubactivitiesPreferredStartingTimes* ctr): QDialog(parent) { setupUi(this); okPushButton->setDefault(true); connect(preferredTimesTable, SIGNAL(itemClicked(QTableWidgetItem*)), this, SLOT(itemClicked(QTableWidgetItem*))); connect(cancelPushButton, SIGNAL(clicked()), this, SLOT(cancel())); connect(okPushButton, SIGNAL(clicked()), this, SLOT(ok())); connect(setAllAllowedPushButton, SIGNAL(clicked()), this, SLOT(setAllSlotsAllowed())); connect(setAllNotAllowedPushButton, SIGNAL(clicked()), this, SLOT(setAllSlotsNotAllowed())); centerWidgetOnScreen(this); restoreFETDialogGeometry(this); QSize tmp1=teachersComboBox->minimumSizeHint(); Q_UNUSED(tmp1); QSize tmp2=studentsComboBox->minimumSizeHint(); Q_UNUSED(tmp2); QSize tmp3=subjectsComboBox->minimumSizeHint(); Q_UNUSED(tmp3); QSize tmp4=activityTagsComboBox->minimumSizeHint(); Q_UNUSED(tmp4); this->_ctr=ctr; updateTeachersComboBox(); updateStudentsComboBox(parent); updateSubjectsComboBox(); updateActivityTagsComboBox(); componentNumberSpinBox->setMinimum(1); componentNumberSpinBox->setMaximum(MAX_SPLIT_OF_AN_ACTIVITY); componentNumberSpinBox->setValue(this->_ctr->componentNumber); preferredTimesTable->setRowCount(gt.rules.nHoursPerDay); preferredTimesTable->setColumnCount(gt.rules.nDaysPerWeek); for(int j=0; j<gt.rules.nDaysPerWeek; j++){ QTableWidgetItem* item=new QTableWidgetItem(gt.rules.daysOfTheWeek[j]); preferredTimesTable->setHorizontalHeaderItem(j, item); } for(int i=0; i<gt.rules.nHoursPerDay; i++){ QTableWidgetItem* item=new QTableWidgetItem(gt.rules.hoursOfTheDay[i]); preferredTimesTable->setVerticalHeaderItem(i, item); } Matrix2D<bool> currentMatrix; currentMatrix.resize(gt.rules.nHoursPerDay, gt.rules.nDaysPerWeek); //bool currentMatrix[MAX_HOURS_PER_DAY][MAX_DAYS_PER_WEEK]; for(int i=0; i<gt.rules.nHoursPerDay; i++) for(int j=0; j<gt.rules.nDaysPerWeek; j++) currentMatrix[i][j]=false; for(int k=0; k<ctr->nPreferredStartingTimes_L; k++){ if(ctr->hours_L[k]==-1 || ctr->days_L[k]==-1) assert(0); int i=ctr->hours_L[k]; int j=ctr->days_L[k]; if(i>=0 && i<gt.rules.nHoursPerDay && j>=0 && j<gt.rules.nDaysPerWeek) currentMatrix[i][j]=true; } for(int i=0; i<gt.rules.nHoursPerDay; i++) for(int j=0; j<gt.rules.nDaysPerWeek; j++){ QTableWidgetItem* item= new QTableWidgetItem(); item->setTextAlignment(Qt::AlignCenter); item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled); preferredTimesTable->setItem(i, j, item); if(!currentMatrix[i][j]) item->setText(NO); else item->setText(YES); colorItem(item); } preferredTimesTable->resizeRowsToContents(); weightLineEdit->setText(CustomFETString::number(ctr->weightPercentage)); connect(preferredTimesTable->horizontalHeader(), SIGNAL(sectionClicked(int)), this, SLOT(horizontalHeaderClicked(int))); connect(preferredTimesTable->verticalHeader(), SIGNAL(sectionClicked(int)), this, SLOT(verticalHeaderClicked(int))); preferredTimesTable->setSelectionMode(QAbstractItemView::NoSelection); tableWidgetUpdateBug(preferredTimesTable); setStretchAvailabilityTableNicely(preferredTimesTable); }