{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "%pylab inline\n", "from pyannote.core import notebook" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Segment (`pyannote.core.segment.Segment`)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "from pyannote.core import Segment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`Segment`** instances are used to describe temporal fragments (e.g. of an audio file)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# start time in seconds\n", "s = 1.\n", "# end time in seconds\n", "e = 9.\n", "segment = Segment(start=s, end=e)\n", "segment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**`Segment`** instances are nothing more than 2-tuples augmented with several useful methods and properties." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "from 1.0 to 9.0\n" ] } ], "source": [ "start, end = segment\n", "print('from {} to {}'.format(start, end))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Segment [ 00:00:01.000 --> 00:00:09.000] ends at 9 seconds.\n", "Its duration is 8 seconds.\n", "Its middle stands as 5 seconds.\n" ] } ], "source": [ "print('Segment %s ends at %g seconds.' % (segment, segment.end))\n", "print('Its duration is %g seconds.' % (segment.duration))\n", "print('Its middle stands as %g seconds.' % (segment.middle))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Intersection" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Segment [ 00:00:01.000 --> 00:00:09.000] intersects other segment [ 00:00:04.000 --> 00:00:13.000].\n", "Their intersection is [ 00:00:04.000 --> 00:00:09.000].\n" ] } ], "source": [ "other_segment = Segment(4, 13)\n", "if segment.intersects(other_segment):\n", " print('Segment %s intersects other segment %s.' % (segment, other_segment))\n", " intersection = segment & other_segment\n", " print('Their intersection is %s.' % (str(intersection)))" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "notebook.crop = Segment(0, 15)\n", "segment" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABjCAYAAAAhK/2kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAImklEQVR4nO3da6hldRkG8OfNKUq7N2blSEeim0Q3JrGE6GJhFzLoS1FR1JegO0F0gfRTCEUXKIqwMkiMsEIJKsWivnRxxkpLs/tlzNKILhZdzLcPe0fD6OCZ4z5n/dee3w8Oe6119hmegZez13n2Wv9d3R0AAAAAxnKXqQMAAAAAcFtKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQLuO5Mm7d+/ujY2NbYoCAAAAcPTZv3//H7r7+EOPH1Fps7GxkX379q0uFQAAAMBRrqp+dXvH3R4FAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gBr45xzzpk6AgAARwHnneyU6u5NP3nv3r29b9++bYwDsHVVlSP5nQYAAFvhvJNVq6r93b330OOutAEAAAAY0K6pAwCsUlVNHQEAAGAllDbAWnGZKgAA280bhewUt0cBa+Pss8+eOgIAAEcB553sFAsRAwAAAEzIQsQAAAAAM6K0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEDV3Zt/ctVfk1y3fXE4Cu1O8oepQ7A2zBOrZqZYNTPFqpkpVs1MsUrmafMe2t3HH3pw1xH+I9d1994VBYJU1T4zxaqYJ1bNTLFqZopVM1OsmplilczTnef2KAAAAIABKW0AAAAABnSkpc3HtiUFRzMzxSqZJ1bNTLFqZopVM1OsmplilczTnXRECxEDAAAAsDPcHgUAAAAwIKUNAAAAwIA2VdpU1ZlVdV1V/bSq3rbdoVhvVXVSVX2tqq6pqh9W1RunzsR6qKpjquq7VfXFqbMwf1V136q6qKp+VFXXVtWTp87EfFXVm5eveT+oqgur6u5TZ2J+quoTVXVjVf3goGP3r6rLquony8f7TZmR+TjMPL1n+bp3VVV9oaruO2VG5uX2Zuqg772lqrqqdk+Rbc7usLSpqmOSfDjJc5KckuQlVXXKdgdjrd2S5C3dfUqS05K81kyxIm9Mcu3UIVgbH0zy5e5+VJLHxWyxRVV1YpI3JNnb3Y9JckySF0+bipk6P8mZhxx7W5LLu/vhSS5f7sNmnJ/bztNlSR7T3Y9N8uMkb9/pUMza+bntTKWqTkry7CS/3ulA62AzV9qcmuSn3f3z7v5Xks8kOWt7Y7HOuvuG7r5yuf3XLP4QOnHaVMxdVe1J8rwk502dhfmrqvskeWqSjydJd/+ru/80bSpmbleSe1TVriTHJvntxHmYoe7+RpI/HnL4rCSfWm5/KskLdzQUs3V789Tdl3b3LcvdbyXZs+PBmK3D/I5KkvcneWsSn4K0BZspbU5M8puD9g/EH9isSFVtJHlCkm9Pm4Q18IEsXgxunToIa+HkJDcl+eTylrvzquq4qUMxT919fZL3ZvEO4w1J/tzdl06bijVyQnffsNz+XZITpgzDWnlVki9NHYJ5q6qzklzf3d+fOstcWYiYyVTVPZN8LsmbuvsvU+dhvqrq+Ulu7O79U2dhbexK8sQkH+nuJyT5W9xywBYt1xg5K4sy8CFJjquql02binXU3R3vZLMCVfXOLJY0uGDqLMxXVR2b5B1J3jV1ljnbTGlzfZKTDtrfszwGW1ZVd82isLmguz8/dR5m7/QkL6iqX2ZxC+czqurT00Zi5g4kOdDd/7sK8KIsShzYijOS/KK7b+rufyf5fJKnTJyJ9fH7qnpwkiwfb5w4DzNXVa9M8vwkL10WgbBVD8viDYvvL8/T9yS5sqoeNGmqmdlMaXNFkodX1clVdbcsFs67ZHtjsc6qqrJYJ+La7n7f1HmYv+5+e3fv6e6NLH5HfbW7vYvNlnX375L8pqoeuTz0zCTXTBiJeft1ktOq6tjla+AzY2FrVueSJK9Ybr8iycUTZmHmqurMLG43f0F3/33qPMxbd1/d3Q/s7o3lefqBJE9cnmexSXdY2iwXonpdkq9kcYLx2e7+4XYHY62dnuTlWVwN8b3l13OnDgVwiNcnuaCqrkry+CTvnjgPM7W8YuuiJFcmuTqL86+PTRqKWaqqC5N8M8kjq+pAVb06yblJnlVVP8niqq5zp8zIfBxmnj6U5F5JLlueo3900pDMymFmijupXPEGAAAAMB4LEQMAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxo19QBAADuSFU9IMnly90HJflPkpuW+3/v7qdMEgwAYBv5yG8AYFaq6pwkN3f3e6fOAgCwndweBQDMWlXdvHx8WlV9vaourqqfV9W5VfXSqvpOVV1dVQ9bPu/4qvpcVV2x/Dp92v8BAMDtU9oAAOvkcUlek+TRSV6e5BHdfWqS85K8fvmcDyZ5f3c/KcmLlt8DABiONW0AgHVyRXffkCRV9bMkly6PX53k6cvtM5KcUlX/+5l7V9U9u/vmHU0KAHAHlDYAwDr550Hbtx60f2v+f95zlySndfc/djIYAMCRcnsUAHC0uTT/v1UqVfX4CbMAAByW0gYAONq8Icneqrqqqq7JYg0cAIDh+MhvAAAAgAG50gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAb0X7Ut2i96zfc6AAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "other_segment" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABjCAYAAAAhK/2kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAImElEQVR4nO3da6hldRkG8OfNKUq7N2blSEeim0Q3JjGFqKywC03Ql6KiqC9BaUUQWZB+CqHIgqIIK4OkCCuKoFIs6ksXZ6y0NLtnY5ZGdDHpYr592FscRgfPjPvM+q89vx8czlrr7DM8Ay97r/Pstf67ujsAAAAAjOVeUwcAAAAA4M6UNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgLYdzIO3b9/eGxsbWxQFAAAA4MizZ8+eP3f3sfsfP6jSZmNjI7t3715dKgAAAIAjXFX97q6Ouz0KAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAHWxrnnnjt1BABWwPM5ACxUd2/6wTt37uzdu3dvYRyAQ1dVOZjnNADG5PkcgCNNVe3p7p37H3elDQAAAMCAtk0dAGCVqmrqCAAAACuhtAHWisvpAeZPAQ8AC26PAtbGOeecM3UEAFbA8zkALFiIGAAAAGBCFiIGAAAAmBGlDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAAOq7t78g6v+keTarYvDEWh7kj9PHYK1YZ5YNTPFqpkpVs1MsWpmilUyT5v36O4+dv+D2w7yH7m2u3euKBCkqnabKVbFPLFqZopVM1Osmpli1cwUq2Se7jm3RwEAAAAMSGkDAAAAMKCDLW0+viUpOJKZKVbJPLFqZopVM1Osmpli1cwUq2Se7qGDWogYAAAAgMPD7VEAAAAAA1LaAAAAAAxoU6VNVZ1RVddW1S+r6p1bHYr1VlUnVNW3qurqqvppVb1l6kysh6o6qqp+WFVfnToL81dVD66qi6vqZ1V1TVU9c+pMzFdVvW35mveTqvpsVd136kzMT1V9sqpurKqf7HPsoVV1aVX9Yvn9IVNmZD4OME/vW77uXVlVX6qqB0+ZkXm5q5na52dvr6ququ1TZJuzuy1tquqoJB9J8sIkJyV5ZVWdtNXBWGu3Jnl7d5+U5JQkbzJTrMhbklwzdQjWxoeSfL27n5DkKTFbHKKqOj7JWUl2dveTkhyV5BXTpmKmLkxyxn7H3pnksu5+bJLLlvuwGRfmzvN0aZIndfeTk/w8ydmHOxSzdmHuPFOpqhOSvCDJdYc70DrYzJU2Jyf5ZXf/urv/k+RzSXZtbSzWWXff0N1XLLf/kcUfQsdPm4q5q6odSV6c5IKpszB/VfWgJM9K8okk6e7/dPdfp03FzG1Lcr+q2pbk6CR/mDgPM9Td30nyl/0O70ry6eX2p5O87LCGYrbuap66+5LuvnW5+70kOw57MGbrAM9RSXJ+knck8SlIh2Azpc3xSX6/z/7e+AObFamqjSRPS/L9aZOwBj6YxYvBbVMHYS2cmOSmJJ9a3nJ3QVUdM3Uo5qm7r0/y/izeYbwhyd+6+5JpU7FGjuvuG5bbf0xy3JRhWCuvT/K1qUMwb1W1K8n13f3jqbPMlYWImUxV3T/JF5K8tbv/PnUe5quqXpLkxu7eM3UW1sa2JE9P8tHuflqSf8YtBxyi5Roju7IoAx+V5JiqevW0qVhH3d3xTjYrUFXvzmJJg4umzsJ8VdXRSd6V5D1TZ5mzzZQ21yc5YZ/9HctjcMiq6t5ZFDYXdfcXp87D7J2W5KVV9dssbuF8blV9ZtpIzNzeJHu7+/arAC/OosSBQ/G8JL/p7pu6+79Jvpjk1IkzsT7+VFWPTJLl9xsnzsPMVdXrkrwkyauWRSAcqsdk8YbFj5fn6TuSXFFVj5g01cxsprS5PMljq+rEqrpPFgvnfWVrY7HOqqqyWCfimu7+wNR5mL/uPru7d3T3RhbPUd/sbu9ic8i6+49Jfl9Vj18eOj3J1RNGYt6uS3JKVR29fA08PRa2ZnW+kuS1y+3XJvnyhFmYuao6I4vbzV/a3bdMnYd56+6ruvvh3b2xPE/fm+Tpy/MsNuluS5vlQlRvTvKNLE4wPt/dP93qYKy105K8JourIX60/HrR1KEA9nNmkouq6sokT03y3onzMFPLK7YuTnJFkquyOP/6+KShmKWq+myS7yZ5fFXtrao3JDkvyfOr6hdZXNV13pQZmY8DzNOHkzwgyaXLc/SPTRqSWTnATHEPlSveAAAAAMZjIWIAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABbZs6AADA3amqhyW5bLn7iCT/S3LTcv+W7j51kmAAAFvIR34DALNSVecmubm73z91FgCAreT2KABg1qrq5uX3Z1fVt6vqy1X166o6r6peVVU/qKqrquoxy8cdW1VfqKrLl1+nTfs/AAC4a0obAGCdPCXJG5M8Mclrkjyuu09OckGSM5eP+VCS87v7GUlevvwZAMBwrGkDAKyTy7v7hiSpql8luWR5/Kokz1luPy/JSVV1++88sKru3903H9akAAB3Q2kDAKyTf++zfds++7fljvOeeyU5pbv/dTiDAQAcLLdHAQBHmktyx61SqaqnTpgFAOCAlDYAwJHmrCQ7q+rKqro6izVwAACG4yO/AQAAAAbkShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABjQ/wGm0dovkW7s6QAAAABJRU5ErkJggg==\n", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "segment & other_segment" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Those two segments do not intersect.\n" ] } ], "source": [ "other_segment = Segment(13, 20)\n", "if not (segment & other_segment):\n", " print('Those two segments do not intersect.')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "notebook.crop = Segment(0, 30)\n", "segment" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABHIAAABjCAYAAAD3jifBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "other_segment" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Inclusion" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 00:00:05.000 --> 00:00:06.000] in included in [ 00:00:01.000 --> 00:00:09.000]\n" ] } ], "source": [ "other_segment = Segment(5, 6)\n", "if other_segment in segment:\n", " print('%s in included in %s' % (other_segment, segment))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 00:00:01.000 --> 00:00:09.000] does not contain time 23.000000\n" ] } ], "source": [ "t = 23.\n", "if not segment.overlaps(t):\n", " print('%s does not contain time %f' % (segment, t))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Other operations" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Union of [ 00:00:01.000 --> 00:00:09.000] and [ 00:00:10.000 --> 00:00:30.000] is [ 00:00:01.000 --> 00:00:30.000]\n" ] } ], "source": [ "other_segment = Segment(10, 30)\n", "print('Union of %s and %s is %s' % (segment, other_segment, segment | other_segment))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Gap between [ 00:00:01.000 --> 00:00:09.000] and [ 00:00:14.000 --> 00:00:15.000] is [ 00:00:09.000 --> 00:00:14.000]\n" ] } ], "source": [ "other_segment = Segment(14, 15)\n", "print('Gap between %s and %s is %s' % (segment, other_segment, segment ^ other_segment))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# SlidingWindow (`pyannote.core.segment.SlidingWindow`)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "from pyannote.core import SlidingWindow, Timeline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Iteration" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ ", , , , , , , , , ])>" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "notebook.crop = Segment(0, 10)\n", "window = SlidingWindow(start=0.0, step=1.1, duration=2., end=10.)\n", "Timeline(window)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Cropping" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Given an interval, `.crop` can be used to return every position of the sliding window within this interval. " ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAABjCAYAAAD6kFeGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAHnklEQVR4nO3dX6hlZRkG8OfVU5Ta/xErFY6EWUNgxklMISy9MIoMAilKJLoJSi2CsG5mLr2QyosIxCwhMUIFJaIMi7ozz2jkn0kySx0bU4lKizKbt4uzxUGwc3bjOWu+s38/OOy11qxvz3Muvtl7nr3Wt6u7AwAAAMA4jpg6AAAAAADzUegAAAAADEahAwAAADAYhQ4AAADAYBQ6AAAAAINZmufkHTt29PLy8iZFAQAAAFg8e/bsebK7j51nzFyFzvLyclZXV+dLBQAAAMCLqqqH5h3jlisAAACAwSh0AAAAAAaj0AEAAAAYjEIHAAAAYDAKHQAAAIDBKHQAAAAABqPQAQAAABiMQgcAAABgMAodAAAAgMEodAAAAAAGo9ABAAAAGIxCBwAAAGAwCh0AAACAwSh0AAAAAAaj0AEAAAAYjEIHAAAAYDAKHQAAAIDBKHQAAAAABqPQAQAAABiMQgcAAABgMAodAAAAgMEodAAAAAAGo9ABAAAAGIxCB2CT7d69e+oIAMBLxOs6cLio7t7wySsrK726urqJcQC2n6rKPP/WAgCHL6/rwGaoqj3dvTLPGFfoAAAAAAxmaeoAAIugqqaOAAAAbCMKHYAt4NJsANgefEgDHC7ccgWwyXbt2jV1BADgJeJ1HThcWBQZAAAAYEIWRQYAAABYAAodAAAAgMEodAAAAAAGo9ABAAAAGIxCBwAAAGAwCh0AAACAwSh0AAAAAAaj0AEAAAAYjEIHAAAAYDAKHQAAAIDBKHQAAAAABqPQAQAAABiMQgcAAABgMAodAAAAgMEodAAAAAAGo9ABAAAAGIxCBwAAAGAwCh0AAACAwSh0AAAAAAaj0AEAAAAYjEIHAAAAYDAKHQAAAIDBKHQAAAAABlPdvfGTq55Kcv/mxQFexI4kT04dAhaQuQfTMPdgOuYfTOOU7n7VPAOW5vwL7u/ulTnHAIeoqlbNPdh65h5Mw9yD6Zh/MI2qWp13jFuuAAAAAAaj0AEAAAAYzLyFzlWbkgJYj7kH0zD3YBrmHkzH/INpzD335loUGQAAAIDpueUKAAAAYDAKHQAAAIDBbKjQqarzqur+qnqgqi7b7FBAUlUnVtXPquq+qrq3qi6dOhMskqo6sqruqqofTJ0FFklVvbaqbqiq31TV3qp6z9SZYBFU1Rdm7znvqarrq+oVU2eC7aqqrqmqx6vqnoOOvb6qflJVv509vm6951m30KmqI5N8I8kHkuxM8vGq2nko4YENeTbJF7t7Z5IzknzW3IMtdWmSvVOHgAV0ZZIfdffbkpwa8xA2XVUdn+SSJCvd/Y4kRyb52LSpYFv7TpLzXnDssiS3dffJSW6b7f9PG7lC5/QkD3T3g939TJLvJTl/vqzAvLp7f3ffOdt+KmtvaI+fNhUshqo6IckHk1w9dRZYJFX1miTvTfKtJOnuZ7r7L9OmgoWxlOSVVbWU5Kgkf5w4D2xb3f2LJH9+weHzk1w72742yUfWe56NFDrHJ3nkoP198Z9K2FJVtZzktCS3T5sEFsbXk3wpyYGpg8CCOSnJE0m+Pbvl8eqqOnrqULDddfejSa5I8nCS/Un+2t23TpsKFs5x3b1/tv1YkuPWG2BRZDjMVdUxSW5M8vnu/tvUeWC7q6oPJXm8u/dMnQUW0FKSdyX5ZnefluTv2cAl58Chma3VcX7WStU3Jzm6qj45bSpYXN3dSXq98zZS6Dya5MSD9k+YHQM2WVW9LGtlznXdfdPUeWBBnJXkw1X1h6zdZvz+qvrutJFgYexLsq+7n7si9YasFTzA5jo3ye+7+4nu/neSm5KcOXEmWDR/qqo3Jcns8fH1Bmyk0LkjyclVdVJVvTxri2PdckgxgXVVVWVtDYG93f3VqfPAoujuL3f3Cd29nLXXvJ92t08pYQt092NJHqmqU2aHzkly34SRYFE8nOSMqjpq9h70nFiQHLbaLUkumm1flOTm9QYsrXdCdz9bVZ9L8uOsrXZ+TXffeygpgQ05K8mFSe6uql/Njn2lu384YSYA2GwXJ7lu9kHig0k+NXEe2Pa6+/aquiHJnVn7ptW7klw1bSrYvqrq+iRnJ9lRVfuS7EpyeZLvV9WnkzyU5IJ1n2ft1iwAAAAARmFRZAAAAIDBKHQAAAAABqPQAQAAABiMQgcAAABgMAodAAAAgMGs+7XlAABTq6o3JLlttvvGJP9J8sRs/x/dfeYkwQAAJuJrywGAoVTV7iRPd/cVU2cBAJiKW64AgKFV1dOzx7Or6udVdXNVPVhVl1fVJ6rql1V1d1W9ZXbesVV1Y1XdMfs5a9rfAABgfgodAGA7OTXJZ5K8PcmFSd7a3acnuTrJxbNzrkzyte5+d5KPzv4MAGAo1tABALaTO7p7f5JU1e+S3Do7fneS9822z02ys6qeG/Pqqjqmu5/e0qQAAIdAoQMAbCf/Omj7wEH7B/L8+54jkpzR3f/cymAAAC8lt1wBAIvm1jx/+1Wq6p0TZgEA+L8odACARXNJkpWq+nVV3Ze1NXcAAIbia8sBAAAABuMKHQAAAIDBKHQAAAAABqPQAQAAABiMQgcAAABgMAodAAAAgMEodAAAAAAGo9ABAAAAGMx/AYgYd1xUnjgzAAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "interval = Segment(3., 7.5)\n", "interval" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`strict` mode only returns fully contained positions." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ ", , ])>" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "indices = window.crop(interval, mode='strict')\n", "Timeline(window[i] for i in indices)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`loose` mode returns any intersecting position." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ ", , , , , ])>" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "indices = window.crop(interval, mode='loose')\n", "Timeline(window[i] for i in indices)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`center` mode centers first and last position on interval boundaries." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAABjCAYAAAD6kFeGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAIJ0lEQVR4nO3dW6hldR0H8O9Pp6js3kQXDSaimwRlnMISoosPRpFBEEVFRC9B2YUgqpeZxx6ky0MEYTcoijBBiSjDot7MMxZZmlR20yyNqLTo6q+Hs8NBsnN2M/v8/Z/1+cCw116z1p7vPPzO2ed71vrv6u4AAAAAMI/TRgcAAAAAYD0KHQAAAIDJKHQAAAAAJqPQAQAAAJiMQgcAAABgMofWOfjw4cN95MiRDUUBAAAAWJ7jx4//rrsfvc45axU6R44cyfb29nqpAAAAALhXVfWLdc9xyxUAAADAZBQ6AAAAAJNR6AAAAABMRqEDAAAAMBmFDgAAAMBkFDoAAAAAk1HoAAAAAExGoQMAAAAwGYUOAAAAwGQUOgAAAACTUegAAAAATEahAwAAADAZhQ4AAADAZBQ6AAAAAJNR6MCCHTt2bHQEWKRNzp65hjE2NXtmGsYwe8ygunvPB29tbfX29vYG4wD7qaqyztcA4NTY5OyZaxhjU7NnpmEMs8d+q6rj3b21zjmu0AEAAACYzKHRAYCxqmp0BOAUM9dwsJhpAP4bhQ4snEtJYf9t+oczcw37b5NzbaZh/ylSmYFbrmDBjh49OjoCLNImZ89cwxibmj0zDWOYPWZgUWQAAACAgSyKDAAAALAACh0AAACAySh0AAAAACaj0AEAAACYjEIHAAAAYDIKHQAAAIDJKHQAAAAAJqPQAQAAAJiMQgcAAABgMgodAAAAgMkodAAAAAAmo9ABWIBjx46NjgCLtMnZM9cwhtkD7iuqu/d88NbWVm9vb28wDgCbUFVZ5+s9cGpscvbMNYxh9oBNqKrj3b21zjmu0AEAAACYzKHRAQDYH1U1OgJwiplrAFguhQ7AQrg8HPbfpgsXcw37T5EK3Fe45QpgAY4ePTo6AizSJmfPXMMYZg+4r7AoMgAAAMBAFkUGAAAAWACFDgAAAMBkFDoAAAAAk1HoAAAAAExGoQMAAAAwGYUOAAAAwGQUOgAAAACTUegAAAAATEahAwAAADAZhQ4AAADAZBQ6AAAAAJNR6AAAAABMRqEDAAAAMBmFDgAAAMBkqrv3fnDVHUlu3Fwc4F4cTvK70SFggcwejGH2YBzzB2M8tbsfss4Jh9b8B27s7q01zwFOUlVtmz3Yf2YPxjB7MI75gzGqanvdc9xyBQAAADAZhQ4AAADAZNYtdD6+kRTAbswejGH2YAyzB+OYPxhj7dlba1FkAAAAAMZzyxUAAADAZBQ6AAAAAJPZU6FTVRdU1Y1V9ZOqeu+mQwFJVT2hqr5ZVddX1Q+r6h2jM8GSVNXpVfXdqvry6CywJFX18Kq6tKp+VFU3VNXzRmeCJaiqd63ec/6gqj5fVQ8YnQkOqqr6ZFXdVlU/OGHfI6vq61X149XjI3Z7nV0Lnao6PclHk7w0ydlJXltVZ59MeGBP/pnk3d19dpJzk7zV7MG+ekeSG0aHgAX6SJKvdvfTkjwz5hA2rqrOTPL2JFvd/Ywkpyd5zdhUcKB9OskF99j33iRXdfeTk1y1ev4/7eUKnecm+Ul339Tdf0/yhSQXrpcVWFd339rd166278jOG9ozx6aCZaiqs5K8LMklo7PAklTVw5K8IMknkqS7/97dfxibChbjUJIHVtWhJA9K8uvBeeDA6u5vJ/n9PXZfmOQzq+3PJHnlbq+zl0LnzCS/OuH5zfFDJeyrqjqS5JwkV49NAovx4STvSXLX6CCwME9McnuST61uebykqs4YHQoOuu6+JcnFSX6Z5NYkf+zuK8emgsV5THffutr+TZLH7HaCRZHhPq6qHpzkS0ne2d1/Gp0HDrqqenmS27r7+OgssECHkjw7yce6+5wkf84eLjkHTs5qrY4Ls1OqPj7JGVX1+rGpYLm6u5P0bsftpdC5JckTTnh+1mofsGFVdb/slDmf6+7LRueBhTgvySuq6ufZuc34xVX12bGRYDFuTnJzd//nitRLs1PwAJt1fpKfdfft3f2PJJclef7gTLA0v62qxyXJ6vG23U7YS6FzTZInV9UTq+r+2Vkc64qTignsqqoqO2sI3NDdHxydB5aiu9/X3Wd195HsfM/7Rnf7LSXsg+7+TZJfVdVTV7tekuT6gZFgKX6Z5NyqetDqPehLYkFy2G9XJHnjavuNSS7f7YRDux3Q3f+sqrcl+Vp2Vjv/ZHf/8GRSAntyXpI3JLmuqr632vf+7v7KwEwAsGkXJfnc6heJNyV50+A8cOB199VVdWmSa7PzSavfTfLxsang4Kqqzyd5YZLDVXVzkqNJPpDki1X15iS/SPLqXV9n59YsAAAAAGZhUWQAAACAySh0AAAAACaj0AEAAACYjEIHAAAAYDIKHQAAAIDJ7Pqx5QAAo1XVo5JctXr62CT/SnL76vlfuvv5Q4IBAAziY8sBgKlU1bEkd3b3xaOzAACM4pYrAGBqVXXn6vGFVfWtqrq8qm6qqg9U1euq6jtVdV1VPWl13KOr6ktVdc3qz3lj/wcAAOtT6AAAB8kzk7wlydOTvCHJU7r7uUkuSXLR6piPJPlQdz8nyatWfwcAMBVr6AAAB8k13X1rklTVT5Ncudp/XZIXrbbPT3J2Vf3nnIdW1YO7+859TQoAcBIUOgDAQfK3E7bvOuH5Xbn7fc9pSc7t7r/uZzAAgFPJLVcAwNJcmbtvv0pVPWtgFgCA/4tCBwBYmrcn2aqq71fV9dlZcwcAYCo+thwAAABgMq7QAQAAAJiMQgcAAABgMgodAAAAgMkodAAAAAAmo9ABAAAAmIxCBwAAAGAyCh0AAACAyfwbEJnJTLHYR8IAAAAASUVORK5CYII=\n", "text/plain": [ ", , , , ])>" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "indices = window.crop(interval, mode='center')\n", "Timeline(window[i] for i in indices)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Need help?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can always try the following... \n", "Who knows? It might give you the information you are looking for!" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on class Segment in module pyannote.core.segment:\n", "\n", "class Segment(Segment)\n", " | Temporal interval defined by its `start` and `end` times.\n", " | \n", " | Multiple segment operators are available -- including intersection (&),\n", " | inclusion (in), emptiness test, start/end time shifting (+, -, >>, <<).\n", " | They are illustrated in **Examples** section.\n", " | \n", " | Comparison of two segments is also available (==, !=, <, <=, >, >=).\n", " | Two segments are equal iff they have identical start and end times.\n", " | Segment S is smaller than segment T iff S.start < T.start or if they have\n", " | the same start time and S.end < T.start.\n", " | \n", " | Parameters\n", " | ----------\n", " | start, end : float\n", " | `start` and `end` times, in seconds.\n", " | \n", " | Returns\n", " | -------\n", " | segment : Segment\n", " | New segment with `start` and `end` times.\n", " | \n", " | Examples\n", " | --------\n", " | Create a new temporal interval between 00:13.000 and 00:37.000.\n", " | \n", " | >>> segment = Segment(start=13., end=37)\n", " | >>> print segment\n", " | [13.000 --> 37.000]\n", " | \n", " | Inclusion, intersection, union & gap\n", " | \n", " | >>> s1 = Segment(1, 2)\n", " | >>> s2 = Segment(0, 3)\n", " | >>> if s1 in s2:\n", " | ... print \"Segment %s is included in segment %s.\" % (s1, s2)\n", " | Segment [1.000 --> 2.000] is included in segment [0.000 --> 3.000].\n", " | >>> s3 = Segment(2, 5)\n", " | >>> print s1 & s3\n", " | ∅\n", " | >>> print s2 & s3\n", " | [2.000 --> 3.000]\n", " | >>> print s2 | s3\n", " | [0.000 --> 5.000]\n", " | >>> print s1 ^ Segment(5, 7)\n", " | [2.000 --> 5.000]\n", " | \n", " | Test whether segment is empty or not.\n", " | \n", " | >>> if not Segment(10, 10):\n", " | ... print \"Segment is empty.\"\n", " | Segment is empty.\n", " | \n", " | Comparison\n", " | \n", " | >>> s1 = Segment(1, 3)\n", " | >>> s2 = Segment(1, 3)\n", " | >>> s3 = Segment(2, 6)\n", " | >>> s4 = Segment(1, 2)\n", " | >>> for s in sorted([s1, s2, s3, s4]):\n", " | ... print s\n", " | [1.000 --> 2.000]\n", " | [1.000 --> 3.000]\n", " | [1.000 --> 3.000]\n", " | [2.000 --> 6.000]\n", " | \n", " | Method resolution order:\n", " | Segment\n", " | Segment\n", " | __builtin__.tuple\n", " | __builtin__.object\n", " | \n", " | Methods defined here:\n", " | \n", " | __and__(self, other)\n", " | Use the expression 'segment & other'\n", " | \n", " | Returns\n", " | -------\n", " | segment : Segment\n", " | Intersection of the two segments\n", " | \n", " | __bool__(self)\n", " | Use the expression 'if segment'\n", " | \n", " | Returns\n", " | -------\n", " | valid : bool\n", " | False is segment is empty, True otherwise.\n", " | \n", " | __contains__(self, other)\n", " | Use the expression 'other in segment'\n", " | \n", " | Returns\n", " | -------\n", " | contains : bool\n", " | True if other segment is fully included, False otherwise\n", " | \n", " | __iter__(self)\n", " | Makes sure tuple(segment) is a tuple of float\n", " | \n", " | __nonzero__(self)\n", " | \n", " | __or__(self, other)\n", " | Use the expression 'segment | other'\n", " | \n", " | Returns\n", " | -------\n", " | segment : Segment\n", " | Shortest segment that contains both segments\n", " | \n", " | __repr__(self)\n", " | \n", " | __str__(self)\n", " | Use the expression str(segment)\n", " | \n", " | __xor__(self, other)\n", " | Use the expression 'segment ^ other'\n", " | \n", " | Returns\n", " | -------\n", " | segment : Segment\n", " | Gap between the two segments\n", " | \n", " | _get_duration(self)\n", " | \n", " | _get_middle(self)\n", " | \n", " | _pretty(self, seconds)\n", " | \n", " | _repr_png_(self)\n", " | \n", " | copy(self)\n", " | Duplicate segment.\n", " | \n", " | for_json(self)\n", " | \n", " | intersects(self, other)\n", " | Check whether two segments intersect each other\n", " | \n", " | Parameters\n", " | ----------\n", " | other : Segment\n", " | Other segment\n", " | \n", " | Returns\n", " | -------\n", " | intersects : bool\n", " | True if segments intersect, False otherwise\n", " | \n", " | overlaps(self, t)\n", " | \n", " | pretty(self)\n", " | Human-readable representation of segments\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods defined here:\n", " | \n", " | from_json(cls, data) from __builtin__.type\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods defined here:\n", " | \n", " | __new__(cls, start=0.0, end=0.0)\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", " | __dict__\n", " | dictionary for instance variables (if defined)\n", " | \n", " | duration\n", " | \n", " | middle\n", " | \n", " | ----------------------------------------------------------------------\n", " | Methods inherited from Segment:\n", " | \n", " | __getnewargs__(self)\n", " | Return self as a plain tuple. Used by copy and pickle.\n", " | \n", " | __getstate__(self)\n", " | Exclude the OrderedDict from pickling\n", " | \n", " | _asdict(self)\n", " | Return a new OrderedDict which maps field names to their values\n", " | \n", " | _replace(_self, **kwds)\n", " | Return a new Segment object replacing specified fields with new values\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods inherited from Segment:\n", " | \n", " | _make(cls, iterable, new=, len=) from __builtin__.type\n", " | Make a new Segment object from a sequence or iterable\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors inherited from Segment:\n", " | \n", " | end\n", " | Alias for field number 1\n", " | \n", " | start\n", " | Alias for field number 0\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data and other attributes inherited from Segment:\n", " | \n", " | _fields = ('start', 'end')\n", " | \n", " | ----------------------------------------------------------------------\n", " | Methods inherited from __builtin__.tuple:\n", " | \n", " | __add__(...)\n", " | x.__add__(y) <==> x+y\n", " | \n", " | __eq__(...)\n", " | x.__eq__(y) <==> x==y\n", " | \n", " | __ge__(...)\n", " | x.__ge__(y) <==> x>=y\n", " | \n", " | __getattribute__(...)\n", " | x.__getattribute__('name') <==> x.name\n", " | \n", " | __getitem__(...)\n", " | x.__getitem__(y) <==> x[y]\n", " | \n", " | __getslice__(...)\n", " | x.__getslice__(i, j) <==> x[i:j]\n", " | \n", " | Use of negative indices is not supported.\n", " | \n", " | __gt__(...)\n", " | x.__gt__(y) <==> x>y\n", " | \n", " | __hash__(...)\n", " | x.__hash__() <==> hash(x)\n", " | \n", " | __le__(...)\n", " | x.__le__(y) <==> x<=y\n", " | \n", " | __len__(...)\n", " | x.__len__() <==> len(x)\n", " | \n", " | __lt__(...)\n", " | x.__lt__(y) <==> x x*n\n", " | \n", " | __ne__(...)\n", " | x.__ne__(y) <==> x!=y\n", " | \n", " | __rmul__(...)\n", " | x.__rmul__(n) <==> n*x\n", " | \n", " | count(...)\n", " | T.count(value) -> integer -- return number of occurrences of value\n", " | \n", " | index(...)\n", " | T.index(value, [start, [stop]]) -> integer -- return first index of value.\n", " | Raises ValueError if the value is not present.\n", "\n" ] } ], "source": [ "help(Segment)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 4 }