MuseScore/omr/omrpage.h
2016-11-19 11:51:21 +01:00

259 lines
7.9 KiB
C++

//=============================================================================
// MusE Reader
// Music Score Reader
// $Id$
//
// Copyright (C) 2010 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//=============================================================================
#ifndef __OMRPAGE_H__
#define __OMRPAGE_H__
#include "libmscore/mscore.h"
#include "libmscore/durationtype.h"
#include "libmscore/fraction.h"
#include "libmscore/clef.h"
#include "libmscore/xml.h"
#include "libmscore/sym.h"
namespace Ms {
class Omr;
class Score;
class XmlWriter;
class XmlReader;
class Pattern;
class OmrPage;
//---------------------------------------------------------
// HLine
//---------------------------------------------------------
struct HLine {
int x1, x2, y;
HLine() {}
HLine(int a, int b, int c) : x1(a), x2(b), y(c) {}
};
//---------------------------------------------------------
// OmrPattern
//---------------------------------------------------------
class OmrPattern : public QRect {
public:
OmrPattern() : QRect(), sym(SymId::noSym), prob(0.0) {}
SymId sym;
double prob;
};
//---------------------------------------------------------
// OmrClef
//---------------------------------------------------------
class OmrClef : public OmrPattern {
public:
OmrClef() : OmrPattern() {}
OmrClef(const OmrPattern& p) : OmrPattern(p) {}
ClefType type = ClefType::G;//CLEF_G;
};
//---------------------------------------------------------
// OmrNote
// object on staff line
//---------------------------------------------------------
class OmrNote : public OmrPattern {
public:
int line;
};
//---------------------------------------------------------
// OmrChord
//---------------------------------------------------------
class OmrChord {
public:
TDuration duration;
QList<OmrNote*> notes;
};
//---------------------------------------------------------
// OmrTimesig
//---------------------------------------------------------
class OmrTimesig : public QRect {
public:
OmrTimesig() {}
OmrTimesig(const QRect& r) : QRect(r) {}
Fraction timesig;
};
//---------------------------------------------------------
// OmrKeySig
//---------------------------------------------------------
class OmrKeySig : public QRect {
public:
OmrKeySig() {}
OmrKeySig(const QRect& r) : QRect(r) {}
int type = 0; // -7 -> +7
};
//---------------------------------------------------------
// OmrMeasure
//---------------------------------------------------------
class OmrMeasure {
int _x1, _x2;
QList<QList<OmrChord>> _chords; // list of notes for every staff
OmrTimesig* _timesig = 0;
public:
OmrMeasure() {}
OmrMeasure(int x1, int x2) : _x1(x1), _x2(x2) {}
QList<QList<OmrChord>>& chords() { return _chords; }
const QList<QList<OmrChord>>& chords() const { return _chords; }
int x1() const { return _x1; }
int x2() const { return _x2; }
OmrTimesig* timesig() const { return _timesig; }
void setTimesig(OmrTimesig* ts) { _timesig = ts;}
};
//---------------------------------------------------------
// OmrStaff
// rectangle of staff lines
//---------------------------------------------------------
class OmrStaff : public QRect {
QList<OmrNote*> _notes;
OmrClef _clef;
OmrKeySig _keySig;
public:
OmrStaff() : QRect() {}
OmrStaff(const QRect& r) : QRect(r) {}
OmrStaff(int x, int y, int w, int h) : QRect(x, y, w, h) {}
QList<OmrNote*>& notes() { return _notes; }
const QList<OmrNote*>& notes() const { return _notes; }
OmrClef clef() const { return _clef; }
void setClef(const OmrClef& c) { _clef = c; }
OmrKeySig keySig() const { return _keySig; }
void setKeySig(const OmrKeySig& s) { _keySig = s; };
};
//---------------------------------------------------------
// OmrSystem
//---------------------------------------------------------
class OmrSystem {
OmrPage* _page;
QList<OmrStaff> _staves;
QList<OmrMeasure>_measures;
void searchNotes(QList<OmrNote*>*, int x1, int x2, int y, int line);
public:
OmrSystem(OmrPage* p) { _page = p; }
const QList<OmrStaff>& staves() const { return _staves; }
QList<OmrStaff>& staves() { return _staves; }
QList<OmrMeasure>& measures() { return _measures; }
const QList<OmrMeasure>& measures() const { return _measures; }
QList<QLine> barLines;
void searchSysBarLines();
float searchBarLinesvar(int n_staff, int **note_labels);
void searchNotes();
void searchNotes(int *note_labels, int ran);
};
//---------------------------------------------------------
// OmrPage
//---------------------------------------------------------
class OmrPage {
Omr* _omr;
QImage _image;
double _spatium;
double _ratio;
int cropL, cropR; // crop values in words (32 bit) units
int cropT, cropB; // crop values in pixel units
QList<QRect> _slices;
QList<OmrStaff> staves;
QList<HLine> slines;
QList<QLine> lines;
QList<OmrSystem> _systems;
void removeBorder();
void crop();
void slice();
double skew(const QRect&);
void deSkew();
void getStaffLines();
void getRatio();
double xproject2(int y);
int xproject(const uint* p, int wl);
void radonTransform(ulong* projection, int w, int n, const QRect&);
OmrTimesig* searchTimeSig(OmrSystem* system);
OmrClef searchClef(OmrSystem* system, OmrStaff* staff);
void searchKeySig(OmrSystem* system, OmrStaff* staff);
OmrPattern searchPattern(const std::vector<Pattern*>& pl, int y, int x1, int x2);
public:
OmrPage(Omr* _parent);
void setImage(const QImage& i) { _image = i; }
const QImage& image() const { return _image; }
QImage& image() { return _image; }
void read();
int width() const { return _image.width(); }
int height() const { return _image.height(); }
const uint* scanLine(int y) const { return (const uint*)_image.scanLine(y); }
const uint* bits() const { return (const uint*)_image.bits(); }
int wordsPerLine() const { return (_image.bytesPerLine() + 3)/4; }
const QList<QLine>& sl() { return lines; }
const QList<HLine>& l() { return slines; }
const QList<QRect>& slices() const { return _slices; }
double spatium() const { return _spatium; }
double ratio() const {return _ratio;}
double staffDistance() const;
double systemDistance() const;
void readHeader(Score* score);
void readBarLines();
float searchBarLines(int start_staff, int end_staff);
void identifySystems();
const QList<OmrSystem>& systems() const { return _systems; }
//QList<OmrSystem>& systems() { return _systems; }
OmrSystem* system(int idx) { return &_systems[idx]; }
void write(XmlWriter&) const;
void read(XmlReader&);
bool dot(int x, int y) const;
bool isBlack(int x, int y) const;
};
}
#endif