New repackaging 2.3.2+dfsg3 for src:musescore2 (castling) 2.3.2+dfsg3
authormirabilos <tg@debian.org>
Thu, 18 Apr 2019 12:35:19 +0000 (14:35 +0200)
committermirabilos <mirabilos@evolvis.org>
Thu, 18 Apr 2019 12:35:19 +0000 (14:35 +0200)
29 files changed:
omr/CMakeLists.txt [deleted file]
omr/TODO [deleted file]
omr/image.h [deleted file]
omr/importpdf.cpp [deleted file]
omr/importpdf.h [deleted file]
omr/ocr.cpp [deleted file]
omr/ocr.h [deleted file]
omr/omr.cpp [deleted file]
omr/omr.h [deleted file]
omr/omrpage.cpp [deleted file]
omr/omrpage.h [deleted file]
omr/omrview.cpp [deleted file]
omr/omrview.h [deleted file]
omr/pattern.cpp [deleted file]
omr/pattern.h [deleted file]
omr/pdf.cpp [deleted file]
omr/pdf.h [deleted file]
omr/skew.cpp [deleted file]
omr/utils.cpp [deleted file]
omr/utils.h [deleted file]
rdoc/.gitignore [deleted file]
rdoc/CMakeLists.txt [deleted file]
rdoc/de/doc.html [deleted file]
rdoc/de/doc.qhcp [deleted file]
rdoc/de/doc.qhp [deleted file]
rdoc/en/doc.html [deleted file]
rdoc/en/doc.qhcp [deleted file]
rdoc/en/doc.qhp [deleted file]
rdoc/en/note.html [deleted file]

