def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video
from dvaapp.models import Video
from dvaapp.tasks import extract_frames, perform_indexing, perform_detection
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
handle_youtube_video('tomorrow never dies',
'https://www.youtube.com/watch?v=gYtz5sw98Bc')
for v in Video.objects.all():
extract_frames(v.pk)
perform_indexing(v.pk)
# perform_detection(v.pk) detection is not performed in CI since it take long time on CPU
test_backup()
def qt():
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file
from dvaapp.models import Video, TEvent
from dvaapp.tasks import extract_frames, perform_face_detection, perform_indexing, segment_video
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/mp4")
v = handle_uploaded_file(f, name)
arguments_json = json.dumps({'sync': True})
segment_video(
TEvent.objects.create(video=v, arguments_json=arguments_json).pk)
perform_face_detection(TEvent.objects.create(video=v).pk)
args = json.dumps({
'index': 'facenet',
'target': 'regions',
'filter': {
'object_name__startswith': 'MTCNN_face'
}
})
perform_indexing(
TEvent.objects.create(video=v, arguments_json=args).pk)
def test(ci=False):
"""
Run tests
:param ci: if True (fab test:1) tests are run on Travis this option skips creating tasks and directly calls
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video
from dvaapp.models import Video
from dvaapp.tasks import extract_frames, perform_indexing, perform_detection
if ci:
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
handle_youtube_video('jungle book',
'https://www.youtube.com/watch?v=C4qgAaxB_pc')
for v in Video.objects.all():
extract_frames(v.pk)
perform_indexing(v.pk)
perform_detection(v.pk)
test_backup()
else:
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
handle_youtube_video('jungle book',
'https://www.youtube.com/watch?v=C4qgAaxB_pc')
def ci_face():
"""
Used in conjunction with travis for Continuous Integration for testing face indexing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaapp.models import Video, TEvent
from dvaapp.tasks import perform_indexing
for i,v in enumerate(Video.objects.all()):
if i ==0: # save travis time by just running detection on first video
args = {
'filter':{'object_name__startswith':'MTCNN_face'},
'index':'facenet',
'target':'regions'}
perform_indexing(TEvent.objects.create(video=v,arguments=args).pk)
def ci_face():
"""
Used in conjunction with travis for Continuous Integration for testing face indexing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaapp.models import Video, TEvent
from dvaapp.tasks import perform_indexing
for i,v in enumerate(Video.objects.all()):
if i ==0: # save travis time by just running detection on first video
args = json.dumps({
'filter':{'object_name__startswith':'MTCNN_face'},
'index':'facenet',
'target':'regions'})
perform_indexing(TEvent.objects.create(video=v,arguments_json=args).pk)
def ci():
"""
Perform Continuous Integration testing using Travis
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaui.view_shared import handle_uploaded_file, pull_vdn_list \
, import_vdn_dataset_url
from dvaapp.models import Video, TEvent, VDNServer, DVAPQL, Retriever, DeepModel
from django.conf import settings
from dvaapp.processing import DVAPQLProcess
from dvaapp.tasks import perform_dataset_extraction, perform_indexing, perform_export, perform_import, \
perform_retriever_creation, perform_detection, \
perform_video_segmentation, perform_transformation
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
for i, v in enumerate(Video.objects.all()):
if v.dataset:
arguments = {'sync': True}
perform_dataset_extraction(
TEvent.objects.create(video=v, arguments=arguments).pk)
else:
arguments = {'sync': True}
perform_video_segmentation(
TEvent.objects.create(video=v, arguments=arguments).pk)
arguments = {'index': 'inception', 'target': 'frames'}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
if i == 0: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# inception on crops from detector
arguments = {
'index': 'inception',
'target': 'regions',
'filters': {
'event_id': dt.pk,
'w__gte': 50,
'h__gte': 50
}
}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
temp = TEvent.objects.create(video=v,
arguments={'destination': "FILE"})
perform_export(temp.pk)
temp.refresh_from_db()
fname = temp.arguments['file_name']
f = SimpleUploadedFile(fname,
file("{}/exports/{}".format(
settings.MEDIA_ROOT, fname)).read(),
content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
perform_import(
TEvent.objects.create(video=vimported,
arguments={
"source": "LOCAL"
}).pk)
dc = Retriever()
args = {}
args['components'] = 32
args['m'] = 8
args['v'] = 8
args['sub'] = 64
dc.algorithm = Retriever.LOPQ
dc.source_filters = {
'indexer_shasum':
DeepModel.objects.get(name="inception",
model_type=DeepModel.INDEXER).shasum
}
dc.arguments = args
dc.save()
clustering_task = TEvent()
clustering_task.arguments = {'retriever_pk': dc.pk}
clustering_task.operation = 'perform_retriever_creation'
clustering_task.save()
perform_retriever_creation(clustering_task.pk)
query_dict = {
'process_type':
DVAPQL.QUERY,
'image_data_b64':
base64.encodestring(file('tests/query.png').read()),
'tasks': [{
'operation': 'perform_indexing',
'arguments': {
'index':
'inception',
'target':
'query',
'next_tasks': [{
'operation': 'perform_retrieval',
'arguments': {
'count': 20,
'retriever_pk':
Retriever.objects.get(name='inception').pk
}
}]
}
}]
}
launch_workers_and_scheduler_from_environment()
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
qp.launch()
qp.wait()
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1), k['url'], None,
k)
handle_uploaded_file(f, name)
if settings.DEBUG:
for fname in glob.glob('data/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
for i, v in enumerate(Video.objects.all()):
perform_import(TEvent.objects.get(video=v, operation='perform_import').pk)
if v.dataset:
arguments = {'sync': True}
perform_dataset_extraction(TEvent.objects.create(video=v, arguments=arguments).pk)
else:
arguments = {'sync': True}
perform_video_segmentation(TEvent.objects.create(video=v, arguments=arguments).pk)
arguments = {'index': 'inception', 'target': 'frames'}
perform_indexing(TEvent.objects.create(video=v, arguments=arguments).pk)
if i == 1: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
print "done perform_detection"
arguments = {'filters': {'event_id': dt.pk}, }
perform_transformation(TEvent.objects.create(video=v, arguments=arguments).pk)
print "done perform_transformation"
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
print "done perform_detection"
arguments = {'filters': {'event_id': dt.pk}, }
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, pull_vdn_list\
,import_vdn_dataset_url
from dvaapp.models import Video, Clusters,IndexEntries,TEvent,VDNServer, DVAPQL
from django.conf import settings
from dvaapp.operations.processing import DVAPQLProcess
from dvaapp.tasks import extract_frames, perform_indexing, export_video, import_video_by_id,\
perform_clustering, perform_analysis, perform_detection,\
segment_video, crop_regions_by_id
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
# handle_youtube_video('world is not enough', 'https://www.youtube.com/watch?v=P-oNz3Nf50Q') # Temporarily disabled due error in travis
for i,v in enumerate(Video.objects.all()):
if v.dataset:
arguments = {'sync':True}
extract_frames(TEvent.objects.create(video=v,arguments=arguments).pk)
else:
arguments = {'sync':True}
segment_video(TEvent.objects.create(video=v,arguments=arguments).pk)
arguments = {'index': 'inception'}
perform_indexing(TEvent.objects.create(video=v,arguments=arguments).pk)
if i ==0: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v,arguments=arguments)
perform_detection(dt.pk)
arguments = {'filters':{'event_id':dt.pk},}
crop_regions_by_id(TEvent.objects.create(video=v,arguments=arguments).pk)
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {'filters':{'event_id':dt.pk},}
crop_regions_by_id(TEvent.objects.create(video=v,arguments=arguments).pk)
# inception on crops from detector
arguments = {'index':'inception','target': 'regions','filters': {'event_id': dt.pk, 'w__gte': 50, 'h__gte': 50}}
perform_indexing(TEvent.objects.create(video=v,arguments=arguments).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video(TEvent.objects.create(video=v).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.arguments = {'clusters_id':dc.pk}
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query_dict = {
'process_type': DVAPQL.QUERY,
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexer_queries':[
{
'algorithm':'inception',
'count':10,
'approximate':False
}
]
}
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
query_dict = {
'process_type': DVAPQL.QUERY,
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexer_queries':[
{
'algorithm':'inception',
'count':10,
'approximate':True
}
]
}
qp = DVAPQLProcess()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1),k['url'],None)
test_backup()
def ci():
"""
Perform Continuous Integration testing using Travis
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, pull_vdn_list \
, import_vdn_dataset_url
from dvaapp.models import Video, IndexEntries, TEvent, VDNServer, DVAPQL, Retriever
from django.conf import settings
from dvaapp.operations.processing import DVAPQLProcess
from dvaapp.tasks import perform_dataset_extraction, perform_indexing, perform_export, perform_import, \
perform_retriever_creation, perform_detection, \
perform_video_segmentation, perform_transformation
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
for i, v in enumerate(Video.objects.all()):
if v.dataset:
arguments = {'sync': True}
perform_dataset_extraction(
TEvent.objects.create(video=v, arguments=arguments).pk)
else:
arguments = {'sync': True}
perform_video_segmentation(
TEvent.objects.create(video=v, arguments=arguments).pk)
arguments = {'index': 'inception', 'target': 'frames'}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
if i == 0: # save travis time by just running detection on first video
# face_mtcnn
arguments = {'detector': 'face'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# coco_mobilenet
arguments = {'detector': 'coco'}
dt = TEvent.objects.create(video=v, arguments=arguments)
perform_detection(dt.pk)
arguments = {
'filters': {
'event_id': dt.pk
},
}
perform_transformation(
TEvent.objects.create(video=v, arguments=arguments).pk)
# inception on crops from detector
arguments = {
'index': 'inception',
'target': 'regions',
'filters': {
'event_id': dt.pk,
'w__gte': 50,
'h__gte': 50
}
}
perform_indexing(
TEvent.objects.create(video=v, arguments=arguments).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
temp = TEvent.objects.create(video=v,
arguments={'destination': "FILE"})
perform_export(temp.pk)
temp.refresh_from_db()
fname = temp.arguments['file_name']
f = SimpleUploadedFile(fname,
file("{}/exports/{}".format(
settings.MEDIA_ROOT, fname)).read(),
content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
perform_import(
TEvent.objects.create(video=vimported,
arguments={
"source": "LOCAL"
}).pk)
# dc = Retriever()
# args = {}
#
# dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
# dc.components = 32
# dc.save()
# clustering_task = TEvent()
# clustering_task.arguments = {'clusters_id': dc.pk}
# clustering_task.operation = 'perform_clustering'
# clustering_task.save()
# perform_clustering(clustering_task.pk)
# query_dict = {
# 'process_type': DVAPQL.QUERY,
# 'image_data_b64': base64.encodestring(file('tests/query.png').read()),
# 'indexer_queries': [
# {
# 'algorithm': 'inception',
# 'count': 10,
# 'approximate': False
# }
# ]
# }
# qp = DVAPQLProcess()
# qp.create_from_json(query_dict)
# # execute_index_subquery(qp.indexer_queries[0].pk)
# query_dict = {
# 'process_type': DVAPQL.QUERY,
# 'image_data_b64': base64.encodestring(file('tests/query.png').read()),
# 'indexer_queries': [
# {
# 'algorithm': 'inception',
# 'count': 10,
# 'approximate': True
# }
# ]
# }
# qp = DVAPQLProcess()
# qp.create_from_json(query_dict)
# # execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1), k['url'], None,
k)
test_backup()
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname,
file(fname).read(),
content_type="application/zip")
handle_uploaded_file(f, name)
handle_youtube_video('jungle book',
'https://www.youtube.com/watch?v=C4qgAaxB_pc')
for v in Video.objects.all():
extract_frames(v.pk)
perform_indexing(v.pk)
perform_detection(v.pk)
elif sys.argv[1] == 'backup':
try:
os.mkdir('backups')
except:
pass
media_dir = settings.MEDIA_ROOT
db = settings.DATABASES.values()[0]
pg = '/Users/aub3/PostgreSQL/pg96/bin/pg_dump' if sys.platform == 'darwin' else 'pg_dump'
with open('{}/postgres.dump'.format(media_dir), 'w') as dumpfile:
dump = subprocess.Popen([
pg, '--clean',
'--dbname', 'postgresql://{}:{}@{}:5432/{}'.format(
db['USER'], db['PASSWORD'], db['HOST'], db['NAME'])
],
import django, os
from dvalib import indexer
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
from dvaapp import tasks
from dvaapp.models import Video
for v in Video.objects.all():
tasks.perform_indexing(v.pk)
def ci():
"""
Used in conjunction with travis for Continuous Integration testing
:return:
"""
import django
sys.path.append(os.path.dirname(__file__))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dva.settings")
django.setup()
import base64
from django.core.files.uploadedfile import SimpleUploadedFile
from dvaapp.views import handle_uploaded_file, handle_youtube_video, pull_vdn_list\
,import_vdn_dataset_url
from dvaapp.models import Video, Clusters,IndexEntries,TEvent,VDNServer
from django.conf import settings
from dvaapp.operations.query_processing import QueryProcessing
from dvaapp.tasks import extract_frames, perform_indexing, export_video_by_id, import_video_by_id,\
perform_clustering, perform_analysis, perform_detection,\
segment_video, crop_regions_by_id
for fname in glob.glob('tests/ci/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
if sys.platform != 'darwin':
for fname in glob.glob('tests/*.mp4'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="video/mp4")
handle_uploaded_file(f, name, False)
for fname in glob.glob('tests/*.zip'):
name = fname.split('/')[-1].split('.')[0]
f = SimpleUploadedFile(fname, file(fname).read(), content_type="application/zip")
handle_uploaded_file(f, name)
# handle_youtube_video('world is not enough', 'https://www.youtube.com/watch?v=P-oNz3Nf50Q') # Temporarily disabled due error in travis
for i,v in enumerate(Video.objects.all()):
if v.dataset:
arguments_json = json.dumps({'sync':True})
extract_frames(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
else:
arguments_json = json.dumps({'sync':True})
segment_video(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
arguments_json = json.dumps({'index': 'inception'})
perform_indexing(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
if i ==0: # save travis time by just running detection on first video
# face_mtcnn
arguments_json = json.dumps({'detector': 'face'})
dt = TEvent.objects.create(video=v,arguments_json=arguments_json)
perform_detection(dt.pk)
arguments_json = json.dumps({'filters':{'event_id':dt.pk},})
crop_regions_by_id(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# coco_mobilenet
arguments_json = json.dumps({'detector': 'coco'})
dt = TEvent.objects.create(video=v, arguments_json=arguments_json)
perform_detection(dt.pk)
arguments_json = json.dumps({'filters':{'event_id':dt.pk},})
crop_regions_by_id(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# inception on crops from detector
arguments_json = json.dumps({'index':'inception','target': 'regions','filters': {'event_id': dt.pk, 'w__gte': 50, 'h__gte': 50}})
perform_indexing(TEvent.objects.create(video=v,arguments_json=arguments_json).pk)
# assign_open_images_text_tags_by_id(TEvent.objects.create(video=v).pk)
fname = export_video_by_id(TEvent.objects.create(video=v,event_type=TEvent.EXPORT).pk)
f = SimpleUploadedFile(fname, file("{}/exports/{}".format(settings.MEDIA_ROOT,fname)).read(), content_type="application/zip")
vimported = handle_uploaded_file(f, fname)
import_video_by_id(TEvent.objects.create(video=vimported).pk)
dc = Clusters()
dc.indexer_algorithm = 'inception'
dc.included_index_entries_pk = [k.pk for k in IndexEntries.objects.all().filter(algorithm=dc.indexer_algorithm)]
dc.components = 32
dc.save()
clustering_task = TEvent()
clustering_task.clustering = dc
clustering_task.event_type = TEvent.CLUSTERING
clustering_task.operation = 'perform_clustering'
clustering_task.save()
perform_clustering(clustering_task.pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':False
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
query_dict = {
'image_data_b64':base64.encodestring(file('tests/query.png').read()),
'indexers':[
{
'algorithm':'inception',
'count':10,
'approximate':True
}
]
}
qp = QueryProcessing()
qp.create_from_json(query_dict)
# execute_index_subquery(qp.indexer_queries[0].pk)
server, datasets, detectors = pull_vdn_list(1)
for k in datasets:
if k['name'] == 'MSCOCO_Sample_500':
print 'FOUND MSCOCO SAMPLE'
import_vdn_dataset_url(VDNServer.objects.get(pk=1),k['url'],None)
test_backup()
