int test_levels(int map_layout [MAX_X][MAX_Y]) // function for agreagate testing
{
//printf("Drawing test\n");
int selected_option, control;
int wrong_input = 0;
do
{
if (wrong_input == 1)
{
printf("The chosen option is not valid.\nNumber of desired option: ");
control = scanf("%d", &selected_option);
fflush(stdin);
}
else
{
printf("Choose the level of difficulty: ");
printf("\nEASY LEVEL - 1 ");
printf("\nMEDIUM LEVEL - 2 ");
printf("\nHARD LEVEL - 3 ");
printf("\nNumber of desired option: ");
control = scanf("%d", &selected_option);
fflush(stdin);
wrong_input = 1;
}
}
while (selected_option < 1 || selected_option > 3 || control == 0);
// selected_level = level_set (selected_option); Problem with this function
if(selected_option == 1)
{
//Load EASY LEVEL
levels(1);
create_mountain_map(map_layout);
//test_drawing_map(map_layout);
//test_drawing_units(map_layout);
}
else if(selected_option == 2)
{
//Load MEDIUM LEVEL
levels(2);
create_mountain_map(map_layout);
//test_drawing_map(map_layout);
//test_drawing_units(map_layout);
}
else if(selected_option == 3)
{
//Load HARD LEVEL
levels(3);
create_mountain_map(map_layout);
//test_drawing_map(map_layout);
//test_drawing_units(map_layout);
}
game_loop(map_layout);
return selected_option;
}
QRect
WPiano::rect2qrect(const Rect &rect) const
{
int l = time2x(rect.time_beg);
int r = time2x(rect.time_end);
int t = rect.level_end > levels(track()) ? 0 : level2y(rect.level_end);
int b = rect.level_end > levels(track()) ? height() : level2y(rect.level_beg);
return QRect(l, t, r-l, b-t);
}
void reachFst(Hg const& hg, RemainingInArcs &remainIn, StateId tail) {
std::size_t nLevels = levels().size();
assert(tail<nLevels);
Level headLevel = levels()[tail]+1;
for (ArcId aid = 0, nArcs = hg.numOutArcs(tail); aid!=nArcs; ++aid) {
StateId head = hg.outArc(tail, aid)->head();
if (--remainIn[head]==0) {
Util::maxEq(Util::atExpand(levels(), head), headLevel);
reachFst(hg, remainIn, head);
}
}
}
static int shift_ll(LIKELIHOOD **** ll_pym,
struct Region *region, int block_size)
{
static int first = 1;
static int xoffset[20];
static int yoffset[20];
int xdelta;
int ystart, ystop, ydelta;
int D;
int k, i;
int block_size_k;
struct Region region_buff;
/* if first time, set offsets to 0 */
if (first) {
D = levels(block_size, block_size);
for (k = 0; k <= D; k++)
xoffset[k] = yoffset[k] = 0;
first = 0;
}
/* save region information */
copy_reg(region, ®ion_buff);
/* subtract pointer offsets for each scale */
D = levels(block_size, block_size);
block_size_k = block_size;
for (k = 0; k <= D; k++) {
xdelta = region->xmin - xoffset[k];
ydelta = region->ymin - yoffset[k];
xoffset[k] = region->xmin;
yoffset[k] = region->ymin;
ystart = region->ymin;
ystop = ystart + block_size_k;
ll_pym[k] -= ydelta;
for (i = ystart; i < ystop; i++)
ll_pym[k][i] -= xdelta;
dec_reg(region);
block_size_k = block_size_k / 2;
}
/* replace region information */
copy_reg(®ion_buff, region);
return 0;
}
void
Fingerprint::CalculateFP(OpenBabel::OBMol* mol, std::vector<unsigned int> & _fp)
{
_fp.clear();
_fp.resize(1024 / _bitsPerInt, 0);
_fragset.clear();
_ringset.clear();
OpenBabel::OBAtom* atom;
std::vector<OpenBabel::OBAtom*>::iterator i;
for (atom = mol->BeginAtom(i); atom; atom = mol->NextAtom(i))
{
std::vector<int> curfrag;
std::vector<int> levels(mol->NumAtoms() + 1, 0);
_getFragments(levels, curfrag, 1, atom, NULL);
}
_doRings();
_doReverses();
// Hash into fingerprint
std::set<std::vector<int> >::iterator itr;
for (itr = _fragset.begin(); itr != _fragset.end(); ++itr)
{
unsigned int hash = _calcHash(*itr);
_setBit(_fp, hash);
}
}
void LevelsFilter::filterImage()
{
ImageLevels levels(m_orgImage.sixteenBit());
for (int i = 0 ; i < 5 ; ++i)
{
postProgress(i * 10);
levels.setLevelLowInputValue(i, m_settings.lInput[i]);
levels.setLevelHighInputValue(i, m_settings.hInput[i]);
levels.setLevelLowOutputValue(i, m_settings.lOutput[i]);
levels.setLevelHighOutputValue(i, m_settings.hOutput[i]);
levels.setLevelGammaValue(i, m_settings.gamma[i]);
}
postProgress(50);
m_destImage = DImg(m_orgImage.width(), m_orgImage.height(), m_orgImage.sixteenBit(), m_orgImage.hasAlpha());
postProgress(60);
levels.levelsCalculateTransfers();
postProgress(70);
// Process all channels Levels
levels.levelsLutSetup(AlphaChannel);
postProgress(80);
levels.levelsLutProcess(m_orgImage.bits(), m_destImage.bits(), m_orgImage.width(), m_orgImage.height());
postProgress(90);
}
WPiano::Rect
WPiano::selectionRect(bool returnAllIfEmpty) const
{
Rect ret;
if (!returnAllIfEmpty && (!pivot_enabled_ || (pivot_time_ == cursor_time_ && pivot_level_ == cursor_level_)))
return ret;
if (!pivot_enabled_ || pivot_time_ == cursor_time_) {
ret.time_beg = 0;
ret.time_end = VMD_MAX_TIME;
} else {
ret.time_beg = std::min(pivot_time_, cursor_time_);
ret.time_end = std::max(pivot_time_, cursor_time_);
}
if (!pivot_enabled_ || pivot_level_ == cursor_level_) {
ret.level_beg = 0;
ret.level_end = levels(track()) + 1;
} else if (pivot_level_ < cursor_level_) {
ret.level_beg = pivot_level_;
ret.level_end = cursor_level_;
} else if (pivot_level_ > cursor_level_) {
ret.level_beg = cursor_level_ + 1;
ret.level_end = pivot_level_ + 1;
}
return ret;
}
//TODO: refactor
static vmd_pitch_t
level2pitch(const vmd_track_t *track, int level, bool round_up = false)
{
if (level < 0)
return round_up ? 0 : -1;
if (level >= levels(track))
return round_up ? VMD_MAX_PITCH : -1;
const vmd_notesystem_t *ns = &track->notesystem;
int octaves = level / (vmd_notesystem_levels(ns) + 1);
level %= (vmd_notesystem_levels(ns) + 1);
vmd_pitch_t octave_pitch;
if (level == 0) {
if (round_up)
octave_pitch = 0;
else
return -1;
} else {
while ((octave_pitch = vmd_notesystem_level2pitch(ns, level - 1)) < 0) {
if (round_up)
level++;
else
return -1;
}
}
return octaves * ns->size + octave_pitch;
}
static optional<pair<expr, expr>> mk_op(environment const & env, old_local_context & ctx, type_checker_ptr & tc,
name const & op, unsigned nunivs, unsigned nargs, std::initializer_list<expr> const & explicit_args,
constraint_seq & cs, tag g) {
levels lvls;
for (unsigned i = 0; i < nunivs; i++)
lvls = levels(mk_meta_univ(mk_fresh_name()), lvls);
expr c = mk_constant(op, lvls);
expr op_type = instantiate_type_univ_params(env.get(op), lvls);
buffer<expr> args;
for (unsigned i = 0; i < nargs; i++) {
if (!is_pi(op_type))
return optional<pair<expr, expr>>();
expr arg = ctx.mk_meta(some_expr(binding_domain(op_type)), g);
args.push_back(arg);
op_type = instantiate(binding_body(op_type), arg);
}
expr r = mk_app(c, args, g);
for (expr const & explicit_arg : explicit_args) {
if (!is_pi(op_type))
return optional<pair<expr, expr>>();
r = mk_app(r, explicit_arg);
expr type = tc->infer(explicit_arg, cs);
justification j = mk_app_justification(r, op_type, explicit_arg, type);
if (!tc->is_def_eq(binding_domain(op_type), type, j, cs))
return optional<pair<expr, expr>>();
op_type = instantiate(binding_body(op_type), explicit_arg);
}
return some(mk_pair(r, op_type));
}
void WaldBoost::detect(Ptr<CvFeatureEvaluator> eval,
const Mat& img, const std::vector<float>& scales,
std::vector<Rect>& bboxes, std::vector<double>& confidences)
{
bboxes.clear();
confidences.clear();
Mat resized_img;
int step = 4;
float h;
for (size_t i = 0; i < scales.size(); ++i) {
float scale = scales[i];
resize(img, resized_img, Size(), scale, scale, INTER_LINEAR_EXACT);
eval->setImage(resized_img, 0, 0, feature_indices_);
int n_rows = (int)(24 / scale);
int n_cols = (int)(24 / scale);
for (int r = 0; r + 24 < resized_img.rows; r += step) {
for (int c = 0; c + 24 < resized_img.cols; c += step) {
eval->setWindow(Point(c, r));
if (predict(eval, &h) == +1) {
int row = (int)(r / scale);
int col = (int)(c / scale);
bboxes.push_back(Rect(col, row, n_cols, n_rows));
confidences.push_back(h);
}
}
}
}
std::vector<int> levels(bboxes.size(), 0);
groupRectangles(bboxes, levels, confidences, 3, 0.7);
}
// Takes color image and set of points provided by Python, outputs relative
// position and orientation
void find_totes_depth(cv::Mat color, cv::Mat depth, std::vector<Target> &r_targets, std::vector<cv::Point> points, double effective_height, double depth_correction, int hfov, int vfov)
{
/* Separate image into depth layers and discard bottom layer */
cv::Mat levels(depth);
levels.convertTo(levels, CV_8UC1);
for (int i = 0; i < levels.size().width; i++) {
for (int j = 0; j < levels.size().height; j++) {
uchar tmp = int(levels.at<uchar>(i,j) - round((depth.size().height-j)*(depth_correction/depth.size().height)));
if (tmp >= 220) {
levels.at<uchar>(i,j) = 0;
} else if (tmp >= 208 && tmp < 220) {
levels.at<uchar>(i,j) = 1;
} else if (tmp >= 180 && tmp < 208) {
levels.at<uchar>(i,j) = 2;
} else {
levels.at<uchar>(i,j) = 3;
}
}
}
/* Designate one point in the background at level 0 as a point so that the algorithm works */
bool done = false;
for (int i = 0; i < levels.size().width && !done; i++) {
for (int j = 0; j < levels.size().height && !done; j++) {
if (levels.at<uchar>(i,j) == 0) {
points.push_back(cv::Point(i,j));
done = true;
}
}
}
/* Discard bottom level of color image */
cv::Mat processed;
cv::bitwise_and(color, color, processed, levels);
/* Apply watershed to color */
int height = depth.size().height;
int width = depth.size().width;
cv::Mat markers(height, width, CV_32F);
for (int i = 0; i < points.size(); i++) {
cv::Scalar color(i, i*100, i);
cv::circle(markers, points[i], 1, color, 20);
}
cv::watershed(color, markers);
for (int i = 0; i < points.size()-1 /* all but background point */; i++) {
acv::Target target;
target.type = "kinect tote";
// Set level (orientation) for tote.
target.orientation = std::to_string(levels.at<uchar>(points[i].x,points[i].y));
// Set angle for each tote.
/* TODO Build std::vector<cv::Point> containing all points within tote */
//cv::Rect min_rect = cv::minAreaRect(
/* TODO Take bottom left and right points and get angle of tote from trig */
// TODO Set coords with:
// int fov_to_pix_per_ft(int frame_dim, double effective_height, int hfov, int vfov);
}
}
//Load a unit from the input stream
Unit Unit::load(std::istream& in)
{
in.exceptions(std::istream::failbit | std::istream::eofbit);
std::vector<int> levels(7);
std::string iacode;
std::for_each(levels.begin(), levels.end(), [&in](int& level) {
in >> level;
});
static int
avg_level(vmd_track_t *track, vmd_time_t beg, vmd_time_t end)
{
avg_note_arg arg = {
track,
levels(track),
0
};
vmd_track_for_range(track, beg, end, avg_note_clb, &arg);
return (arg.min + arg.max) / 2;
}
Spectrogram* Spectrogram::copy()
{
Spectrogram *new_s = new Spectrogram(matrix());
new_s->setDisplayMode(QwtPlotSpectrogram::ImageMode, testDisplayMode(QwtPlotSpectrogram::ImageMode));
new_s->setDisplayMode(QwtPlotSpectrogram::ContourMode, testDisplayMode(QwtPlotSpectrogram::ContourMode));
new_s->setColorMap (colorMap());
new_s->setAxis(xAxis(), yAxis());
new_s->setDefaultContourPen(defaultContourPen());
new_s->setLevelsNumber(levels());
new_s->color_map_policy = color_map_policy;
return new_s;
}
void
SortWidget::trimToLevel( const int level )
{
for( int i = m_ribbon->count() - 1 ; i > level; i-- )
{
BreadcrumbItem *item = qobject_cast< BreadcrumbItem * >( m_ribbon->itemAt( i )->widget() );
m_ribbon->removeWidget( item );
item->deleteLater();
}
updateSortScheme();
m_addButton->updateMenu( levels() );
}
MetaData::MetaData (Rcpp::List md)
/*
* Construct meta data from the R list of meta data.
*
* Used for prediction.
*
* Format:
* [[0]] ---- Number of variables
* [[1]] ---- Index of target variable
* [[2]] ---- Target variable name
* [[3]] ---- Variable name vector
* [[4]] ---- Variable type vector
* [[5]] ---- Discrete variable value list
*/
{
nvars_ = Rcpp::as<int>(md[NVARS]);
var_types_ = type_vec(Rcpp::as<vector<int> >(md[VAR_TYPES]));
feature_vars_ = idx_vec(nvars_);
var_names_ = name_vec(nvars_);
Rcpp::CharacterVector varnames((SEXP)(md[VAR_NAMES]));
for (int vindex = 0; vindex < nvars_; vindex++) {
string name = Rcpp::as<string>((SEXPREC*)varnames[vindex]);
var_names_[vindex] = name;
}
Rcpp::List valuenames((SEXP)(md[VAL_NAMES]));
for (int i = 0; i < valuenames.size(); i++) {
Rcpp::List lst(valuenames[i]);
int vindex = Rcpp::as<int>((SEXPREC*)lst[0]);
Rcpp::CharacterVector levels(lst[1]);
int nlevels = levels.size();
name_vec levnames(nlevels);
name_value_map namevals;
for (int lindex = 0; lindex < nlevels; lindex++) {
string name = Rcpp::as<string>((SEXPREC*)levels[lindex]);
namevals.insert(name_value_map::value_type(name, lindex));
levnames[lindex] = name;
}
var_values_[vindex].swap(namevals);
val_names_[vindex].swap(levnames);
}
for (int i = 0; i < nvars_; ++i)
feature_vars_[i] = i;
nlabels_ = val_names_[nvars_].size();
}
QString Spectrogram::saveToString()
{
QString s = "<spectrogram>\n";
s += "\t<matrix>" + QString(d_matrix->objectName()) + "</matrix>\n";
if (color_map_policy != Custom)
s += "\t<ColorPolicy>" + QString::number(color_map_policy) + "</ColorPolicy>\n";
else
{
s += "\t<ColorMap>\n";
s += "\t\t<Mode>" + QString::number(color_map.mode()) + "</Mode>\n";
s += "\t\t<MinColor>" + color_map.color1().name() + "</MinColor>\n";
s += "\t\t<MaxColor>" + color_map.color2().name() + "</MaxColor>\n";
QwtArray <double> colors = color_map.colorStops();
int stops = (int)colors.size();
s += "\t\t<ColorStops>" + QString::number(stops - 2) + "</ColorStops>\n";
for (int i = 1; i < stops - 1; i++)
{
s += "\t\t<Stop>" + QString::number(colors[i]) + "\t";
s += QColor(color_map.rgb(QwtDoubleInterval(0,1), colors[i])).name();
s += "</Stop>\n";
}
s += "\t</ColorMap>\n";
}
s += "\t<Image>"+QString::number(testDisplayMode(QwtPlotSpectrogram::ImageMode))+"</Image>\n";
bool contourLines = testDisplayMode(QwtPlotSpectrogram::ContourMode);
s += "\t<ContourLines>"+QString::number(contourLines)+"</ContourLines>\n";
if (contourLines)
{
s += "\t\t<Levels>"+QString::number(levels())+"</Levels>\n";
bool defaultPen = defaultContourPen().style() != Qt::NoPen;
s += "\t\t<DefaultPen>"+QString::number(defaultPen)+"</DefaultPen>\n";
if (defaultPen)
{
s += "\t\t\t<PenColor>"+defaultContourPen().color().name()+"</PenColor>\n";
s += "\t\t\t<PenWidth>"+QString::number(defaultContourPen().widthF())+"</PenWidth>\n";
s += "\t\t\t<PenStyle>"+QString::number(defaultContourPen().style() - 1)+"</PenStyle>\n";
}
}
QwtScaleWidget *colorAxis = plot()->axisWidget(color_axis);
if (colorAxis && colorAxis->isColorBarEnabled())
{
s += "\t<ColorBar>\n\t\t<axis>" + QString::number(color_axis) + "</axis>\n";
s += "\t\t<width>" + QString::number(colorAxis->colorBarWidth()) + "</width>\n";
s += "\t</ColorBar>\n";
}
s += "\t<Visible>"+ QString::number(isVisible()) + "</Visible>\n";
return s+"</spectrogram>\n";
}
void
SortWidget::addLevel( QString internalColumnName, Qt::SortOrder sortOrder ) //private slot
{
BreadcrumbLevel *bLevel = new BreadcrumbLevel( internalColumnName );
BreadcrumbItem *item = new BreadcrumbItem( bLevel, this );
m_ribbon->addWidget( item );
connect( item, SIGNAL(clicked()), this, SLOT(onItemClicked()) );
connect( item->menu(), SIGNAL(actionClicked(QString)), this, SLOT(onItemSiblingClicked(QString)) );
connect( item->menu(), SIGNAL(shuffleActionClicked()), this, SLOT(onShuffleSiblingClicked()) );
connect( item, SIGNAL(orderInverted()), this, SLOT(updateSortScheme()) );
if( sortOrder != item->sortOrder() )
item->invertOrder();
m_addButton->updateMenu( levels() );
updateSortScheme();
}
void Spectrogram::updateData()
{
if (!d_matrix || !d_graph)
return;
setData(MatrixData(d_matrix, d_use_matrix_formula));
setLevelsNumber(levels());
QwtScaleWidget *colorAxis = d_graph->axisWidget(color_axis);
if (colorAxis)
colorAxis->setColorMap(data().range(), colorMap());
d_graph->setAxisScale(color_axis, data().range().minValue(), data().range().maxValue());
d_graph->replot();
}
CharacterVector reencode_factor(IntegerVector x) {
CharacterVector levels(reencode_char(get_levels(x)));
CharacterVector ret(x.length());
R_xlen_t nlevels = levels.length();
R_xlen_t len = x.length();
for (R_xlen_t i = 0; i < len; ++i) {
int xi = x[i];
if (xi <= 0 || xi > nlevels)
ret[i] = NA_STRING;
else
ret[i] = levels[xi - 1];
}
return ret;
}
//Provide a randomly muteted version of the current unit
Unit Unit::mutate()const
{
int index = std::rand()%7;
std::vector<int> levels(7);
for(int i = 0; i < 7; ++i) {
levels[i] = capacities_[i]->getLevel();
}
while(levels[index]==0) {
index = std::rand()%7;
}
int index2 = std::rand()%7;
while(index == index2) {
index2 = std::rand()%7;
}
levels[index]--;
levels[index2]++;
return Unit(iaCode_,levels);
}
void Spectrogram::updateData(Matrix *m)
{
if (!m)
return;
QwtPlot *plot = this->plot();
if (!plot)
return;
setData(MatrixData(m));
setLevelsNumber(levels());
QwtScaleWidget *colorAxis = plot->axisWidget(color_axis);
if (colorAxis)
colorAxis->setColorMap(data().range(), colorMap());
plot->setAxisScale(color_axis, data().range().minValue(), data().range().maxValue());
plot->replot();
}
//Star operator overloading, providing a random crossing of the current
//unit and the one provided in parameter.
Unit Unit::operator*(const Unit& unit)const
{
std::vector<int> maxLevels(7);
for(int i = 0; i < 7; ++i) {
maxLevels[i] = std::max(capacities_[i]->getLevel(), unit.getCapacity(i)->getLevel());
}
int gA = this->getLevel();
int gB = unit.getLevel();
int global = gA;
if(gA!=gB)
global = std::min(gA, gB)+std::rand()%std::abs(gA-gB);
std::vector<int> levels(7,0);
while(global) {
int index = std::rand()%7;
if(levels[index]<maxLevels[index]) {
levels[index]++;
global--;
}
}
std::string ia;
std::string ia2 = tree->getCode();
if (std::rand() % 2)
{
ia = std::string(iaCode_);
std::string oldIaPart = getRandomIATreeSonCode();
size_t start_pos = ia.find(oldIaPart);
if (start_pos != std::string::npos)
{
ia.replace(start_pos, oldIaPart.size(), unit.getRandomIATreeSonCode());
}
}
else
{
ia = std::string(unit.getIACode());
std::string oldIaPart = unit.getRandomIATreeSonCode();
size_t start_pos = ia.find(oldIaPart);
if (start_pos != std::string::npos)
{
ia.replace(start_pos, oldIaPart.size(), getRandomIATreeSonCode());
}
}
return Unit(ia,levels);
}
bool fingerprint2::GetFingerprint(OBBase* pOb, vector<unsigned int>&fp, int nbits)
{
OBMol* pmol = dynamic_cast<OBMol*>(pOb);
if(!pmol) return false;
fp.resize(1024/Getbitsperint());
fragset.clear();//needed because now only one instance of fp class
ringset.clear();
//identify fragments starting at every atom
OBAtom *patom;
vector<OBNodeBase*>::iterator i;
for (patom = pmol->BeginAtom(i);patom;patom = pmol->NextAtom(i))
{
if(patom->GetAtomicNum() == OBElements::Hydrogen) continue;
vector<int> curfrag;
vector<int> levels(pmol->NumAtoms());
getFragments(levels, curfrag, 1, patom, NULL);
}
// TRACE("%s %d frags before; ",pmol->GetTitle(),fragset.size());
//Ensure that each chemically identical fragment is present only in a single
DoRings();
DoReverses();
SetItr itr;
_ss.str("");
for(itr=fragset.begin();itr!=fragset.end();++itr)
{
//Use hash of fragment to set a bit in the fingerprint
int hash = CalcHash(*itr);
SetBit(fp,hash);
if(!(Flags() & FPT_NOINFO))
PrintFpt(*itr,hash);
}
if(nbits)
Fold(fp, nbits);
// TRACE("%d after\n",fragset.size());
return true;
}
void CEnv::SetData(Rcpp::IntegerMatrix x_, Rcpp::IntegerMatrix mcz_) {
int J = x_.nrow();
int n = x_.ncol();
int nZeroMC = mcz_.ncol();
if (mcz_.nrow() != J) { // no mcz
nZeroMC = 0;
}
intvec x = Rcpp::as<intvec>(x_);
intvec mcz = Rcpp::as<intvec>(mcz_);
Rcpp::List something(x_.attr("levels"));
intvec levels(something.size());
for (unsigned int i = 0; i < levels.size(); i++) {
SEXP exp = something[i];
Rcpp::CharacterVector v(exp);
levels[i] = v.size();
//Rprintf( "%d\n", levels[i]) ;
}
SetData(x, J, n, mcz, nZeroMC, levels);
}
int main() {
int level = 14;
//time stuff
struct timeval t1, t2;
double elapsedTime1, elapsedTime2;
printf("Starting none threaded\n");
// start timer
gettimeofday(&t1, NULL);
levels(level);
// stop timer
gettimeofday(&t2, NULL);
elapsedTime1 = (t2.tv_sec - t1.tv_sec);
threadpool thpool = thpool_init(2);
// start timer
gettimeofday(&t1, NULL);
level--;
for (int i = 0; i < level; i++) {
thpool_add_work(thpool, (void*)levels, level);
}
thpool_wait(thpool);
// stop timer
gettimeofday(&t2, NULL);
elapsedTime2 = (t2.tv_sec - t1.tv_sec);
printf("done\n");
printf("None threaded seconds: %f\n", elapsedTime1);
printf("Threaded seconds: %f\n", elapsedTime2);
}
void UserManagement::readLevelData(QString fileName)
{
//READS THE LEVELS INFORMATION AND PARSES IT ACORDDINGLY
QFile levels(fileName);
if (levels.open(QIODevice::ReadOnly))
{
QTextStream reader(&levels);
QString data=reader.readLine();
QStringList values;
while(!data.isNull())
{
values=data.split(":");
levelLevel.append(values[0]);
QStringList sequenceValues;//used to append in for loop
sequenceValues=values[1].split(",");
for(int i=0;i<sequenceValues.size();i++)
{
levelSequence.append(sequenceValues[i]);
}
levelSequenceNumber.append(levelSequence);//MAKES A LIST OF SEQUENCES
levelSequence.clear();
levelRows.append(values[2]);
levelStart.append(values[3]);
levelInterval.append(values[4]);
levelDecrement.append(values[5]);
data = reader.readLine();
}
levels.close();
}
else
{
close=true;
}
}
WPiano::WPiano(File *_file, vmd_track_t *_track, vmd_time_t time, Player *_player)
:file_(_file),
track_(_track),
grid_size_(file()->division),
mouse_captured_(false),
cursor_time_(grid_snap_left(this, time)),
cursor_size_(file()->division),
cursor_level_(0),
pivot_enabled_(false),
selection_(NULL),
player_(_player)
{
int w = time2x(vmd_file_length(file()));
int h = margin * 2 + level_height * levels(track());
setMinimumSize(w, h);
setPalette(PianoPalette());
setFocusPolicy(Qt::StrongFocus);
connect(file_, SIGNAL(acted()), this, SLOT(update()));
connect(player_, SIGNAL(started()), this, SLOT(playStarted()));
connect(player_, SIGNAL(finished()), this, SLOT(playStopped()));
if (playing())
playStarted();
}
void* pixels() { return levels() + fLevelCount; }
const void* pixels() const { return levels() + fLevelCount; }