diff --git a/omr/CMakeLists.txt b/omr/CMakeLists.txt
deleted file mode 100644 (file)
index 88615e5..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-#=============================================================================
-#  MusE
-#  Linux Music Editor
-#  $Id:$
-#
-#  Copyright (C) 2002-2006 by Werner Schweer and others
-#
-#  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.
-#=============================================================================
-
-include (${PROJECT_SOURCE_DIR}/build/gch.cmake)
-
-include_directories(
-      ${PROJECT_SOURCE_DIR}
-      ${PROJECT_BINARY_DIR}
-      )
-
-if (OCR)
-      set (OCR_SRC ocr.cpp)
-endif (OCR)
-
-add_library (
-      omr STATIC
-      ${PROJECT_BINARY_DIR}/all.h
-      ${PCH}
-      omrview.cpp pdf.cpp omrpage.cpp
-      skew.cpp utils.cpp
-      omr.cpp pattern.cpp importpdf.cpp
-      ${OCR_SRC}
-      )
-
-set_target_properties (
-      omr
-      PROPERTIES
-         COMPILE_FLAGS "${PCH_INCLUDE} -g -Wall -Wextra -Winvalid-pch"
-      )
-
-xcode_pch(omr all)
-
-ADD_DEPENDENCIES(omr mops1)
-ADD_DEPENDENCIES(omr mops2)
-
diff --git a/omr/TODO b/omr/TODO
deleted file mode 100644 (file)
index 8f3cfdc..0000000
--- a/omr/TODO
+++ /dev/null
@@ -1,55 +0,0 @@
-
-
-- Qualität messen: Rauschabstand
-      - Erkennungswahrscheinlichkeit: 0 - 1.0
-      - Abstand zwischen "false positive" und nicht erkannten Elementen = Rauschabstand
-
-- Erkennen von Notenlinien:
-      - die horizontale Projektion soll Kanten berücksichtigen
-
-- Zeichenerkennung
-      - Zeichenränder sollen mit einbezogen werden, um den Rauschabstand zu verbessern
-
-- Rekursion
-      - erkannten Notenköpfe korrigieren die Position der Notenlinien
-
-- Notenköpfe:
-      - Notenlinien und Notenhals in Muster einzeichnen:
-            - ergibt 6 Varianten per Kopf:
-                  - zwischen den Notenlinien
-                  - auf den Notenlinien
-                  - Hals nach oben
-                  - Hals nach unten
-                  - Hals durchlaufend (Akkord)
-
-TODO:
-      * Taktstriche erkennen
-      - Systeme erkennen
-
-      System-Preamble erkennen:
-            * Schlüssel erkennen
-            * Taktart erkennen
-            - Tonartvorzeichen erkennen
-            - Vorzeichen erkennen
-            - Notenhälse
-            - Flags
-            - Beams
-
-===========================================
-      * create OmrMeasure
-      * distribute notes into measures
-      * detect timesig
-      - detect clef
-
-      * create notes in score
-        for simple cases
-      * create chords
-
-      panel:
-            - notehead detection threshold
-
-      score gui:
-            - hover with mouse and detect element
-            - show info about element
-
-
diff --git a/omr/image.h b/omr/image.h
deleted file mode 100644 (file)
index 53a7cbd..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-//=============================================================================
-//  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 __IMAGE_H__
-#define __IMAGE_H__
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   Image
-//---------------------------------------------------------
-
-class Image : public QImage {
-   public:
-      };
-
-extern double imageSkew(const QImage& image);
-
-}
-
-#endif
-
diff --git a/omr/importpdf.cpp b/omr/importpdf.cpp
deleted file mode 100644 (file)
index 514b6d2..0000000
+++ /dev/null
@@ -1,288 +0,0 @@
-//=============================================================================
-//  MuseScore
-//  Linux Music Score Editor
-//  $Id: importmidi.cpp 2721 2010-02-15 19:41:28Z wschweer $
-//
-//  Copyright (C) 2002-2011 Werner Schweer and others
-//
-//  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.
-//=============================================================================
-
-#include "importpdf.h"
-#include "libmscore/score.h"
-#include "omr/omr.h"
-#include "libmscore/part.h"
-#include "libmscore/staff.h"
-#include "libmscore/measure.h"
-#include "libmscore/rest.h"
-#include "omr/omrpage.h"
-#include "libmscore/segment.h"
-#include "libmscore/layoutbreak.h"
-#include "libmscore/page.h"
-#include "libmscore/clef.h"
-#include "libmscore/bracket.h"
-#include "libmscore/mscore.h"
-#include "libmscore/chord.h"
-#include "libmscore/note.h"
-#include "libmscore/utils.h"
-#include "libmscore/timesig.h"
-#include "libmscore/keysig.h"
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   OmrState
-//---------------------------------------------------------
-
-class OmrState {
-   public:
-      Score* score = 0;
-      Fraction timesig { 4, 4};
-      int tick = 0;
-
-      void importPdfPage(OmrPage* omrPage);
-      int importPdfSystem(int tick, OmrSystem* omrSystem);
-      void importPdfMeasure(OmrMeasure* m, const OmrSystem* omrSystem);
-      };
-
-//---------------------------------------------------------
-//   importPdfMeasure
-//---------------------------------------------------------
-
-void OmrState::importPdfMeasure(OmrMeasure* m, const OmrSystem* omrSystem)
-      {
-      Measure* measure = new Measure(score);
-      measure->setTick(tick);
-      if (m->timesig()) {
-            timesig = m->timesig()->timesig;
-            score->sigmap()->add(tick, SigEvent(timesig));
-            }
-      measure->setTimesig(timesig);
-      measure->setLen(timesig);
-
-      for (int staffIdx = 0; staffIdx < omrSystem->staves().size(); ++staffIdx) {
-            if (tick == 0) {
-                  const OmrStaff& omrStaff = omrSystem->staves()[staffIdx];
-                  int keySigType = omrStaff.keySig().type;
-                  KeySig* ks     = new KeySig(score);
-                  ks->setSig(keySigType, keySigType);
-                  ks->setTrack(staffIdx * VOICES);
-                  Segment* s = measure->getSegment(Segment::SegKeySig, 0);
-                  s->add(ks);
-                  score->staff(staffIdx)->setKey(0, keySigType);
-                  }
-
-            if (m->timesig()) {
-                  TimeSig* ts = new TimeSig(score);
-                  Segment* s = measure->getSegment(Segment::SegTimeSig, tick);
-                  ts->setSig(timesig);
-                  ts->setTrack(staffIdx * VOICES);
-                  s->add(ts);
-                  }
-            Fraction nl;
-            QList<OmrChord>& chords = m->chords()[staffIdx];
-            if (timesig == Fraction(3,8)) {
-                  if (chords.size() == 1) {
-                        chords[0].duration = TDuration(timesig);
-                        }
-                  else if (chords.size() == 3) {
-                        int i = 0;
-                        for (;i < 3; ++i) {
-                              if (chords[i].duration.fraction() != Fraction(1,4))
-                                    break;
-                              }
-                        if (i == 3) {
-                              for (i = 0;i < 3; ++i) {
-                                    chords[i].duration = TDuration(Fraction(1, 8));
-                                    }
-                              }
-                        }
-                  }
-            foreach(const OmrChord& omrChord, chords) {
-                  nl += omrChord.duration.fraction();
-                  }
-            bool notesOk = nl == timesig;
-
-            if (notesOk) {
-                  int ltick = 0;
-                  foreach(const OmrChord& omrChord, chords) {
-                        Chord* chord = new Chord(score);
-                        chord->setDurationType(omrChord.duration);
-                        chord->setDuration(omrChord.duration.fraction());
-                        chord->setTrack(staffIdx * VOICES);
-                        Segment* s = measure->getSegment(Segment::SegChordRest, tick + ltick);
-                        s->add(chord);
-                        int keyType = score->staff(staffIdx)->key(tick + ltick).accidentalType();
-
-                        foreach (OmrNote* omrNote, omrChord.notes) {
-                              Note* note = new Note(score);
-                              ClefType clef = score->staff(staffIdx)->initialClef()._concertClef;
-                              int pitch = line2pitch(omrNote->line, clef, keyType);
-                              note->setPitch(pitch);
-                              note->setTpcFromPitch();
-                              chord->add(note);
-                              }
-                        ltick += omrChord.duration.ticks();
-                        }
-                  }
-            else {
-                  TDuration d(TDuration::V_MEASURE);
-                  Segment* s = measure->getSegment(Segment::SegChordRest, measure->tick());
-                  Rest* rest = new Rest(score, d);
-                  rest->setDuration(timesig);
-                  rest->setTrack(staffIdx * VOICES);
-                  s->add(rest);
-                  }
-            }
-
-      score->measures()->add(measure);
-      tick += measure->timesig().ticks();
-      }
-
-//---------------------------------------------------------
-//   importPdfSystem
-//---------------------------------------------------------
-
-int OmrState::importPdfSystem(int tick, OmrSystem* omrSystem)
-      {
-      for (int i = 0; i < omrSystem->measures().size(); ++i) {
-            OmrMeasure* m = &omrSystem->measures()[i];
-            importPdfMeasure(m, omrSystem);
-            }
-      LayoutBreak* b = new LayoutBreak(score);
-      b->setLayoutBreakType(LayoutBreakType::LAYOUT_BREAK_LINE);
-      score->lastMeasure()->add(b);
-      return tick;
-      }
-
-//---------------------------------------------------------
-//   importPdfPage
-//---------------------------------------------------------
-
-void OmrState::importPdfPage(OmrPage* omrPage)
-      {
-      TDuration d(TDuration::V_MEASURE);
-      int tick         = 0;
-
-      int nsystems = omrPage->systems().size();
-      int n = nsystems == 0 ? 1 : nsystems;
-      for (int k = 0; k < n; ++k) {
-            int numMeasures = 1;
-            if (k < nsystems) {
-                  tick = importPdfSystem(tick, omrPage->system(k));
-                  }
-            else {
-                  Measure* measure;
-                  for (int i = 0; i < numMeasures; ++i) {
-                        measure = new Measure(score);
-                        measure->setTick(tick);
-
-                     Rest* rest = new Rest(score, d);
-                        rest->setDuration(Fraction(4,4));
-                        rest->setTrack(0);
-                        Segment* s = measure->getSegment(Segment::SegChordRest, tick);
-                   s->add(rest);
-                     rest = new Rest(score, d);
-                        rest->setDuration(Fraction(4,4));
-                        rest->setTrack(4);
-                   s->add(rest);
-                        score->measures()->add(measure);
-                        tick += MScore::division * 4;
-                        }
-                  if (k < (nsystems-1)) {
-                        LayoutBreak* b = new LayoutBreak(score);
-                        b->setLayoutBreakType(LAYOUT_BREAK_LINE);
-                        measure->add(b);
-                        }
-                  }
-            }
-      Measure* measure = score->lastMeasure();
-      if (measure) {
-            LayoutBreak* b = new LayoutBreak(score);
-            b->setLayoutBreakType(LAYOUT_BREAK_PAGE);
-            measure->add(b);
-            }
-      }
-
-//---------------------------------------------------------
-//   importPdf
-//---------------------------------------------------------
-
-Score::FileError importPdf(Score* score, const QString& path)
-      {
-      Omr* omr = new Omr(path, score);
-      if (!omr->readPdf()) {
-            delete omr;
-            return Score::FILE_BAD_FORMAT;
-            }
-
-      score->setOmr(omr);
-      qreal sp = omr->spatiumMM();
-      if (sp == 0.0)
-            sp = 1.5;
-      score->setSpatium(sp * MScore::DPMM);
-      score->style()->set(ST_lastSystemFillLimit, 0.0);
-      score->style()->set(ST_staffLowerBorder, 0.0);
-      score->style()->set(ST_measureSpacing, 1.0);
-
-      PageFormat pF;
-      pF.copy(*score->pageFormat());
-      pF.setEvenLeftMargin(5.0 * MScore::DPMM / MScore::DPI);
-      pF.setEvenTopMargin(0);
-      pF.setEvenBottomMargin(0);
-      pF.setOddLeftMargin(5.0 * MScore::DPMM / MScore::DPI);
-      pF.setOddTopMargin(0);
-      pF.setOddBottomMargin(0);
-      score->setPageFormat(pF);
-
-      score->style()->set(ST_minSystemDistance,   Spatium(omr->systemDistance()));
-      score->style()->set(ST_maxSystemDistance,   Spatium(omr->systemDistance()));
-      score->style()->set(ST_akkoladeDistance,    Spatium(omr->staffDistance()));
-
-      Part* part   = new Part(score);
-      Staff* staff = new Staff(score, part, 0);
-      part->staves()->push_back(staff);
-      score->staves().insert(0, staff);
-      staff = new Staff(score, part, 1);
-      part->staves()->push_back(staff);
-      score->staves().insert(1, staff);
-      part->staves()->front()->setBarLineSpan(part->nstaves());
-      score->insertPart(part, 0);
-
-      //---set initial clefs
-
-      OmrPage* omrPage = omr->pages().front();
-      int staves = score->nstaves();
-      for (int i = 0; i < staves; ++i) {
-            Staff* staff = score->staff(i);
-            const OmrStaff& omrStaff = omrPage->systems().front().staves()[i];
-            staff->setInitialClef(omrStaff.clef().type);
-            }
-
-      OmrState state;
-      state.score = score;
-      foreach(OmrPage* omrPage, omr->pages())
-            state.importPdfPage(omrPage);
-
-      //---create bracket
-
-      score->staff(0)->setBracket(0, BRACKET_BRACE);
-      score->staff(0)->setBracketSpan(0, 2);
-
-      score->setShowOmr(true);
-      omr->page(0)->readHeader(score);
-      score->rebuildMidiMapping();
-      return Score::FILE_NO_ERROR;
-      }
-}
-
diff --git a/omr/importpdf.h b/omr/importpdf.h
deleted file mode 100644 (file)
index 7d8a5bf..0000000
+++ /dev/null
@@ -1,32 +0,0 @@
-//=============================================================================
-//  MuseScore
-//  Linux Music Score Editor
-//  $Id: importmidi.cpp 2721 2010-02-15 19:41:28Z wschweer $
-//
-//  Copyright (C) 2012 Werner Schweer and others
-//
-//  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 __IMPORT_PDF_H__
-#define __IMPORT_PDF_H__
-
-#include "libmscore/score.h"
-
-namespace Ms {
-
-      extern Score::FileError importPdf(Score*, const QString&);
-      }
-
-#endif
-
diff --git a/omr/ocr.cpp b/omr/ocr.cpp
deleted file mode 100644 (file)
index 6c869f4..0000000
+++ /dev/null
@@ -1,80 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "ocr.h"
-
-#include <tesseract/baseapi.h>
-#include <locale.h>
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   Ocr
-//---------------------------------------------------------
-
-Ocr::Ocr()
-      {
-      tess = 0;
-      }
-
-//---------------------------------------------------------
-//   init
-//---------------------------------------------------------
-
-void Ocr::init()
-      {
-      if (tess == 0)
-            tess = new tesseract::TessBaseAPI;
-      tess->Init("/usr/local/share/tessdata", 0, 0, 0, false);
-      }
-
-//---------------------------------------------------------
-//   readLine
-//---------------------------------------------------------
-
-QString Ocr::readLine(const OcrImage& img)
-      {
-      int w = img.r.width();
-      int h = img.r.height();
-
-      int bw = (w + 7) / 8;
-      uchar* d = new uchar[bw * h];
-      memset(d, 0, bw * h);
-      uchar* p = d;
-      int yo = img.r.y();
-      int xo = img.r.x();
-
-      for (int y = 0; y < h; ++y) {
-            for (int x = 0; x < bw; ++x) {
-                  int mask = 0x80;
-                  uchar dst = 0;
-                  for (int xx = 0; xx < 8; ++xx) {
-                        if (img.dot(x * 8 + xo + xx, y + yo))
-                              dst |= mask;
-                        mask >>= 1;
-                        }
-                  *p++ = ~dst;
-                  }
-            }
-      char* txt = tess->TesseractRect(d, 0, bw, 0, 0, w, h);
-      return QString(txt);
-      }
-}
-
diff --git a/omr/ocr.h b/omr/ocr.h
deleted file mode 100644 (file)
index cc4350e..0000000
--- a/omr/ocr.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//=============================================================================
-//  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 __OCR_H__
-#define __OCR_H__
-
-
-namespace tesseract {
-      class TessBaseAPI;
-      };
-
-namespace Ms {
-
-
-//---------------------------------------------------------
-//   OcrImage
-//---------------------------------------------------------
-
-struct OcrImage {
-      uint* image;
-      QRect r;
-      int stride; // uint* stride
-
-      OcrImage() {}
-      OcrImage(const uchar* p, const QRect& _r, int _s) : image((uint*)p), r(_r), stride(_s) {}
-      OcrImage crop() const;
-      bool dot(int x, int y) const {
-            return (*(image + (y * stride) + (x / 32))) & (0x1 << (x % 32));
-            }
-      };
-
-//---------------------------------------------------------
-//   Ocr
-//---------------------------------------------------------
-
-class Ocr {
-      tesseract::TessBaseAPI* tess;
-
-   public:
-      Ocr();
-      void init();
-      QString readLine(const OcrImage&);
-      };
-}
-
-#endif
-
diff --git a/omr/omr.cpp b/omr/omr.cpp
deleted file mode 100644 (file)
index 92b4012..0000000
+++ /dev/null
@@ -1,236 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "omr.h"
-#include "omrview.h"
-#include "libmscore/xml.h"
-#include "libmscore/sym.h"
-#include "omrpage.h"
-#include "pdf.h"
-#ifdef OCR
-#include "ocr.h"
-#endif
-#include "utils.h"
-#include "pattern.h"
-
-namespace Ms {
-
-#ifdef OMR
-
-class ScoreView;
-
-Pattern* Omr::quartheadPattern;
-Pattern* Omr::halfheadPattern;
-Pattern* Omr::sharpPattern;
-Pattern* Omr::flatPattern;
-Pattern* Omr::naturalPattern;
-Pattern* Omr::trebleclefPattern;
-Pattern* Omr::bassclefPattern;
-
-//---------------------------------------------------------
-//   Omr
-//---------------------------------------------------------
-
-Omr::Omr(Score* s)
-      {
-      _score = s;
-#ifdef OCR
-      _ocr = 0;
-#endif
-      initUtils();
-      }
-
-Omr::Omr(const QString& p, Score* s)
-      {
-      _score        = s;
-      _path         = p;
-      _ocr          = 0;
-      initUtils();
-      }
-
-//---------------------------------------------------------
-//   newOmrView
-//---------------------------------------------------------
-
-OmrView* Omr::newOmrView(ScoreView* sv)
-      {
-      OmrView* ov = new OmrView(sv);
-      ov->setOmr(this);
-      return ov;
-      }
-
-//---------------------------------------------------------
-//   write
-//---------------------------------------------------------
-
-void Omr::write(Xml& xml) const
-      {
-      xml.stag("Omr");
-      xml.tag("path", _path);
-      xml.tag("spatium", _spatium);
-      xml.tag("dpmm", _dpmm);
-      foreach(OmrPage* page, _pages) {
-            page->write(xml);
-            }
-      xml.etag();
-      }
-
-//---------------------------------------------------------
-//   read
-//---------------------------------------------------------
-
-void Omr::read(XmlReader& e)
-      {
-      _doc = 0;
-#ifdef OCR
-      if (_ocr == 0)
-            _ocr = new Ocr;
-      _ocr->init();
-#endif
-      while (e.readNextStartElement()) {
-            const QStringRef& tag(e.name());
-
-            if (tag == "path")
-                  _path = e.readElementText();
-            else if (tag == "OmrPage") {
-                  OmrPage* page = new OmrPage(this);
-                  page->read(e);
-                  _pages.append(page);
-                  }
-            else if (tag == "spatium")
-                  _spatium = e.readDouble();
-            else if (tag == "dpmm")
-                  _dpmm = e.readDouble();
-            else
-                  e.unknown();
-            }
-      }
-
-//---------------------------------------------------------
-//   pagesInDocument
-//---------------------------------------------------------
-
-int Omr::pagesInDocument() const
-      {
-      return _doc ? _doc->numPages() : 0;
-      }
-
-//---------------------------------------------------------
-//   readPdf
-//    return true on success
-//---------------------------------------------------------
-
-bool Omr::readPdf()
-      {
-#ifdef OCR
-      if (_ocr == 0)
-            _ocr = new Ocr;
-      _ocr->init();
-#endif
-
-      _doc = new Pdf();
-      if (!_doc->open(_path)) {
-            delete _doc;
-            _doc = 0;
-            return false;
-            }
-
-      int n = _doc->numPages();
-      printf("readPdf: %d pages\n", n);
-      for (int i = 0; i < n; ++i) {
-            OmrPage* page = new OmrPage(this);
-            QImage image = _doc->page(i);
-            page->setImage(image);
-            _pages.append(page);
-            }
-      process();
-      return true;
-      }
-
-//---------------------------------------------------------
-//   process
-//---------------------------------------------------------
-
-void Omr::process()
-      {
-      double sp = 0;
-      double w  = 0;
-
-      int pages = 0;
-      int n = _pages.size();
-      for (int i = 0; i < n; ++i) {
-            _pages[i]->read();
-            if (_pages[i]->systems().size() > 0) {
-                  sp += _pages[i]->spatium();
-                  ++pages;
-                  }
-            w  += _pages[i]->width();
-            }
-      _spatium = sp / pages;
-      w       /= n;
-      _dpmm    = w / 210.0;            // PaperSize A4
-
-// printf("*** spatium: %f mm  dpmm: %f\n", spatiumMM(), _dpmm);
-
-      quartheadPattern  = new Pattern(quartheadSym, &symbols[0][quartheadSym], _spatium);
-      halfheadPattern   = new Pattern(halfheadSym, &symbols[0][halfheadSym], _spatium);
-      sharpPattern      = new Pattern(sharpSym, &symbols[0][sharpSym], _spatium);
-      flatPattern       = new Pattern(flatSym, &symbols[0][flatSym], _spatium);
-      naturalPattern    = new Pattern(naturalSym, &symbols[0][naturalSym], _spatium);
-      trebleclefPattern = new Pattern(trebleclefSym, &symbols[0][trebleclefSym],  _spatium);
-      bassclefPattern   = new Pattern(bassclefSym, &symbols[0][bassclefSym],  _spatium);
-
-      for (int i = 0; i < n; ++i) {
-            OmrPage* page = _pages[i];
-            if (!page->systems().isEmpty()) {
-                  page->readBarLines(i);
-                  }
-            }
-      }
-
-//---------------------------------------------------------
-//   spatiumMM
-//---------------------------------------------------------
-
-double Omr::spatiumMM() const
-      {
-      return _spatium / _dpmm;
-      }
-
-//---------------------------------------------------------
-//   staffDistance
-//---------------------------------------------------------
-
-double Omr::staffDistance() const
-      {
-      return _pages[0]->staffDistance();
-      }
-
-//---------------------------------------------------------
-//   systemDistance
-//---------------------------------------------------------
-
-double Omr::systemDistance() const
-      {
-      return _pages[0]->systemDistance();
-      }
-#endif
-}
-
diff --git a/omr/omr.h b/omr/omr.h
deleted file mode 100644 (file)
index 0c93ee7..0000000
--- a/omr/omr.h
+++ /dev/null
@@ -1,130 +0,0 @@
-//=============================================================================
-//  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 __OMR_H__
-#define __OMR_H__
-
-#include "config.h"
-
-namespace Ms {
-
-class OmrView;
-class Xml;
-class Pdf;
-class OmrPage;
-class Ocr;
-class Score;
-class ScoreView;
-class XmlReader;
-class Pattern;
-
-#ifdef OMR
-
-//---------------------------------------------------------
-//   Omr
-//---------------------------------------------------------
-
-class Omr {
-      QString _path;
-      double _spatium;
-      double _dpmm;
-      Pdf* _doc;
-      QList<OmrPage*> _pages;
-      Ocr* _ocr;
-      Score* _score;
-
-      static void initUtils();
-
-      void process1(int page);
-
-   public:
-      Omr(Score*);
-      Omr(const QString& path, Score*);
-
-      static char bitsSetTable[256];
-
-      bool readPdf();
-      int pagesInDocument() const;
-      int numPages() const                 { return _pages.size();          }
-      OmrPage* page(int idx)               { return _pages[idx];            }
-      OmrView* newOmrView(ScoreView*);
-      const QList<OmrPage*>& pages() const { return _pages; }
-#ifdef OCR
-      Ocr* ocr() const                     { return _ocr; }
-#endif
-      void write(Xml&) const;
-      void read(XmlReader&);
-
-      double spatiumMM() const;           // spatium in millimeter
-      double spatium() const               { return _spatium;   }
-      void setSpatium(double val)          { _spatium = val;    }
-      double dpmm() const                  { return _dpmm;      }
-      void setDpmm(double val)             { _dpmm = val;       }
-      double staffDistance() const;
-      double systemDistance() const;
-      Score* score() const                 { return _score;     }
-      const QString& path() const          { return _path;      }
-      void process();
-
-      static Pattern* quartheadPattern;
-      static Pattern* halfheadPattern;
-      static Pattern* sharpPattern;
-      static Pattern* flatPattern;
-      static Pattern* naturalPattern;
-      static Pattern* trebleclefPattern;
-      static Pattern* bassclefPattern;
-      };
-
-#else
-//---------------------------------------------------------
-//   Omr
-//---------------------------------------------------------
-
-class Omr {
-      QString _path;
-      QList<OmrPage*> _pages;
-
-   public:
-      Omr(Score*)                          {}
-      Omr(const QString&, Score*)          {}
-      bool readPdf()                       { return false; }
-      int pagesInDocument() const          { return 0; }
-      int numPages() const                 { return 0; }
-      OmrPage* page(int)                   { return 0; }
-      const QList<OmrPage*>& pages() const { return _pages; }
-      OmrView* newOmrView(ScoreView*)      { return 0; }
-#ifdef OCR
-      Ocr* ocr() const                     { return 0; }
-#endif
-      void write(Xml&) const               {}
-      void read(XmlReader&)                {}
-
-      double spatiumMM() const             { return 0; }
-      double spatium() const               { return 0; }
-      double dpmm() const                  { return 0; }
-      double staffDistance() const         { return 0; }
-      double systemDistance() const        { return 0; }
-      Score* score() const                 { return 0; }
-      const QString& path() const          { return _path; }
-      };
-
-#endif
-}
-#endif
diff --git a/omr/omrpage.cpp b/omr/omrpage.cpp
deleted file mode 100644 (file)
index c74d44d..0000000
+++ /dev/null
@@ -1,1177 +0,0 @@
-//=============================================================================
-//  MusE Reader
-//  Music Score Reader
-//  $Id$
-//
-//  Copyright (C) 2010-2011 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.
-//=============================================================================
-
-#include "omrpage.h"
-#include "image.h"
-#include "utils.h"
-#include "omr.h"
-#ifdef OCR
-#include "ocr.h"
-#endif
-#include "libmscore/score.h"
-#include "libmscore/text.h"
-#include "libmscore/measurebase.h"
-#include "libmscore/box.h"
-#include "libmscore/sym.h"
-#include "pattern.h"
-
-namespace Ms {
-
-static const double noteTH = 0.8;
-static const double timesigTH = 0.7;
-static const double clefTH = 0.7;
-static const double keysigTH = 0.8;
-
-struct Hv {
-      int x;
-      int val;
-      Hv(int a, int b) : x(a), val(b) {}
-      bool operator< (const Hv& a) const { return a.val < val; }
-      };
-
-struct Peak {
-      int x;
-      double val;
-      int sym;
-
-      bool operator<(const Peak& p) const { return p.val < val; }
-      Peak(int _x, double _val) : x(_x), val(_val) {}
-      Peak(int _x, double _val, int s) : x(_x), val(_val), sym(s) {}
-      };
-
-//---------------------------------------------------------
-//   Lv
-//    line + value
-//---------------------------------------------------------
-
-struct Lv {
-      int line;
-      double val;
-      Lv(int a, double b) : line(a), val(b) {}
-      bool operator< (const Lv& a) const {
-            return a.val < val;
-            }
-      };
-
-//---------------------------------------------------------
-//   OmrPage
-//---------------------------------------------------------
-
-OmrPage::OmrPage(Omr* parent)
-      {
-      _omr = parent;
-      cropL = cropR = cropT = cropB = 0;
-      }
-
-//---------------------------------------------------------
-//   dot
-//---------------------------------------------------------
-
-bool OmrPage::dot(int x, int y) const
-      {
-      const uint* p = scanLine(y) + (x / 32);
-      return (*p) & (0x1 << (x % 32));
-      }
-
-//---------------------------------------------------------
-//   read
-//---------------------------------------------------------
-
-void OmrPage::read()
-      {
-      crop();
-      slice();
-      deSkew();
-      crop();
-      slice();
-      getStaffLines();
-
-      //--------------------------------------------------
-      //    create systems
-      //--------------------------------------------------
-
-      int numStaves    = staves.size();
-      int stavesSystem = 2;
-      int systems      = numStaves / stavesSystem;
-
-      for (int system = 0; system < systems; ++system) {
-            OmrSystem omrSystem(this);
-            for (int i = 0; i < stavesSystem; ++i) {
-                  omrSystem.staves().append(staves[system * stavesSystem + i]);
-                  }
-            _systems.append(omrSystem);
-            }
-
-      if (_systems.isEmpty())
-            return;
-      }
-
-//---------------------------------------------------------
-//   readBarLines
-//---------------------------------------------------------
-
-void OmrPage::readBarLines(int pageNo)
-      {
-      QFuture<void> bl = QtConcurrent::map(_systems, &OmrSystem::searchBarLines);
-      bl.waitForFinished();
-
-      int numStaves    = staves.size();
-      int stavesSystem = 2;
-      int systems = numStaves / stavesSystem;
-
-      for (int i = 0; i < systems; ++i) {
-            OmrSystem* system = &_systems[i];
-            int n = system->barLines.size();
-            for (int k = 0; k < n-1; ++k) {
-                  const QLine& l1 = system->barLines[k];
-                  const QLine& l2 = system->barLines[k+1];
-                  OmrMeasure m(l1.x1(), l2.x1());
-                  for (int k = 0; k < system->staves().size(); ++k) {
-                        OmrStaff& staff = system->staves()[k];
-                        QList<OmrChord> chords;
-                        int nx   = 0;
-                        int nsym = -1;
-                        OmrChord chord;
-                        foreach(OmrNote* n, staff.notes()) {
-                              int x = n->x();
-                              if (x >= m.x2())
-                                    break;
-                              if (x >= m.x1() && x < m.x2()) {
-                                    if (qAbs(x - nx) > int(_spatium/2) || (nsym != n->sym)) {
-                                          if (!chord.notes.isEmpty()) {
-                                                int sym = chord.notes.front()->sym;
-                                                if (sym == quartheadSym)
-                                                      chord.duration.setType(TDuration::V_QUARTER);
-                                                else if (sym == halfheadSym)
-                                                      chord.duration.setType(TDuration::V_HALF);
-                                                chords.append(chord);
-                                                chord.notes.clear();
-                                                }
-                                          }
-                                    nx   = x;
-                                    nsym = n->sym;
-                                    chord.notes.append(n);
-                                    }
-                              }
-                        if (!chord.notes.isEmpty()) {
-                              int sym = chord.notes.front()->sym;
-                              if (sym == quartheadSym)
-                                    chord.duration.setType(TDuration::V_QUARTER);
-                              else if (sym == halfheadSym)
-                                    chord.duration.setType(TDuration::V_HALF);
-                              chords.append(chord);
-                              }
-                        m.chords().append(chords);
-                        }
-                  system->measures().append(m);
-                  }
-            }
-
-      //--------------------------------------------------
-      //    search clef/keysig
-      //--------------------------------------------------
-
-      if (pageNo == 0) {
-            OmrSystem* s = &_systems[0];
-            for (int i = 0; i < s->staves().size(); ++i) {
-                  OmrStaff* staff = &s->staves()[i];
-                  OmrClef clef = searchClef(s, staff);
-                  staff->setClef(clef);
-
-                  searchKeySig(s, staff);
-                  }
-
-
-            //--------------------------------------------------
-            //    search time signature
-            //--------------------------------------------------
-
-            if (!s->staves().isEmpty()) {
-                  OmrTimesig* ts = searchTimeSig(s);
-                  s->measures()[0].setTimesig(ts);
-                  }
-            }
-      }
-
-//---------------------------------------------------------
-//   searchClef
-//---------------------------------------------------------
-
-OmrClef OmrPage::searchClef(OmrSystem* system, OmrStaff* staff)
-      {
-      std::vector<Pattern*> pl = {
-            Omr::trebleclefPattern,
-            Omr::bassclefPattern
-            };
-      const OmrMeasure& m = system->measures().front();
-printf("search clef %d   %d-%d\n", staff->y(), m.x1(), m.x2());
-
-      int x1 = m.x1() + 2;
-      int x2 = x1 + (m.x2() - x1)/2;
-      OmrPattern p = searchPattern(pl, staff->y(), x1, x2);
-
-      OmrClef clef(p);
-      if (p.sym == trebleclefSym)
-            clef.type = CLEF_G;
-      else if (p.sym == bassclefSym)
-            clef.type = CLEF_F;
-      else
-            clef.type = CLEF_G;
-      return clef;
-      }
-
-//---------------------------------------------------------
-//   searchPattern
-//---------------------------------------------------------
-
-OmrPattern OmrPage::searchPattern(const std::vector<Pattern*>& pl, int y, int x1, int x2)
-      {
-      OmrPattern p;
-      p.sym  = -1;
-      p.prob = 0.0;
-      for (Pattern* pattern : pl) {
-            double val = 0.0;
-            int xx = 0;
-            int hw = pattern->w();
-
-            for (int x = x1; x < (x2 - hw); ++x) {
-                  double val1 = pattern->match(&image(), x - pattern->base().x(), y - pattern->base().y());
-                  if (val1 > val) {
-                        val = val1;
-                        xx  = x;
-                        }
-                  }
-
-            if (val > p.prob) {
-                  p.setRect(xx, y, pattern->w(), pattern->h());
-                  p.sym  = pattern->id();
-                  p.prob = val;
-                  }
-            printf("Pattern found %d %f %d\n", int(pattern->id()), val, xx);
-            }
-      return p;
-      }
-
-//---------------------------------------------------------
-//   searchTimeSig
-//---------------------------------------------------------
-
-OmrTimesig* OmrPage::searchTimeSig(OmrSystem* system)
-      {
-      Pattern pl[10];
-      pl[0] = Pattern(zeroSym,  &symbols[0][zeroSym],  _spatium);
-      pl[1] = Pattern(oneSym,   &symbols[0][oneSym],   _spatium);
-      pl[2] = Pattern(twoSym,   &symbols[0][twoSym],   _spatium);
-      pl[3] = Pattern(threeSym, &symbols[0][threeSym], _spatium);
-      pl[4] = Pattern(fourSym,  &symbols[0][fourSym],  _spatium);
-      pl[5] = Pattern(fiveSym,  &symbols[0][fiveSym],  _spatium);
-      pl[6] = Pattern(sixSym,   &symbols[0][sixSym],   _spatium);
-      pl[7] = Pattern(sevenSym, &symbols[0][sevenSym], _spatium);
-      pl[8] = Pattern(eightSym, &symbols[0][eightSym], _spatium);
-      pl[9] = Pattern(nineSym,  &symbols[0][nineSym],  _spatium);
-
-      int z = -1;
-      int n = -1;
-      double zval = 0;
-      double nval = 0;
-      QRect rz, rn;
-
-      int y         = system->staves().front().y();
-      OmrMeasure* m = &system->measures().front();
-      int x1        = m->x1();
-
-      for (int i = 0; i < 10; ++i) {
-            Pattern* pattern = &pl[i];
-            double val = 0.0;
-            int hh     = pattern->h();
-            int hw     = pattern->w();
-            int x2     = m->x2() - hw;
-            QRect r;
-
-            for (int x = x1; x < x2; ++x) {
-                  double val1 = pattern->match(&image(), x, y);
-                  if (val1 > val) {
-                        val = val1;
-                        r = QRect(x, y, hw, hh);
-                        }
-                  }
-
-            if (val > timesigTH && val > zval) {
-                  z = i;
-                  zval = val;
-                  rz   = r;
-                  }
-//            printf("   found %d %f\n", i, val);
-            }
-
-      if (z < 0)
-            return 0;
-      y = system->staves().front().y() + lrint(_spatium * 2);
-
-      x1 = rz.x();
-      int x2 = x1 + 1;
-      OmrTimesig* ts = 0;
-      for (int i = 0; i < 10; ++i) {
-            Pattern* pattern = &pl[i];
-            double val = 0.0;
-            int hh     = pattern->h();
-            int hw     = pattern->w();
-            QRect r;
-
-            for (int x = x1; x < x2; ++x) {
-                  double val1 = pattern->match(&image(), x, y);
-                  if (val1 > val) {
-                        val = val1;
-                        r   = QRect(x, y, hw, hh);
-                        }
-                  }
-
-            if (val > timesigTH && val > nval) {
-                  n = i;
-                  nval = val;
-                  rn   = r;
-                  }
-//            printf("   found %d %f\n", i, val);
-            }
-      if (n > 0) {
-            ts = new OmrTimesig(rz | rn);
-            ts->timesig = Fraction(z, n);
-            printf("timesig  %d/%d\n", z, n);
-            }
-      return ts;
-      }
-
-//---------------------------------------------------------
-//   searchKeySig
-//---------------------------------------------------------
-
-void OmrPage::searchKeySig(OmrSystem* system, OmrStaff* staff)
-      {
-      Pattern* pl[2];
-      pl[0] = Omr::sharpPattern;
-      pl[1] = Omr::flatPattern;
-
-      double zval = 0;
-
-      int y         = system->staves().front().y();
-      OmrMeasure* m = &system->measures().front();
-      int x1        = m->x1();
-
-      for (int i = 0; i < 2; ++i) {
-            Pattern* pattern = pl[i];
-            double val = 0.0;
-            int hh     = pattern->h();
-            int hw     = pattern->w();
-            int x2     = m->x2() - hw;
-            QRect r;
-
-            for (int x = x1; x < x2; ++x) {
-                  double val1 = pattern->match(&image(), x, y - hh/2);
-                  if (val1 > val) {
-                        val = val1;
-                        r = QRect(x, y, hw, hh);
-                        }
-                  }
-
-            if (val > keysigTH && val > zval) {
-                  zval = val;
-                  OmrKeySig key(r);
-                  key.type = i == 0 ? 1 : -1;
-                  staff->setKeySig(key);
-                  }
-            printf(" key found %d %f\n", i, val);
-            }
-      }
-
-//---------------------------------------------------------
-//   maxP
-//---------------------------------------------------------
-
-int maxP(int* projection, int x1, int x2)
-      {
-      int xx = x1;
-      int max = 0;
-      for (int x = x1; x < x2; ++x) {
-            if (projection[x] > max) {
-                  max = projection[x];
-                  xx  = x;
-                  }
-            }
-      return xx;
-      }
-
-//---------------------------------------------------------
-//   searchBarLines
-//---------------------------------------------------------
-
-void OmrSystem::searchBarLines()
-      {
-      OmrStaff& r1 = _staves[0];
-      OmrStaff& r2 = _staves[1];
-
-      int x1  = r1.x();
-      int x2  = x1 + r1.width();
-      int y1  = r1.y();
-      int y2  = r2.y() + r2.height();
-      int h   = y2 - y1 + 1;
-      int th  = h * 4 / 6;     // threshold
-
-      int vpw = x2-x1;
-      int vp[vpw];
-      memset(vp, 0, sizeof(int) * vpw);
-
-      //
-      // compute vertical projections
-      //
-
-      for (int x = x1; x < x2; ++x) {
-            int dots = 0;
-            for (int y = y1; y < y2; ++y) {
-                  if (_page->dot(x, y))
-                        ++dots;
-                  }
-            vp[x - x1] = dots;
-            }
-
-      bool firstBarLine = true;
-      for (int x = 1; x < vpw; ++x) {
-            if (vp[x-1] < vp[x])
-                  continue;
-            if (vp[x] < th)
-                  continue;
-//            if (vp[x-1] > vp[x])
-                  {
-                  barLines.append(QLine(x + x1, y1, x + x1, y2));
-                  int xx = x + x1;
-                  if (firstBarLine) {
-                        firstBarLine = false;
-                        _staves[0].setX(xx);
-                        _staves[1].setX(xx);
-                        }
-                  else {
-                        _staves[0].setWidth(xx - _staves[0].x());
-                        _staves[1].setWidth(xx - _staves[1].x());
-                        }
-                  }
-            }
-
-      searchNotes();
-
-      //
-      // remove false positive barlines:
-      //    - two barlines too narrow (repeat-/end-barlines
-      //      are detected as two barlines
-      //    - barlines which are really note stems
-      //
-      QList<QLine> nbl;
-      double x = -10000.0;
-      double spatium = _page->spatium();
-      int nbar = 0;
-//      int i = 0;
-      int n = barLines.size();
-      for (int i = 0; i < n; ++i) {
-            const QLine& l = barLines[i];
-            int nx = l.x1();
-            if ((nx - x) > spatium) {
-                  //
-                  // check for start repeat:
-                  //
-                  if ((nbar == 1)
-                     && ((nx-x)/spatium < 8.0)   // at begin of system?
-//                     && (i < (n-1))
-//                     && ((barLines[i+1].x1() - x) < spatium)    // double bar line?
-                                                 // missing: check for noteheads
-                                                 // up to here
-                     ) {
-                        x = nx;
-                        continue;
-                        }
-                  nbl.append(l);
-                  x = nx;
-                  ++nbar;
-                  }
-            }
-      barLines = nbl;
-      }
-
-//---------------------------------------------------------
-//   noteCompare
-//---------------------------------------------------------
-
-static bool noteCompare(OmrNote* n1, OmrNote* n2)
-      {
-      return n1->x() < n2->x();
-      }
-
-static bool intersectFuzz(const QRect& a, const QRect& b, int fuzz)
-      {
-      int xfuzz = fuzz;
-      int yfuzz = fuzz;
-      if (a.x() > b.x())
-            xfuzz = -xfuzz;
-      if (a.y() > b.y())
-            yfuzz = -yfuzz;
-
-      return (a.intersects(b.translated(xfuzz, yfuzz)));
-      }
-
-//---------------------------------------------------------
-//   searchNotes
-//---------------------------------------------------------
-
-void OmrSystem::searchNotes()
-      {
-      for (int i = 0; i < _staves.size(); ++i) {
-            OmrStaff* r = &_staves[i];
-            int x1 = r->x();
-            int x2 = x1 + r->width();
-
-            //
-            // search notes on a range of vertical line position
-            //
-            for (int line = -5; line < 14; ++line)
-                  searchNotes(&r->notes(), x1, x2, r->y(), line);
-
-            //
-            // detect collisions
-            //
-            int fuzz = int(_page->spatium()) / 2;
-            foreach(OmrNote* n, r->notes()) {
-                  foreach(OmrNote* m, r->notes()) {
-                        if (m == n)
-                              continue;
-                        if (intersectFuzz(*m, *n, fuzz)) {
-                              if (m->prob > n->prob)
-                                    r->notes().removeOne(n);
-                              else
-                                    r->notes().removeOne(m);
-                              }
-                        }
-                  }
-            qSort(r->notes().begin(), r->notes().end(), noteCompare);
-            }
-      }
-
-//---------------------------------------------------------
-//   addText
-//---------------------------------------------------------
-
-#ifdef OCR
-static void addText(Score* score, int subtype, const QString& s)
-      {
-#if 0 //TODO-1
-      MeasureBase* measure = score->first();
-      if (measure == 0 || measure->type() != Element::VBOX) {
-            measure = new VBox(score);
-            measure->setNext(score->first());
-            measure->setTick(0);
-       score->add(measure);
-            }
-      Text* text = new Text(score);
-      switch(subtype) {
-            case TEXT_TITLE:    text->setTextStyle(TEXT_STYLE_TITLE);    break;
-            case TEXT_SUBTITLE: text->setTextStyle(TEXT_STYLE_SUBTITLE); break;
-            case TEXT_COMPOSER: text->setTextStyle(TEXT_STYLE_COMPOSER); break;
-            case TEXT_POET:     text->setTextStyle(TEXT_STYLE_POET);     break;
-            }
-      text->setSubtype(subtype);
-      text->setText(s);
-      measure->add(text);
-#endif
-      }
-#endif
-
-//---------------------------------------------------------
-//   readHeader
-//---------------------------------------------------------
-
-void OmrPage::readHeader(Score*)
-      {
-      if (_slices.isEmpty())
-            return;
-      double maxHeight = _spatium * 4 * 2;
-
-      int slice = 0;
-      double maxH = 0.0;
-//      int maxIdx;
-      for (;slice < _slices.size(); ++slice) {
-            double h = _slices[slice].height();
-
-            if (h > maxHeight)
-                  break;
-            if (h > maxH) {
-                  maxH = h;
-//                  maxIdx = slice;
-                  }
-            }
-#ifdef OCR
-      //
-      // assume that highest slice contains header text
-      //
-      OcrImage img = OcrImage(_image.bits(), _slices[maxIdx], (_image.width() + 31)/32);
-      QString s    = _omr->ocr()->readLine(img).trimmed();
-      if (!s.isEmpty())
-            score->addText("title", s);
-
-      QString subTitle;
-      for (int i = maxIdx + 1; i < slice; ++i) {
-            OcrImage img = OcrImage(_image.bits(), _slices[i], (_image.width() + 31)/32);
-            QString s = _omr->ocr()->readLine(img).trimmed();
-            if (!s.isEmpty()) {
-                  if (!subTitle.isEmpty())
-                        subTitle += "\n";
-                  subTitle += s;
-                  }
-            }
-      if (!subTitle.isEmpty())
-            score->addText("subtitle", subTitle);
-#endif
-#if 0
-      OcrImage img = OcrImage(_image.bits(), _slices[0], (_image.width() + 31)/32);
-      QString s = _omr->ocr()->readLine(img).trimmed();
-      if (!s.isEmpty())
-            addText(score, TEXT_TITLE, s);
-
-      img = OcrImage(_image.bits(), _slices[1], (_image.width() + 31)/32);
-      s = _omr->ocr()->readLine(img).trimmed();
-      if (!s.isEmpty())
-            addText(score, TEXT_SUBTITLE, s);
-
-      img = OcrImage(_image.bits(), _slices[2], (_image.width() + 31)/32);
-      s = _omr->ocr()->readLine(img).trimmed();
-      if (!s.isEmpty())
-            addText(score, TEXT_COMPOSER, s);
-#endif
-      }
-
-//---------------------------------------------------------
-//   crop
-//---------------------------------------------------------
-
-void OmrPage::crop()
-      {
-      int wl  = wordsPerLine();
-      int cropT = cropB = cropL = cropR = 0;
-      for (int y = 0; y < height(); ++y) {
-            const uint* p = scanLine(y);
-            for (int k = 0; k < wl; ++k) {
-                  if (*p++) {
-                        cropT = y;
-                        break;
-                        }
-                  }
-            if (cropT)
-                  break;
-            }
-      for (int y = height()-1; y >= cropT; --y) {
-            const uint* p = scanLine(y);
-            for (int k = 0; k < wl; ++k) {
-                  if (*p++) {
-                        cropB = height() - y - 1;
-                        break;
-                        }
-                  }
-            if (cropB)
-                  break;
-            }
-      int y1 = cropT;
-      int y2 = height() - cropT - cropB;
-      for (int x = 0; x < wl; ++x) {
-            for (int y = y1; y < y2; ++y) {
-                  if (*(scanLine(y) + x)) {
-                        cropL = x;
-                        break;
-                        }
-                  }
-            if (cropL)
-                  break;
-            }
-      for (int x = wl-1; x >= cropL; --x) {
-            for (int y = y1; y < y2; ++y) {
-                  if (*(scanLine(y) + x)) {
-                        cropR = wl - x - 1;
-                        break;
-                        }
-                  }
-            if (cropR)
-                  break;
-            }
-//      printf("*** crop: T%d B%d L%d R:%d\n", cropT, cropB, cropL, cropR);
-      }
-
-//---------------------------------------------------------
-//   slice
-//---------------------------------------------------------
-
-void OmrPage::slice()
-      {
-      _slices.clear();
-      int y1    = cropT;
-      int y2    = height() - cropB;
-      int x1    = cropL;
-      int x2    = wordsPerLine() - cropR;
-      int xbits = (x2 - x1) * 32;
-
-//      _slices.append(QRect(cropL*32, y1, xbits, y2-y1));
-#if 1
-      for (int y = y1; y < y2;) {
-            //
-            // skip contents
-            //
-            int ys = y;
-            for (; y < y2; ++y) {
-                  const uint* p = scanLine(y) + cropL;
-                  bool bits = false;
-                  for (int x = cropL; x < x2; ++x) {
-                        if (*p) {
-                              bits = true;
-                              break;
-                              }
-                        ++p;
-                        }
-                  if (!bits)
-                        break;
-                  }
-            if (y - ys)
-                  _slices.append(QRect(cropL*32, ys, xbits, y - ys));
-            //
-            // skip space
-            //
-            for (; y < y2; ++y) {
-                  const uint* p = scanLine(y) + cropL;
-                  bool bits = false;
-                  for (int x = cropL; x < x2; ++x) {
-                        if (*p) {
-                              bits = true;
-                              break;
-                              }
-                        ++p;
-                        }
-                  if (bits)
-                        break;
-                  }
-            }
-#endif
-      }
-
-//---------------------------------------------------------
-//    deSkew
-//---------------------------------------------------------
-
-void OmrPage::deSkew()
-      {
-      int wl    = wordsPerLine();
-      int h     = height();
-      uint* db  = new uint[wl * h];
-      memset(db, 0, wl * h * sizeof(uint));
-
-      foreach(const QRect& r, _slices) {
-            double rot = skew(r);
-            if (qAbs(rot) < 0.1) {
-                  memcpy(db + wl * r.y(), scanLine(r.y()), wl * r.height() * sizeof(uint));
-                  continue;
-                  }
-
-            QTransform t;
-            t.rotate(rot);
-            QTransform tt = QImage::trueMatrix(t, width(), r.height());
-
-            double m11 = tt.m11();
-            double m12 = tt.m12();
-            double m21 = tt.m21();
-            double m22 = tt.m22();
-            double dx  = tt.m31();
-            double dy  = tt.m32();
-
-            double m21y = r.y() * m21;
-            double m22y = r.y() * m22;
-            int y2 = r.y() + r.height();
-
-            for (int y = r.y(); y < y2; ++y) {
-                  const uint* s = scanLine(y);
-
-                  m21y += m21;
-                  m22y += m22;
-                  for (int x = 0; x < wl; ++x) {
-                        uint c = *s++;
-                        if (c == 0)
-                              continue;
-                        uint mask = 1;
-                        for (int xx = 0; xx < 32; ++xx) {
-                              if (c & mask) {
-                                    int xs  = x * 32 + xx;
-                                    int xd  = lrint(m11 * xs + m21y + dx);
-                                    int yd  = lrint(m22y + m12 * xs + dy);
-
-                                    int wxd = xd / 32;
-                                    if ((xd >= 0) && (wxd < wl) && (yd >= 0) && (yd < h)) {
-                                          uint* d = db + wl * yd + wxd;
-                                          if( d < db + wl * h) //check that we are in the bounds.
-                                                *d |= (0x1 << (xd % 32));
-                                          }
-                                    }
-                              mask <<= 1;
-                              }
-                        }
-                  }
-            }
-      memcpy(_image.bits(), db, wl * h * sizeof(uint));
-      delete[] db;
-      }
-
-struct ScanLine {
-      int run;
-      int x1, x2;
-      ScanLine() { run = 0; x1 = 100000; x2 = 0; }
-      };
-
-struct H {
-      int y;
-      int bits;
-
-      H(int a, int b) : y(a), bits(b) {}
-      };
-
-//---------------------------------------------------------
-//   xproject
-//---------------------------------------------------------
-
-int OmrPage::xproject(const uint* p, int wl)
-      {
-      int run = 0;
-      int w   = wl - cropL - cropR;
-      int x1 = cropL + w/4;         // only look at part of page
-      int x2 = x1 + w/2;
-      for (int x = cropL; x < x2; ++x) {
-            uint v = *p++;
-            run += Omr::bitsSetTable[v & 0xff]
-                + Omr::bitsSetTable[(v >> 8) & 0xff]
-                + Omr::bitsSetTable[(v >> 16) & 0xff]
-                + Omr::bitsSetTable[v >> 24];
-            }
-      return run;
-      }
-
-//---------------------------------------------------------
-//   xproject2
-//---------------------------------------------------------
-
-double OmrPage::xproject2(int y1)
-      {
-      int wl          = wordsPerLine();
-      const uint* db  = bits();
-      double val      = 0.0;
-
-      int w  = wl - cropL - cropR;
-      int x1 = (cropL + w/4)*32;         // only look at part of page
-      int x2 = x1 + (w/2 * 32);
-
-      int ddx = x2 - x1;
-      for (int dy = -12; dy < 12; ++dy) {
-            int onRun   = 0;
-            int offRun  = 0;
-            int on      = 0;
-            int off     = 0;
-            bool onFlag = false;
-            int incy    = (dy > 0) ? 1 : (dy < 0) ? -1 : 0;
-            int ddy     = dy < 0 ? -dy : dy;
-            int y       = y1;
-            if (y < 1)
-                  y = 0;
-            int err     = ddx / 2;
-            for (int x = x1; x < x2;) {
-                  const uint* d  = db + wl * y + (x / 32);
-                  if (d < db + wl)
-                        break;
-                  if (d >= db + (wl-1) * height()) //check that we are in the bounds.
-                        break;
-                  bool bit = ((*d) & (0x1 << (x % 32)));
-                  bit = bit || ((*(d+wl)) & (0x1 << (x % 32)));
-                  bit = bit || ((*(d-wl)) & (0x1 << (x % 32)));
-                  if (bit != onFlag) {
-                        if (!onFlag) {
-                              //
-                              // end of offrun:
-                              //
-                              if (offRun > 20) {
-                                    off += offRun * offRun;
-                                    on  += onRun * onRun;
-                                    onRun  = 0;
-                                    offRun = 0;
-                                    }
-                              else {
-                                    onRun += offRun;
-                                    offRun = 0;
-                                    }
-                              }
-                        onFlag = bit;
-                        }
-                  (bit ? onRun : offRun)++;
-                  if (offRun > 100) {
-                        offRun = 0;
-                        off   = 1;
-                        on    = 0;
-                        onRun = 0;
-                        break;
-                        }
-                  err -= ddy;
-                  if (err < 0) {
-                        err += ddx;
-                        y   += incy;
-                        if (y < 1)
-                              y = 1;
-                        else if (y >= height())
-                              y = height()-1;
-                        }
-                  ++x;
-                  }
-            if (offRun > 20)
-                  off += offRun * offRun;
-            else
-                  onRun += offRun;
-            on  += onRun * onRun;
-            if (off == 0)
-                  off = 1;
-            double nval = double(on) / double(off);
-            if (nval > val)
-                  val = nval;
-            }
-      return val;
-      }
-
-static bool sortLvStaves(const Lv& a, const Lv& b)
-      {
-      return a.line < b.line;
-      }
-
-//---------------------------------------------------------
-//   getStaffLines
-//---------------------------------------------------------
-
-void OmrPage::getStaffLines()
-      {
-      int h  = height();
-      int wl = wordsPerLine();
-// printf("getStaffLines %d %d  crop %d %d\n", h, wl, cropT, cropB);
-      if (h < 1)
-            return;
-
-      int y1 = cropT;
-      int y2 = h - cropB;
-      if (y2 >= h)
-            --y2;
-
-      double projection[h];
-      for (int y = 0; y < y1; ++y)
-            projection[y] = 0;
-      for (int y = y2; y < h; ++y)
-            projection[y] = 0;
-      for (int y = y1; y < y2; ++y)
-            projection[y] = xproject2(y);
-      int autoTableSize = (wl * 32) / 10;       // 1/10 page width
-      if (autoTableSize > y2-y1)
-            autoTableSize = y2 - y1;
-      double autoTable[autoTableSize];
-      memset(autoTable, 0, sizeof(autoTable));
-      for (int i = 0; i < autoTableSize; ++i) {
-            autoTable[i] = covariance(projection+y1, projection+i+y1, y2-y1-i);
-            }
-
-      //
-      // search for first maximum in covariance starting at 10 to skip
-      // line width. Staff line distance (spatium) must be at least 10 dots
-      //
-      double maxCorrelation = 0;
-      _spatium = 0;
-      for (int i = 10; i < autoTableSize; ++i) {
-            if (autoTable[i] > maxCorrelation) {
-                  maxCorrelation = autoTable[i];
-                  _spatium = i;
-                  }
-            }
-      if (_spatium == 0) {
-            printf("*** no staff lines found\n");
-            return;
-            }
-
-      //---------------------------------------------------
-      //    look for staves
-      //---------------------------------------------------
-
-      QList<Lv> lv;
-      int ly = 0;
-      int lval = -1000.0;
-      for (int y = y1; y < (y2 - _spatium * 4); ++y) {
-            double val = 0.0;
-            for (int i = 0; i < 5; ++i)
-                  val += projection[y + i * int(_spatium)];
-            if (val < lval) {
-                  lv.append(Lv(ly, lval));
-                  }
-            lval = val;
-            ly   = y;
-            }
-      qSort(lv);
-
-      QList<Lv> staveTop;
-      int staffHeight = _spatium * 6;
-      foreach(Lv a, lv) {
-            if (a.val < 500)   // MAGIC to avoid false positives
-                  continue;
-            int line = a.line;
-            bool ok  = true;
-            foreach(Lv b, staveTop) {
-                  if ((line > (b.line - staffHeight)) && (line < (b.line + staffHeight))) {
-                        ok = false;
-                        break;
-                        }
-                  }
-            if (ok)
-                  staveTop.append(a);
-            }
-      qSort(staveTop.begin(), staveTop.end(), sortLvStaves);
-      foreach(Lv a, staveTop) {
-            staves.append(OmrStaff(cropL * 32, a.line, width() - cropR*32, _spatium*4));
-            }
-      }
-
-//---------------------------------------------------------
-//   searchNotes
-//---------------------------------------------------------
-
-void OmrSystem::searchNotes(QList<OmrNote*>* noteList, int x1, int x2, int y, int line)
-      {
-      double _spatium = _page->spatium();
-      y += line * _spatium * .5;
-
-      Pattern* patternList[2];
-      patternList[0] = Omr::quartheadPattern;
-      patternList[1] = Omr::halfheadPattern;
-
-      QList<Peak> notePeaks;
-
-      for (int k = 0; k < 2; ++k) {
-            Pattern* pattern = patternList[k];
-            int hh = pattern->h();
-            int hw = pattern->w();
-            bool found = false;
-            int xx1;
-            double val;
-
-            for (int x = x1; x < (x2 - hw); ++x) {
-                  double val1 = pattern->match(&_page->image(), x, y - hh/2);
-                  if (val1 >= noteTH) {
-                        if (!found || (val1 > val)) {
-                              xx1 = x;
-                              val = val1;
-                              found = true;
-                              }
-                        }
-                  else {
-                        if (found) {
-                              notePeaks.append(Peak(xx1, val, k));
-                              found = false;
-                              }
-                        }
-                  }
-            }
-
-      qSort(notePeaks);
-      int n = notePeaks.size();
-      for (int i = 0; i < n; ++i) {
-            if (notePeaks[i].val < noteTH)
-                  break;
-            OmrNote* note = new OmrNote;
-            int sym = notePeaks[i].sym;
-            int hh = patternList[sym]->h();
-            int hw = patternList[sym]->w();
-            note->setRect(notePeaks[i].x, y - hh/2, hw, hh);
-            note->line = line;
-            note->sym  = patternList[sym]->id();
-            note->prob = notePeaks[i].val;
-            noteList->append(note);
-            }
-      }
-
-//---------------------------------------------------------
-//   staffDistance
-//---------------------------------------------------------
-
-double OmrPage::staffDistance() const
-      {
-      if (staves.size() < 2)
-            return 5;
-      return ((staves[1].y() - staves[0].y()) / _spatium) - 4.0;
-      }
-
-//---------------------------------------------------------
-//   systemDistance
-//---------------------------------------------------------
-
-double OmrPage::systemDistance() const
-      {
-      if (staves.size() < 3)
-            return 6.0;
-      return ((staves[2].y() - staves[1].y()) / _spatium) - 4.0;
-      }
-
-//---------------------------------------------------------
-//   write
-//---------------------------------------------------------
-
-void OmrPage::write(Xml& xml) const
-      {
-      xml.stag("OmrPage");
-      xml.tag("cropL", cropL);
-      xml.tag("cropR", cropR);
-      xml.tag("cropT", cropT);
-      xml.tag("cropB", cropB);
-      foreach(const QRect& r, staves)
-            xml.tag("staff", QRectF(r));
-      xml.etag();
-      }
-
-//---------------------------------------------------------
-//   read
-//---------------------------------------------------------
-
-void OmrPage::read(XmlReader& e)
-      {
-      while (e.readNextStartElement()) {
-            const QStringRef& tag(e.name());
-
-            if (tag == "cropL")
-                  cropL = e.readInt();
-            else if (tag == "cropR")
-                  cropR = e.readInt();
-            else if (tag == "cropT")
-                  cropT = e.readInt();
-            else if (tag == "cropB")
-                  cropB = e.readInt();
-            else if (tag == "staff") {
-                  OmrStaff r(e.readRect().toRect());
-                  staves.append(r);
-                  }
-            else
-                  e.unknown();
-            }
-      }
-}
-
diff --git a/omr/omrpage.h b/omr/omrpage.h
deleted file mode 100644 (file)
index bb51303..0000000
+++ /dev/null
@@ -1,246 +0,0 @@
-//=============================================================================
-//  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"
-
-namespace Ms {
-
-class Omr;
-class Score;
-class Xml;
-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(-1), prob(0.0) {}
-      int sym;
-      double prob;
-      };
-
-//---------------------------------------------------------
-//   OmrClef
-//---------------------------------------------------------
-
-class OmrClef : public OmrPattern {
-   public:
-      OmrClef() : OmrPattern() {}
-      OmrClef(const OmrPattern& p) : OmrPattern(p) {}
-      ClefType type = 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 searchBarLines();
-      void searchNotes();
-      };
-
-//---------------------------------------------------------
-//   OmrPage
-//---------------------------------------------------------
-
-class OmrPage {
-      Omr* _omr;
-      QImage _image;
-      double _spatium;
-
-      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 crop();
-      void slice();
-      double skew(const QRect&);
-      void deSkew();
-      void getStaffLines();
-      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 staffDistance() const;
-      double systemDistance() const;
-      void readHeader(Score* score);
-      void readBarLines(int);
-
-      const QList<OmrSystem>& systems() const { return _systems; }
-      QList<OmrSystem>& systems() { return _systems; }
-      OmrSystem* system(int idx)  { return &_systems[idx]; }
-
-
-      void write(Xml&) const;
-      void read(XmlReader&);
-      bool dot(int x, int y) const;
-      };
-
-}
-
-#endif
-
-
diff --git a/omr/omrview.cpp b/omr/omrview.cpp
deleted file mode 100644 (file)
index 45960b3..0000000
+++ /dev/null
@@ -1,454 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "mscore/globals.h"
-#include "omrview.h"
-#include "omr.h"
-#include "libmscore/page.h"
-#include "omrpage.h"
-#include "libmscore/score.h"
-#include "mscore/scoreview.h"
-#include "libmscore/sym.h"
-#include "libmscore/mscore.h"
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   OmrView
-//---------------------------------------------------------
-
-OmrView::OmrView(ScoreView* sv, QWidget* parent)
-   : QWidget(parent)
-      {
-      setFocusPolicy(Qt::StrongFocus);
-      setAttribute(Qt::WA_InputMethodEnabled);
-      setAttribute(Qt::WA_KeyCompression);
-      setMouseTracking(true);
-
-      _omr       = 0;
-      _scoreView = sv;
-      double m   = .25;
-      _fotoMode  = false;
-      _matrix    = QTransform(m, 0.0, 0.0, m, 0.0, 0.0);
-      xoff = yoff = 0;
-      _showLines      = false;
-      _showBarlines   = true;
-      _showSlices     = true;
-      _showStaves     = true;
-      }
-
-//---------------------------------------------------------
-//   setOmr
-//---------------------------------------------------------
-
-void OmrView::setOmr(Omr* s)
-      {
-      delete _omr;
-      _omr    = s;
-      if (s == 0 || s->numPages() == 0) {
-            maxTiles = 0;
-            return;
-            }
-      int n                = s->numPages();
-      OmrPage* page        = _omr->page(0);
-      const QImage& i      = page->image();
-      Score* score         = _scoreView->score();
-      const PageFormat* pf = score->pageFormat();
-      double mag           = _omr->spatium() / score->spatium();
-      pageWidth            = lrint(pf->width()  * mag * MScore::DPI);
-
-      int htiles = ((pageWidth + TILE_W - 1) / TILE_W);
-      pageWidth  = htiles * TILE_W;
-      int vtiles = (i.height() + TILE_H - 1) / TILE_H;
-      maxTiles   = n * htiles *  vtiles;
-      }
-
-//---------------------------------------------------------
-//   initTile
-//---------------------------------------------------------
-
-void OmrView::initTile(Tile* t)
-      {
-      int page1  = t->r.x() / pageWidth;
-      if (page1 < 0)
-            page1 = 0;
-      int n = _omr->numPages();
-      if (page1 >= n)
-            return;
-
-      t->page     = _omr->page(page1);
-      t->pageNo   = page1;
-
-      const QImage& i = t->page->image();
-      int xoffset     = 0; // (pageWidth - i.width()) / 2;
-      int x           = t->r.x() - (t->pageNo * pageWidth) - xoffset;
-      t->pm           = QPixmap::fromImage(i.copy(x, t->r.y(), TILE_W, TILE_H));
-      }
-
-//---------------------------------------------------------
-//   Tile
-//---------------------------------------------------------
-
-Tile::Tile()
-   : no(0), r(0, 0, TILE_W, TILE_H), pm(TILE_W, TILE_H)
-      {
-      }
-
-//---------------------------------------------------------
-//   paintEvent
-//---------------------------------------------------------
-
-void OmrView::paintEvent(QPaintEvent* event)
-      {
-      if (_omr == 0)
-            return;
-
-      QPainter p(this);
-      p.setTransform(_matrix);
-
-      QRect r(event->rect());
-
-      //
-      // remove unused tiles
-      //
-      QRect rr = _matrix.inverted().mapRect(QRectF(r)).toRect();
-      rr.adjust(-1, -1, 2, 2);
-
-      QList<Tile*> nl;
-      foreach(Tile* t, usedTiles) {
-            if (t->r.intersects(rr))
-                  nl.append(t);
-            else
-                  freeTiles.append(t);
-            }
-#if QT_VERSION >= 0x040800
-      usedTiles.swap(nl);
-#else
-      QList<Tile*> tmp = nl;
-      nl = usedTiles;
-      usedTiles = tmp;
-#endif
-
-      //
-      // add visible tiles
-      //
-      Score* score    = _scoreView->score();
-
-      double sSpatium = score->spatium();
-      double spatium  = _omr->spatium();
-      double mag      = spatium / sSpatium;
-
-      const PageFormat* pf = score->pageFormat();
-      int w = pageWidth;
-      int h = lrint(pf->height() * mag * MScore::DPI);
-      int n = _omr->numPages();
-
-      int nx = (w * n) / TILE_W;
-      int ny = (h + TILE_H - 1) / TILE_H;
-
-      int y1 = rr.y() / TILE_H;
-      int y2 = (rr.y() + rr.height() + TILE_H - 1) / TILE_H;
-      int x1 = rr.x() / TILE_W;
-      int x2 = (rr.x() + rr.width() + TILE_W -1) / TILE_W;
-
-      if (x1 < 0)
-            x1 = 0;
-      if (y1 < 0)
-            y1 = 0;
-      if (x2 > nx)
-            x2 = nx;
-      if (y2 > ny)
-            y2 = ny;
-
-      for (int y = y1; y < y2; ++y) {
-            for (int x = x1; x < x2; ++x) {
-                  int no = nx * y + x;
-                  if (no < 0 || no >= maxTiles)
-                        continue;
-                  int i;
-                  for (i = 0; i < usedTiles.size(); ++i) {
-                        if (usedTiles[i]->no == no)
-                              break;
-                        }
-                  if (i == usedTiles.size()) {
-                        // create new tile
-                        Tile* t = freeTiles.isEmpty() ? new Tile : freeTiles.pop();
-                        t->no = no;
-                        t->r  = QRect(x * TILE_W, y * TILE_H, TILE_W, TILE_H);
-                        initTile(t);
-                        usedTiles.append(t);
-                        }
-                  }
-            }
-
-      int minPage = 9000;
-      int maxPage = 0;
-      foreach(const Tile* t, usedTiles) {
-            p.drawPixmap(t->r, t->pm);
-            if (t->pageNo < minPage)
-                  minPage = t->pageNo;
-            if (t->pageNo > maxPage)
-                  maxPage = t->pageNo;
-            }
-      for (int pageNo = minPage; pageNo <= maxPage; ++pageNo) {
-            OmrPage* page = _omr->page(pageNo);
-            p.save();
-            p.translate(w * pageNo, 0);
-            if (_showLines) {
-                  p.setPen(QPen(QColor(255, 0, 0, 80), 1.0));
-                  foreach(QLine l, page->sl())
-                        p.drawLine(QLineF(l.x1()+.5, l.y1()+.5, l.x2()+.5, l.y2()+.5));
-                  }
-            if (_showSlices) {
-                  foreach(const QRect r, page->slices())
-                        p.fillRect(r, QBrush(QColor(0, 100, 100, 50)));
-                  }
-
-            if (_showStaves) {
-                  foreach(const OmrSystem& s, page->systems()) {       // staves
-                        foreach(const OmrStaff& r, s.staves())
-                              p.fillRect(r, QBrush(QColor(0, 0, 100, 50)));
-                        }
-                  }
-
-            foreach (const OmrSystem& system, page->systems()) {
-                  if (_showBarlines) {
-                        p.setPen(QPen(Qt::blue, 3.0));
-                        foreach(const QLineF& l, system.barLines)
-                              p.drawLine(l);
-                        }
-
-                  foreach (const OmrStaff& staff, system.staves()) {
-                        foreach (const OmrNote* n, staff.notes()) {
-                              if (n->sym == quartheadSym)
-                                    p.setPen(QPen(QColor(255, 0, 0), 2.0));
-                              else
-                                    p.setPen(QPen(QColor(0, 0, 255), 2.0));
-                              p.drawRect(*n);
-                              }
-                        }
-                  }
-            p.restore();
-            }
-
-      if (fotoMode()) {
-            // TODO
-            p.setBrush(QColor(0, 0, 50, 50));
-            QPen pen(QColor(0, 0, 255));
-            // always 2 pixel width
-            qreal w = 2.0 / p.matrix().m11();
-            pen.setWidthF(w);
-            p.setPen(pen);
-            p.drawRect(_foto);
-            }
-      }
-
-//---------------------------------------------------------
-//   mousePressEvent
-//---------------------------------------------------------
-
-void OmrView::mousePressEvent(QMouseEvent* e)
-      {
-      startDrag = e->pos();
-      }
-
-//---------------------------------------------------------
-//   mouseMoveEvent
-//---------------------------------------------------------
-
-void OmrView::mouseMoveEvent(QMouseEvent* e)
-      {
-      if (QApplication::mouseButtons()) {
-            QPoint delta = e->pos() - startDrag;
-            int dx       = delta.x();
-            int dy       = delta.y();
-            xoff += dx;
-            yoff += dy;
-            _matrix.setMatrix(_matrix.m11(), _matrix.m12(), _matrix.m13(), _matrix.m21(),
-               _matrix.m22(), _matrix.m23(), _matrix.dx()+dx, _matrix.dy()+dy, _matrix.m33());
-
-            scroll(dx, dy, QRect(0, 0, width(), height()));
-            startDrag = e->pos();
-            }
-      }
-
-//---------------------------------------------------------
-//   setMag
-//---------------------------------------------------------
-
-void OmrView::setMag(double nmag)
-      {
-      qreal m = mag();
-
-      if (nmag == m)
-            return;
-      double deltamag = nmag / m;
-
-      _matrix.setMatrix(nmag, _matrix.m12(), _matrix.m13(), _matrix.m21(),
-         nmag, _matrix.m23(), _matrix.dx()*deltamag, _matrix.dy()*deltamag, _matrix.m33());
-      }
-
-//---------------------------------------------------------
-//   zoom
-//---------------------------------------------------------
-
-void OmrView::zoom(int step, const QPoint& pos)
-      {
-      QTransform imatrix(_matrix.inverted());
-      QPointF p1 = imatrix.map(QPointF(pos));
-      double _scale = mag();
-      if (step > 0) {
-            for (int i = 0; i < step; ++i)
-                   _scale *= 1.1;
-            }
-      else {
-            for (int i = 0; i < -step; ++i)
-                  _scale /= 1.1;
-            }
-      if (_scale > 16.0)
-            _scale = 16.0;
-      else if (_scale < 0.05)
-            _scale = 0.05;
-      setMag(_scale);
-
-      QPointF p2 = imatrix.map(QPointF(pos));
-      QPointF p3 = p2 - p1;
-      int dx     = lrint(p3.x() * _scale);
-      int dy     = lrint(p3.y() * _scale);
-
-      _matrix.setMatrix(_matrix.m11(), _matrix.m12(), _matrix.m13(), _matrix.m21(),
-         _matrix.m22(), _matrix.m23(), _matrix.dx()+dx, _matrix.dy()+dy, _matrix.m33());
-      scroll(dx, dy, QRect(0, 0, width(), height()));
-      update();
-      }
-
-//---------------------------------------------------------
-//   wheelEvent
-//---------------------------------------------------------
-
-void OmrView::wheelEvent(QWheelEvent* event)
-      {
-      if (event->modifiers() & Qt::ControlModifier) {
-            QApplication::sendPostedEvents(this, 0);
-            zoom(event->delta() / 120, event->pos());
-            return;
-            }
-      int dx = 0;
-      int dy = 0;
-      if (event->modifiers() & Qt::ShiftModifier || event->orientation() == Qt::Horizontal) {
-            //
-            //    scroll horizontal
-            //
-            int n = width() / 10;
-            if (n < 2)
-                  n = 2;
-            dx = event->delta() * n / 120;
-            }
-      else {
-            //
-            //    scroll vertical
-            //
-            int n = height() / 10;
-            if (n < 2)
-                  n = 2;
-            dy = event->delta() * n / 120;
-            }
-
-      _matrix.setMatrix(_matrix.m11(), _matrix.m12(), _matrix.m13(), _matrix.m21(),
-         _matrix.m22(), _matrix.m23(), _matrix.dx()+dx, _matrix.dy()+dy, _matrix.m33());
-      scroll(dx, dy, QRect(0, 0, width(), height()));
-      }
-
-//---------------------------------------------------------
-//   setScale
-//---------------------------------------------------------
-
-void OmrView::setScale(double v)
-      {
-      double spatium = _omr->spatium();
-      setMag(v/spatium);
-      update();
-      }
-
-//---------------------------------------------------------
-//   setOffset
-//---------------------------------------------------------
-
-void OmrView::setOffset(double x, double y)
-      {
-      Score* score    = _omr->score();
-      double sSpatium = score->spatium() * _scoreView->matrix().m11();
-      double spatium  = _omr->spatium() * _matrix.m11();
-
-      double nx = x / sSpatium * spatium + xoff;
-      double ny = y / sSpatium * spatium + yoff;
-
-      double ox = _matrix.dx();
-      double oy = _matrix.dy();
-
-      _matrix.setMatrix(_matrix.m11(), _matrix.m12(), _matrix.m13(), _matrix.m21(),
-         _matrix.m22(), _matrix.m23(), nx, ny, _matrix.m33());
-
-      scroll(ox-nx, oy-ny, QRect(0, 0, width(), height()));
-      update();
-      }
-
-//---------------------------------------------------------
-//   contextMenuEvent
-//---------------------------------------------------------
-
-void OmrView::contextMenuEvent(QContextMenuEvent*)
-      {
-      printf("context menu\n");
-      }
-
-//---------------------------------------------------------
-//   setShowBarlines
-//---------------------------------------------------------
-
-void OmrView::setShowBarlines(bool val)
-      {
-      _showBarlines = val;
-      update();
-      }
-
-//---------------------------------------------------------
-//   setShowSlices
-//---------------------------------------------------------
-
-void OmrView::setShowSlices(bool val)
-      {
-      _showSlices = val;
-      update();
-      }
-
-//---------------------------------------------------------
-//   setShowStaves
-//---------------------------------------------------------
-
-void OmrView::setShowStaves(bool val)
-      {
-      _showStaves = val;
-      update();
-      }
-
-}
-
-
diff --git a/omr/omrview.h b/omr/omrview.h
deleted file mode 100644 (file)
index 7f2c169..0000000
+++ /dev/null
@@ -1,115 +0,0 @@
-//=============================================================================
-//  MusE Reader
-//  Linux 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 __SCAN_VIEW_H__
-#define __SCAN_VIEW_H__
-
-namespace Ms {
-
-class Omr;
-class Page;
-class ScoreView;
-class OmrPage;
-
-//---------------------------------------------------------
-//   Tile
-//---------------------------------------------------------
-
-struct Tile {
-      int no;
-      QRect r;
-      QPixmap pm;
-      OmrPage* page;
-      int pageNo;
-
-      Tile();
-      };
-
-static const int TILE_H = 512;
-static const int TILE_W = 512;
-
-//---------------------------------------------------------
-//   OmrView
-//---------------------------------------------------------
-
-class OmrView : public QWidget {
-      Q_OBJECT
-      Omr* _omr;
-      ScoreView* _scoreView;
-      int maxTiles;
-
-      QList<Tile*> usedTiles;
-      QStack<Tile*> freeTiles;
-      QPoint startDrag;
-
-      QTransform _matrix;
-      int xoff, yoff;
-      int pageWidth;
-
-      bool   _fotoMode;
-      QRectF _foto;
-
-      bool _showLines;
-      bool _showBarlines;
-      bool _showSlices;
-      bool _showStaves;
-
-      void zoom(int step, const QPoint& pos);
-
-      virtual void mousePressEvent(QMouseEvent*);
-      virtual void mouseMoveEvent(QMouseEvent*);
-      virtual void wheelEvent(QWheelEvent*);
-      virtual void paintEvent(QPaintEvent*);
-      virtual void contextMenuEvent(QContextMenuEvent*);
-
-      qreal mag() const { return _matrix.m11(); }
-      void setMag(double mag);
-      void initTile(Tile* t);
-
-   public slots:
-      void setScale(double);
-      void setOffset(double, double);
-
-   signals:
-      void pageNumberChanged(int);
-      void xPosChanged(int);
-      void yPosChanged(int);
-
-   public:
-      OmrView(ScoreView*, QWidget* parent = 0);
-      void setOmr(Omr*);
-      Omr* omr() const           { return _omr;      }
-      bool fotoMode() const      { return _fotoMode; }
-      void setFotoMode(bool val) { _fotoMode = val;  }
-
-      void setShowLines(bool val)          { _showLines = val;  }
-      bool showLines() const               { return _showLines; }
-      bool showBarlines() const            { return _showBarlines; }
-      bool showSlices() const              { return _showSlices;   }
-      bool showStaves() const              { return _showStaves;   }
-      void setShowBarlines(bool val);
-      void setShowSlices(bool val);
-      void setShowStaves(bool val);
-      };
-
-}
-
-#endif
-
diff --git a/omr/pattern.cpp b/omr/pattern.cpp
deleted file mode 100644 (file)
index 0084cb0..0000000
+++ /dev/null
@@ -1,182 +0,0 @@
-//=============================================================================
-//  MusE Reader
-//  Music Score Reader
-//  $Id$
-//
-//  Copyright (C) 2010-2011 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.
-//=============================================================================
-
-#include "pattern.h"
-#include "utils.h"
-#include "libmscore/sym.h"
-#include "omr.h"
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   Pattern
-//---------------------------------------------------------
-
-Pattern::Pattern()
-      {
-      }
-
-Pattern::~Pattern()
-      {
-      }
-
-//---------------------------------------------------------
-//   patternMatch
-//    compare two patterns for similarity
-//    return:
-//          1.0   - identical
-//          0.5   - 50% of all pixel match
-//          0.0   - no match
-//---------------------------------------------------------
-
-double Pattern::match(const Pattern* a) const
-      {
-      int n = image()->byteCount();
-      if (n != a->image()->byteCount())
-            return 0.0;
-      int k = 0;
-      const uchar* p1 = image()->bits();
-      const uchar* p2 = a->image()->bits();
-      for (int i = 0; i < n; ++i) {
-            uchar v = (*(p1++)) ^ (*(p2++));
-            k += Omr::bitsSetTable[v];
-            }
-      return 1.0 - (double(k) / (h() * w()));
-      }
-
-double Pattern::match(const QImage* img, int col, int row) const
-      {
-      int rows      = h();
-      int bytes     = ((w() + 7) / 8) - 1;
-      int shift     = col & 7;
-      int k         = 0;
-      int eshift    = (col + w()) & 7;
-
-      for (int y = 0; y < rows; ++y) {
-            const uchar* p1 = image()->scanLine(y);
-            const uchar* p2 = img->scanLine(row + y) + (col/8);
-            for (int x = 0; x < bytes; ++x) {
-                  uchar a = *p1++;
-                  uchar b1 = *p2;
-                  uchar b2 = *(p2 + 1);
-                  p2++;
-                  uchar b  = (b1 >> shift) | (b2 << (7 - shift));
-                  uchar v = a ^ b;
-                  k += Omr::bitsSetTable[v];
-                  }
-            uchar a = *p1++;
-            uchar b1 = *p2;
-            uchar b2 = *(p2 + 1) & (0xff << eshift);
-            uchar b  = (b1 >> shift) | (b2 << (7 - shift));
-            uchar v = a ^ b;
-            k += Omr::bitsSetTable[v];
-            }
-      return 1.0 - (double(k) / (h() * w()));
-      }
-
-//---------------------------------------------------------
-//   Pattern
-//    create a Pattern from symbol
-//---------------------------------------------------------
-
-Pattern::Pattern(int id, Sym* symbol, double spatium)
-      {
-      _id = id;
-      _sym = symbol;
-      QFont f("MScore");
-      f.setPixelSize(lrint(spatium * 4));
-      QFontMetrics fm(f);
-      QString s;
-      QChar code(_sym->code());
-      QRect r(fm.boundingRect(code));
-      int _w = r.right() - r.left() + 2;
-      int _h = ((r.height() + 1) / 2) * 2;
-      _base = QPoint(-r.left(), -r.top());
-
-      _image = QImage(_w, _h, QImage::Format_MonoLSB);
-      QVector<QRgb> ct(2);
-      ct[0] = qRgb(255, 255, 255);
-      ct[1] = qRgb(0, 0, 0);
-      _image.setColorTable(ct);
-      _image.fill(0);
-
-      QPainter painter;
-      painter.begin(&_image);
-      painter.setFont(f);
-      painter.drawText(-r.left() + 1, -r.y(), code);
-      painter.end();
-
-      int ww = _w % 32;
-      if (ww == 0)
-            return;
-      uint mask = 0xffffffff << ww;
-      int n = ((_w + 31) / 32) - 1;
-      for (int i = 0; i < _h; ++i) {
-            uint* p = ((uint*)_image.scanLine(i)) + n;
-            *p = ((*p) & ~mask);
-            }
-      }
-
-//---------------------------------------------------------
-//   Pattern
-//    create a Pattern from image
-//---------------------------------------------------------
-
-Pattern::Pattern(QImage* img, int x, int y, int w, int h)
-      {
-      _image = img->copy(x, y, w, h);
-      int ww = w % 32;
-      if (ww == 0)
-            return;
-      uint mask = 0xffffffff << ww;
-      int n = ((w + 31) / 32) - 1;
-      for (int i = 0; i < h; ++i) {
-            uint* p = ((uint*)_image.scanLine(i)) + n;
-            *p     &= ~mask;
-            }
-      }
-
-//---------------------------------------------------------
-//   dump
-//---------------------------------------------------------
-
-void Pattern::dump() const
-      {
-      printf("pattern %d x %d\n", _image.width(), _image.height());
-      for (int y = 0; y < _image.height(); ++y) {
-            for (int x = 0; x < _image.width(); ++x) {
-                  QRgb pixel = _image.pixel(x, y);
-                  printf("%c", pixel & 0xffffff ? '-' : '*');
-                  }
-            printf("\n");
-            }
-      }
-
-//---------------------------------------------------------
-//   dot
-//---------------------------------------------------------
-
-bool Pattern::dot(int x, int y) const
-      {
-      const uint* p = (const uint*)_image.scanLine(y) + (x / 32);
-      return (*p) & (0x1 << (x % 32));
-      }
-}
-
diff --git a/omr/pattern.h b/omr/pattern.h
deleted file mode 100644 (file)
index f188115..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-//=============================================================================
-//  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 __PATTERN_H__
-#define __PATTERN_H__
-
-namespace Ms {
-
-class Sym;
-
-//---------------------------------------------------------
-//   Pattern
-//    _n % sizeof(int)  is zero, patterns are 32bit padded
-//---------------------------------------------------------
-
-class Pattern {
-   protected:
-      QImage _image;
-      Sym* _sym = 0;
-      int _id;
-      QPoint _base;
-
-   public:
-      Pattern();
-      ~Pattern();
-      Pattern(int id, Sym* symbol, double spatium);
-      Pattern(QImage*, int, int, int, int);
-
-      double match(const Pattern*) const;
-      double match(const QImage* img, int col, int row) const;
-
-      void dump() const;
-      const QImage* image() const { return &_image; }
-      int w() const       { return _image.width(); }
-      int h() const       { return _image.height(); }
-      bool dot(int x, int y) const;
-      int id() const      { return _id; }
-      void setId(int val) { _id = val; }
-      const QPoint& base() const { return _base; }
-      void setBase(const QPoint& v) { _base = v; }
-      };
-}
-
-#endif
-
diff --git a/omr/pdf.cpp b/omr/pdf.cpp
deleted file mode 100644 (file)
index 600d4fe..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "pdf.h"
-extern "C" {
-#include <fitz.h>
-// #include <mupdf.h>
-      }
-
-namespace Ms {
-
-int Pdf::references;
-static fz_context* ctx;
-
-//---------------------------------------------------------
-//   numPages
-//---------------------------------------------------------
-
-int Pdf::numPages() const
-      {
-      return fz_count_pages(doc);
-      }
-
-//---------------------------------------------------------
-//   Pdf
-//---------------------------------------------------------
-
-Pdf::Pdf()
-      {
-      if (references == 0)
-            ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);  // 256MB cache
-      ++references;
-      doc = 0;
-      }
-
-//---------------------------------------------------------
-//   open
-//---------------------------------------------------------
-
-bool Pdf::open(const QString& path)
-      {
-      char* name = path.toLatin1().data();
-      fz_try(ctx) {
-            doc = fz_open_document(ctx, name);
-            }
-      fz_catch(ctx) {
-            fz_close_document(doc);
-            doc = 0;
-            return false;
-            }
-      return true;
-      }
-
-//---------------------------------------------------------
-//   ~Pdf
-//---------------------------------------------------------
-
-Pdf::~Pdf()
-      {
-      if (doc)
-            fz_close_document(doc);
-      doc = 0;
-      --references;
-      if (references == 0) {
-            fz_free_context(ctx);
-            ctx = 0;
-            }
-      }
-
-//---------------------------------------------------------
-//   page
-//---------------------------------------------------------
-
-QImage Pdf::page(int i)
-      {
-      fz_page* page = fz_load_page(doc, i);
-      if (page == 0) {
-            printf("cannot load page %d\n", i);
-            return QImage();
-            }
-      static const float resolution = 600.0;
-      const float zoom = resolution / 72.0;
-      fz_rect bounds;
-
-      fz_bound_page(doc, page, &bounds);
-      fz_matrix ctm;
-
-      fz_pre_scale(fz_rotate(&ctm, 0.0), zoom, zoom);
-
-      fz_irect ibounds;
-      fz_rect tbounds;
-      tbounds = bounds;
-      fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
-      fz_pixmap* pix = fz_new_pixmap_with_bbox(ctx, fz_device_gray, &ibounds);
-
-      fz_clear_pixmap_with_value(ctx, pix, 255);
-      fz_device* dev = fz_new_draw_device(ctx, pix);
-      fz_run_page(doc, page, dev, &ctm, NULL);
-      fz_free_device(dev);
-      dev = NULL;
-
-      int w = fz_pixmap_width(ctx, pix);
-      int h = fz_pixmap_height(ctx, pix);
-      if (fz_pixmap_components(ctx, pix) != 2) {
-            printf("omg: pixmap not bw? %d\n", fz_pixmap_components(ctx, pix));
-            return QImage();
-            }
-
-      printf("page %d  %d x %d\n", i, w, h);
-      QImage image(w, h, QImage::Format_MonoLSB);
-      QVector<QRgb> ct(2);
-      ct[0] = qRgb(255, 255, 255);
-      ct[1] = qRgb(0, 0, 0);
-      image.setColorTable(ct);
-
-      uchar* s   = fz_pixmap_samples(ctx, pix);
-      int bytes  = w / 8;
-      int bits   = w % 8;
-      for (int line = 0; line < h; ++line) {
-            uchar* d = image.scanLine(line);
-            for (int col = 0; col < bytes; ++col) {
-                  uchar data = 0;
-                  for (int i = 0; i < 8; ++i) {
-                        uchar v = *s;
-                        s += 2;
-                        data >>= 1;
-                        if (v < 128) {            // convert grayscale to bw
-                              data |= 0x80;
-                              }
-                        }
-                  *d++ = data;
-                  }
-            uchar data = 0;
-            for (int col = 0; col < bits; ++col) {
-                  uchar v = *s;
-                  s += 2;
-                  data >>= 1;
-                  if (v < 128)
-                        data |= 0x80;
-                  }
-            }
-      fz_drop_pixmap(ctx, pix);
-      return image;
-      }
-}
-
diff --git a/omr/pdf.h b/omr/pdf.h
deleted file mode 100644 (file)
index 5bd98f8..0000000
--- a/omr/pdf.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//=============================================================================
-//  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 __PDF_H__
-#define __PDF_H__
-
-typedef struct fz_document_s fz_document;
-
-namespace Ms {
-
-//---------------------------------------------------------
-//   Pdf
-//---------------------------------------------------------
-
-class Pdf {
-      static int references;
-      fz_document* doc;
-
-   public:
-      Pdf();
-      bool open(const QString& path);
-      ~Pdf();
-
-      int numPages() const;
-      QImage page(int);
-      };
-}
-
-#endif
-
diff --git a/omr/skew.cpp b/omr/skew.cpp
deleted file mode 100644 (file)
index a3ab29d..0000000
+++ /dev/null
@@ -1,186 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "image.h"
-#include "utils.h"
-#include "omr.h"
-#include "omrpage.h"
-
-namespace Ms {
-
-//=============================================================================
-//  inspired by ImageMagick (http://www.imagemagick.org)
-//=============================================================================
-
-//  imageSkew() calculates skew of image.  Skew is an artifact that
-//  occurs in scanned images because of the camera being misaligned,
-//  imperfections in the scanning or surface, or simply because the paper was
-//  not placed completely flat when scanned.
-//
-//  The format of the imageSkew method is:
-//
-//      double imageSkew(const QImage *image)
-//
-
-// Benchmark 7.3sec test2 first page
-//           6
-//           5.7
-//           5.3
-//           3.74
-//           3.30
-//           0.47sec RELEASE
-
-#define MyPI  3.14159265358979323846264338327950288419716939937510
-
-//---------------------------------------------------------
-//   RadiansToDegrees
-//---------------------------------------------------------
-
-static inline double RadiansToDegrees(double r) {
-      return 180.0 * r / MyPI;
-      }
-
-//---------------------------------------------------------
-//   RadonInfo
-//---------------------------------------------------------
-
-class RadonInfo {
-      int size;
-
-   public:
-      ushort* cells;
-      int width, height;
-
-      RadonInfo(ulong w, ulong h) {
-            width  = w;
-            height = h;
-            size   = w * h;
-            cells  = new ushort[size];
-            }
-      ~RadonInfo() { delete[] cells; }
-      void reset() { memset(cells, 0, size * sizeof(*cells)); }
-      ushort getCell(int x, int y) const         { return cells[height * x + y];  }
-      void   setCell(int x, int y, ushort value) { cells[height * x + y] = value; }
-      };
-
-//---------------------------------------------------------
-//   radonProjection
-//---------------------------------------------------------
-
-static void radonProjection(RadonInfo* src, RadonInfo* dst, int sign, ulong* projection)
-      {
-      RadonInfo* p = src;
-      RadonInfo* q = dst;
-      for (int step = 1; step < p->width; step *= 2) {
-            for (int x = 0; x < p->width; x += 2 * step) {
-                  for (int i = 0; i < step; i++) {
-                        int y;
-                        for (y = 0; y < (p->height-i-1); y++) {
-                              ushort cell = p->getCell(x+i, y);
-                              q->setCell(x+2*i,   y, cell + p->getCell(x+i+step, y+i));
-                              q->setCell(x+2*i+1, y, cell + p->getCell(x+i+step, y+i+1));
-                              }
-                        for ( ; y < (p->height-i); y++) {
-                              ushort cell = p->getCell(x+i, y);
-                              q->setCell(x+2*i, y, cell + p->getCell(x+i+step, y+i));
-                              q->setCell(x+2*i+1, y, cell);
-                              }
-                        for ( ; y < p->height; y++) {
-                              ushort cell = p->getCell(x+i, y);
-                              q->setCell(x+2*i, y, cell);
-                              q->setCell(x+2*i+1, y, cell);
-                              }
-                        }
-                  }
-            RadonInfo* swap = p;
-            p = q;
-            q = swap;
-            }
-      for (int x = 0; x < p->width; x++) {
-            uint sum = 0;
-            for (int y = 0; y < (p->height-1); y++) {
-                  int delta = p->getCell(x, y) - p->getCell(x, y + 1);
-                  sum += delta * delta;
-                  }
-            projection[p->width + sign * x - 1] = sum;
-            }
-      }
-
-//---------------------------------------------------------
-//   radonTransform
-//---------------------------------------------------------
-
-void OmrPage::radonTransform(ulong* projection, int w, int n, const QRect& r)
-      {
-      int h = r.height();
-      RadonInfo* src = new RadonInfo(w, h);
-      RadonInfo* dst = new RadonInfo(w, h);
-
-      src->reset();
-      for (int y = 0; y < h; y++) {
-            int i = n;
-            const uchar* p = (const uchar*)scanLine(r.y() + y);
-            for (int x = 0; x < n; ++x)
-                  src->setCell(--i, y, Omr::bitsSetTable[*p++]);
-            }
-      radonProjection(src, dst, -1, projection);
-
-      src->reset();
-      for (int y = 0; y < h; y++) {
-            const uchar* p = (const uchar*)scanLine(r.y() + y);
-            for (int x = 0; x < n; ++x)
-                  src->setCell(x, y, Omr::bitsSetTable[*p++]);
-            }
-      radonProjection(src, dst, 1, projection);
-
-      delete dst;
-      delete src;
-      }
-
-//---------------------------------------------------------
-//   skew
-//    compute image skew angle
-//---------------------------------------------------------
-
-double OmrPage::skew(const QRect& r)
-      {
-//      Benchmark bench("imageSkew");
-
-      int nn    = wordsPerLine() * 4;
-      int width = 1;
-      for (; width < nn; width <<= 1)
-            ;
-      int n = 2 * width - 1;
-
-      ulong* projection = new ulong[n];
-      radonTransform(projection, width, nn, r);
-      uint max_projection = 0;
-      int skew            = 0;
-      for (int i = 0; i < n; i++) {
-            if (projection[i] > max_projection) {
-                  skew = i - width + 1;
-                  max_projection = projection[i];
-                  }
-            }
-      delete[] projection;
-      return RadiansToDegrees(-atan((double) skew/width/8));
-      }
-}
-
diff --git a/omr/utils.cpp b/omr/utils.cpp
deleted file mode 100644 (file)
index 75a4c79..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-//=============================================================================
-//  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.
-//=============================================================================
-
-#include "utils.h"
-#include "omr.h"
-
-namespace Ms {
-
-char Omr::bitsSetTable[256];
-
-//---------------------------------------------------------
-//   initUtils
-//---------------------------------------------------------
-
-void Omr::initUtils()
-      {
-      static bool initialized = false;
-      if (initialized)
-            return;
-      initialized = true;
-      //
-      // populate the bitsSetTable
-      bitsSetTable[0] = 0;
-      for (int i = 1; i < 256; i++)
-            bitsSetTable[i] = (i & 1) + bitsSetTable[i/2];
-      }
-
-//---------------------------------------------------------
-//   mean
-//    Compute the arithmetic mean of a dataset using the
-//    recurrence relation
-//    mean_(n) = mean(n-1) + (data[n] - mean(n-1))/(n+1)
-//---------------------------------------------------------
-
-double mean(const double data[], int size)
-      {
-      long double mean = 0;
-
-      for (int i = 0; i < size; i++)
-            mean += (data[i] - mean) / (i + 1);
-      return mean;
-      }
-
-//---------------------------------------------------------
-//   covariance
-//---------------------------------------------------------
-
-double covariance(const double data1[],
-   const double data2[], int n, double mean1, double mean2)
-      {
-      long double covariance = 0.0;
-
-      /* find the sum of the squares */
-      for (size_t i = 0; i < (size_t)n; i++) {
-            const long double delta1 = (data1[i] - mean1);
-            const long double delta2 = (data2[i] - mean2);
-            covariance += (delta1 * delta2 - covariance) / (i + 1);
-            }
-      return covariance;
-      }
-
-double covariance(const double data1[], const double data2[], int n)
-      {
-      double mean1 = mean(data1, n);
-      double mean2 = mean(data2, n);
-
-      return covariance(data1, data2, n, mean1, mean2);
-      }
-}
-
diff --git a/omr/utils.h b/omr/utils.h
deleted file mode 100644 (file)
index dfbefb4..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-//=============================================================================
-//  MusE Reader
-//  Linux 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 __UTILS_H__
-#define __UTILS_H__
-
-namespace Ms {
-
-extern double curTime();
-
-//---------------------------------------------------------
-//   Benchmark
-//---------------------------------------------------------
-
-class Benchmark {
-      double startTime;
-      const char* msg;
-
-   public:
-      Benchmark(const char* p) {
-            msg = p;
-            startTime = curTime();
-            printf("===%s start\n", msg);
-            }
-      ~Benchmark() {
-            double elapsed = curTime() - startTime;
-            printf("===%s elapsed %f\n", msg, elapsed);
-            }
-      };
-
-extern double covariance(const double data1[], const double data2[], int n);
-
-}
-
-#endif
-
diff --git a/rdoc/.gitignore b/rdoc/.gitignore
deleted file mode 100644 (file)
index 2daf75c..0000000
+++ /dev/null
@@ -1,2 +0,0 @@
-*.qch
-
diff --git a/rdoc/CMakeLists.txt b/rdoc/CMakeLists.txt
deleted file mode 100644 (file)
index 0ac7a8a..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-#=============================================================================
-#  MuseScore
-#  Music Composition & Notation
-#
-#  Copyright (C) 2011 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
-#  as published by the Free Software Foundation and appearing in
-#  the file LICENSE.GPL
-#=============================================================================
-
-add_custom_target(referenceDocumentation
-      ALL
-      DEPENDS en/doc.html de/doc.html en/doc.qhp de/doc.qhp
-      )
-
-add_custom_command(TARGET referenceDocumentation
-      POST_BUILD
-      COMMAND Qt5::qcollectiongenerator ${PROJECT_SOURCE_DIR}/rdoc/en/doc.qhcp -o doc_en.qhc
-      COMMAND Qt5::qcollectiongenerator ${PROJECT_SOURCE_DIR}/rdoc/de/doc.qhcp -o doc_de.qhc
-      )
-
-install(FILES
-      ${PROJECT_BINARY_DIR}/rdoc/doc_en.qhc
-      ${PROJECT_BINARY_DIR}/rdoc/doc_de.qhc
-  DESTINATION ${Mscore_SHARE_NAME}${Mscore_INSTALL_NAME}manual)
-
diff --git a/rdoc/de/doc.html b/rdoc/de/doc.html
deleted file mode 100644 (file)
index bcc8af0..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-<html>
-
-<body>
-Hallo MuseScore!
-</body>
-
-
-
-</html>
diff --git a/rdoc/de/doc.qhcp b/rdoc/de/doc.qhcp
deleted file mode 100644 (file)
index 59195b8..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<QHelpCollectionProject version="1.0">
-    <docFiles>
-        <generate>
-            <file>
-                  <input>doc.qhp</input>
-                  <output>doc.qch</output>
-            </file>
-        </generate>
-        <register>
-            <file>doc.qch</file>
-        </register>
-    </docFiles>
-</QHelpCollectionProject>
-
diff --git a/rdoc/de/doc.qhp b/rdoc/de/doc.qhp
deleted file mode 100644 (file)
index fe20eda..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<QtHelpProject version="1.0">
-    <namespace>musescore.com.musescore.2.0</namespace>
-    <virtualFolder>doc</virtualFolder>
-    <customFilter name="de">
-        <filterAttribute>MuseScore</filterAttribute>
-    </customFilter>
-
-    <filterSection>
-        <filterAttribute>MuseScore</filterAttribute>
-        <toc>
-            <section title="My Application Manual" ref="index.html">
-                <section title="Chapter 1" ref="doc.html#chapter1"/>
-                <section title="Chapter 2" ref="doc.html#chapter2"/>
-                <section title="Chapter 3" ref="doc.html#chapter3"/>
-            </section>
-        </toc>
-        <keywords>
-            <keyword id="manual" ref="doc.html"/>
-            <keyword name="bar" ref="doc.html#bar"/>
-            <keyword id="MuseScore::foobar" ref="doc.html#foobar"/>
-            <keyword id="mops" ref="doc.html#foobar"/>
-            <keyword id="klops" ref="doc.html#foobar"/>
-        </keywords>
-        <files>
-            <file>doc.html</file>
-        </files>
-    </filterSection>
-
-</QtHelpProject>
diff --git a/rdoc/en/doc.html b/rdoc/en/doc.html
deleted file mode 100644 (file)
index 18955a9..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-<html>
-
-<body>
-Hello MuseScore!
-</body>
-
-
-
-</html>
diff --git a/rdoc/en/doc.qhcp b/rdoc/en/doc.qhcp
deleted file mode 100644 (file)
index 59195b8..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<QHelpCollectionProject version="1.0">
-    <docFiles>
-        <generate>
-            <file>
-                  <input>doc.qhp</input>
-                  <output>doc.qch</output>
-            </file>
-        </generate>
-        <register>
-            <file>doc.qch</file>
-        </register>
-    </docFiles>
-</QHelpCollectionProject>
-
diff --git a/rdoc/en/doc.qhp b/rdoc/en/doc.qhp
deleted file mode 100644 (file)
index 99bf8bb..0000000
+++ /dev/null
@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<QtHelpProject version="1.0">
-    <namespace>musescore.com.musescore.2.0</namespace>
-    <virtualFolder>doc</virtualFolder>
-    <customFilter name="en">
-        <filterAttribute>MuseScore</filterAttribute>
-    </customFilter>
-
-    <filterSection>
-        <filterAttribute>MuseScore</filterAttribute>
-        <toc>
-            <section title="My Application Manual" ref="index.html">
-                <section title="Chapter 1" ref="doc.html#chapter1"/>
-                <section title="Chapter 2" ref="doc.html#chapter2"/>
-                <section title="Chapter 3" ref="doc.html#chapter3"/>
-            </section>
-        </toc>
-        <keywords>
-            <keyword id="manual"            ref="doc.html"/>
-            <keyword id="bar"               ref="doc.html#bar"/>
-            <keyword id="MuseScore::foobar" ref="doc.html#foobar"/>
-            <keyword id="note"              ref="note.html"/>
-        </keywords>
-        <files>
-            <file>doc.html</file>
-            <file>note.html</file>
-        </files>
-    </filterSection>
-
-</QtHelpProject>
diff --git a/rdoc/en/note.html b/rdoc/en/note.html
deleted file mode 100644 (file)
index 9974ed2..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-<html>
-<title>Note</title>
-<body>
-<h2>Note</h2>
-This is a note.
-</body>
-</html>