def render_prediction_labels(labels, img=None):
from shared.pcgtscanvas import PcGtsCanvas
out = np.zeros(labels.shape + (3, ), dtype=np.uint8)
if img is not None:
out = np.stack((img, ) * 3, axis=-1).astype(int)
def draw(i, c):
return np.kron((labels == i), c).reshape(out.shape).astype(int)
for i, c in [
(SymbolLabel.BACKGROUND, (255, 255, 255)),
(SymbolLabel.NOTE_START, (255, 0, 0)),
(SymbolLabel.NOTE_GAPPED, (255, 120, 120)),
(SymbolLabel.NOTE_LOOPED, (120, 0, 0)),
(SymbolLabel.CLEF_C, (120, 255, 120)),
(SymbolLabel.CLEF_F, (0, 255, 0)),
(SymbolLabel.ACCID_NATURAL, (0, 0, 255)),
(SymbolLabel.ACCID_SHARP, (50, 50, 255)),
(SymbolLabel.ACCID_FLAT, (0, 0, 120)),
]:
c = PcGtsCanvas.color_for_music_symbol(i.to_music_symbol(),
inverted=True,
default_color=(255, 255, 255))
if c != (0, 0, 0):
out[:, :, 0] = np.where(labels == i, c[0], out[:, :, 0])
out[:, :, 1] = np.where(labels == i, c[1], out[:, :, 1])
out[:, :, 2] = np.where(labels == i, c[2], out[:, :, 2])
# if img is not None:
# out = (out.astype(float) * np.stack((img,) * 3, axis=-1) / 255).astype(np.uint8)
return out.clip(0, 255).astype(np.uint8)
def _predict(
self,
pcgts_files: List[PcGts],
callback: Optional[PredictionCallback] = None
) -> Generator[SingleLinePredictionResult, None, None]:
dataset = SymbolDetectionDataset(pcgts_files, self.dataset_params)
for p in self.predictor.predict(
dataset.to_page_segmentation_dataset()):
m: RegionLineMaskData = p.data.user_data
symbols = SingleLinePredictionResult(
self.exract_symbols(p.probabilities, p.labels, m, dataset),
p.data.user_data)
if False:
from shared.pcgtscanvas import PcGtsCanvas
canvas = PcGtsCanvas(m.operation.page,
PageScaleReference.NORMALIZED_X2)
for s in symbols.symbols:
s.coord = m.operation.music_line.staff_lines.compute_coord_by_position_in_staff(
s.coord.x, s.position_in_staff)
canvas.draw(symbols.symbols, invert=True)
canvas.show()
if False:
import matplotlib.pyplot as plt
f, ax = plt.subplots(5, 1, sharey='all', sharex='all')
ax[0].imshow(p.probabilities[:, :, 0], vmin=0.0, vmax=1.0)
ax[1].imshow(p.data.image, vmin=0.0, vmax=255)
ax[2].imshow(render_prediction_labels(p.labels, p.data.image))
ax[3].imshow(
(p.probabilities[:, :, 0] <= 0.8) *
(1 + np.argmax(p.probabilities[:, :, 1:], axis=-1)))
ax[4].imshow(
render_prediction_labels(p.data.mask, p.data.image))
plt.show()
yield symbols
def predict(self, pages: List[DatabasePage], callback: Optional[PredictionCallback] = None) -> AlgorithmPredictionResultGenerator:
pcgts_files = [p.pcgts() for p in pages]
page_results = [PredictionResult(pcgts, pcgts.page.location, [], []) for pcgts in pcgts_files]
for line_results in self._predict(pcgts_files, callback):
if isinstance(line_results, SingleLinePredictionResult):
page_result = [p for p in page_results if p.pcgts == line_results.line.operation.pcgts][0]
page_result.music_lines.append(line_results)
else:
if len(line_results) == 2:
line_results_symbols = line_results[0]
page_result = [p for p in page_results if p.pcgts == line_results_symbols.line.operation.pcgts][0]
page_result.music_lines.append(line_results_symbols)
line_results_symbols = line_results[1]
page_result = [p for p in page_results if p.pcgts == line_results_symbols.line.operation.pcgts][0]
page_result.debug_music_lines.append(line_results_symbols)
for page_result in page_results:
if False:
from .evaluator import SymbolDetectionEvaluator, Codec
evaluator = SymbolDetectionEvaluator()
canvas = PcGtsCanvas(page_result.music_lines[0].line.operation.page, PageScaleReference.NORMALIZED_X2)
for i, ml in enumerate(page_result.music_lines):
canvas.draw(ml.line.operation.music_line.staff_lines)
for s in ml.symbols:
canvas.draw_music_symbol_position_in_line(ml.line.operation.music_line.staff_lines, s, color=(255, 255, 0), thickness=2)
for s in ml.line.operation.music_line.symbols:
canvas.draw_music_symbol_position_in_line(ml.line.operation.music_line.staff_lines, s, color=(0,0, 255))
c = Codec()
gt = c.symbols_to_label_sequence(ml.line.operation.music_line.symbols, False)
pred = c.symbols_to_label_sequence(ml.symbols, False)
r = c.compute_sequence_diffs(gt, pred)
print(i + 1, r)
print(i + 1, evaluator.evaluate([ml.line.operation.music_line.symbols], [ml.symbols])[-3])
canvas.show()
yield page_result
for i, p in enumerate(pages):
pcgts = PcGts.from_file(p.file('pcgts'))
dataset = SymbolDetectionDataset([pcgts], params)
calamari_dataset = dataset.to_calamari_dataset(train=True)
for a, (sample, out) in enumerate(
zip(calamari_dataset.samples(), dataset.load())):
img, region, mask = out.line_image, out.region, out.mask
img = sample['image'].transpose()
ax[a, i].imshow(img)
elif at == AlgorithmTypes.SYMBOLS_PC:
page = pages[0]
pcgts = PcGts.from_file(page.file('pcgts'))
dataset = SymbolDetectionDataset([pcgts], params)
ps_dataset = dataset.to_page_segmentation_dataset()
canvas_ol = PcGtsCanvas(
pcgts.page, scale_reference=PageScaleReference.NORMALIZED_X2)
for ml in pcgts.page.all_music_lines():
canvas_ol.draw(ml.symbols, scale=1.5, invert=True)
canvas_mask = PcGtsCanvas(
pcgts.page,
scale_reference=PageScaleReference.NORMALIZED_X2,
no_background=True)
for ml in pcgts.page.all_music_lines():
canvas_mask.draw(ml.symbols, scale=1.5, invert=True)
canvas = PcGtsCanvas(pcgts.page,
scale_reference=PageScaleReference.NORMALIZED_X2,
file='gray')
PcGtsCanvas.show_all([canvas_ol, canvas_mask, canvas], hor=False)
f, ax = plt.subplots(len(ps_dataset.data),
3,
sharex='all',
np.random.seed(1)
if False:
train_pcgts, val_pcgts = dataset_by_locked_pages(
0.8,
[LockState(Locks.SYMBOLS, True),
LockState(Locks.LAYOUT, True)],
True,
[
# DatabaseBook('Graduel_Part_1'),
# DatabaseBook('Graduel_Part_2'),
# DatabaseBook('Graduel_Part_3'),
])
book = DatabaseBook('Gothic_Test')
meta = Step.meta(AlgorithmTypes.OCR_CALAMARI)
# model = meta.newest_model_for_book(book)
model = Model(
MetaId.from_custom_path(
BASE_DIR +
'/internal_storage/pretrained_models/text_calamari/fraktur_historical',
meta.type()))
settings = AlgorithmPredictorSettings(model=model, )
pred = meta.create_predictor(settings)
ps: List[PredictionResult] = list(pred.predict(book.pages()[0:1]))
for i, p in enumerate(ps):
canvas = PcGtsCanvas(p.pcgts.page,
p.text_lines[0].line.operation.scale_reference)
for j, s in enumerate(p.text_lines):
canvas.draw(s)
canvas.show()
dataset.local_to_global_pos(Point((pos.global_start + pos.global_end) / 2, 40), m.operation.params).x,
m.operation.scale_reference
))
for pos in p.positions]
return CalamariSequence.to_symbols(dataset.params.calamari_codec, sentence, m.operation.music_line.staff_lines)
if __name__ == '__main__':
import random
from omr.dataset.datafiles import dataset_by_locked_pages, LockState
from shared.pcgtscanvas import PcGtsCanvas, PageScaleReference
random.seed(1)
np.random.seed(1)
b = DatabaseBook('Graduel_Fully_Annotated')
train_pcgts, val_pcgts = dataset_by_locked_pages(0.8, [LockState(Locks.STAFF_LINES, True), LockState(Locks.LAYOUT, True)], True, [
DatabaseBook('Graduel_Part_1'),
DatabaseBook('Graduel_Part_2'),
DatabaseBook('Graduel_Part_3'),
])
pred = OMRPredictor(AlgorithmPredictorSettings(
model=Meta.best_model_for_book(b),
))
ps = list(pred.predict([p.page.location for p in val_pcgts[7:8]]))
for p in ps:
p: PredictionResult = p
canvas = PcGtsCanvas(p.pcgts.page, PageScaleReference.NORMALIZED_X2)
for sp in p.music_lines:
canvas.draw(sp.symbols)
canvas.show()
from shared.pcgtscanvas import PcGtsCanvas
from omr.dataset.datafiles import dataset_by_locked_pages, LockState
random.seed(1)
np.random.seed(1)
if False:
train_pcgts, val_pcgts = dataset_by_locked_pages(
0.8,
[LockState(Locks.SYMBOLS, True),
LockState(Locks.LAYOUT, True)],
True,
[
# DatabaseBook('Graduel_Part_1'),
# DatabaseBook('Graduel_Part_2'),
# DatabaseBook('Graduel_Part_3'),
])
book = DatabaseBook('Paper_New_York')
meta = Step.meta(AlgorithmTypes.SYLLABLES_FROM_TEXT)
model = meta.best_model_for_book(book)
settings = AlgorithmPredictorSettings(model=model, )
pred = meta.create_predictor(settings)
ps: List[PredictionResult] = list(pred.predict(book.pages()[:1]))
for i, p in enumerate(ps):
pmr = p.page_match_result
canvas = PcGtsCanvas(pmr.pcgts.page, PageScaleReference.NORMALIZED_X2)
canvas.draw(pmr.text_prediction_result.text_lines[4],
color=(25, 150, 25),
background=True)
# canvas.draw(pmr.match_results)
# canvas.draw(p.annotations)
canvas.show()
os.environ['DJANGO_SETTINGS_MODULE'] = 'ommr4all.settings'
django.setup()
from ommr4all.settings import BASE_DIR
import random
import matplotlib.pyplot as plt
from shared.pcgtscanvas import PcGtsCanvas
from omr.dataset.datafiles import dataset_by_locked_pages, LockState
from database.file_formats.pcgts import PageScaleReference
random.seed(1)
np.random.seed(1)
if False:
train_pcgts, val_pcgts = dataset_by_locked_pages(0.8, [LockState(Locks.SYMBOLS, True), LockState(Locks.LAYOUT, True)], True, [
# DatabaseBook('Graduel_Part_1'),
# DatabaseBook('Graduel_Part_2'),
# DatabaseBook('Graduel_Part_3'),
])
book = DatabaseBook('Paper_New_York')
meta = Step.meta(AlgorithmTypes.SYLLABLES_IN_ORDER)
model = meta.best_model_for_book(book)
settings = AlgorithmPredictorSettings(
model=model,
)
pred = meta.create_predictor(settings)
ps: List[PredictionResult] = list(pred.predict(book.pages()[:1]))
for i, p in enumerate(ps):
pmr = p.page_match_result
canvas = PcGtsCanvas(pmr.pcgts.page, PageScaleReference.NORMALIZED_X2)
canvas.draw(pmr.match_results)
canvas.draw(p.annotations)
canvas.show()
# page = book.page('Graduel_de_leglise_de_Nevers_520')
# page = book.page('Graduel_de_leglise_de_Nevers_513')
pages = [page]
settings = AlgorithmPredictorSettings(
Meta.best_model_for_book(book),
book.get_meta().algorithm_predictor_params(
BasicStaffLinePredictor.meta().type()),
#["/home/wick/Documents/Projects/ommr4all-deploy/modules/ommr4all-server/internal_storage/default_models/french14/pc_staff_lines/model"],
#["/home/wick/Documents/Projects/ommr4all-deploy/modules/ommr4all-server/models_out/all/line_detection_4/best"],
# ["/home/wick/Documents/Projects/ommr4all-deploy/modules/ommr4all-server/storage/Graduel/pc_staff_lines/model"],
# ["/home/wick/Downloads/line_detection_0/best"],
)
detector = BasicStaffLinePredictor(settings)
for prediction in detector.predict(pages):
canvas = PcGtsCanvas(prediction.line.operation.page,
PageScaleReference.NORMALIZED)
def scale(p):
return prediction.line.operation.page.page_to_image_scale(
p, ref=PageScaleReference.NORMALIZED)
f, ax = plt.subplots(1, 3)
staffs = prediction.music_lines_local
data = prediction.line
img = np.array(data.line_image, dtype=np.uint8)
ax[0].imshow(255 - img, cmap='gray')
[s.draw(img, color=255, thickness=1, scale=scale) for s in staffs]
b = np.zeros(img.shape)
[s.draw(b, color=255, thickness=1, scale=scale) for s in staffs]
ax[1].imshow(img)
ax[2].imshow(b, cmap='gray')