0x2620/pandora
2
1
Fork 1
Code Issues 1.3k Pull requests Releases Wiki Activity

findClips

Browse source
This commit is contained in:
j 2011-10-02 20:16:28 +02:00
parent 4442a9aaf3
commit 78b07dd64a
11 changed files with 228 additions and 14 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
pandora/annotation/models.py
View file

@ -6,9 +6,11 @@ from django.db import models
from django.contrib.auth.models import User
import ox
from archive import extract
from clip.models import Clip
import utils
import managers
from archive import extract
def load_layers(layers):
@ -79,6 +81,7 @@ class Annotation(models.Model):
modified = models.DateTimeField(auto_now=True)
user = models.ForeignKey(User)
item = models.ForeignKey('item.Item', related_name='annotations')
clip = models.ForeignKey('clip.Clip', null=True, related_name='annotations')
public_id = models.CharField(max_length=128, unique=True)
#seconds
@ -127,14 +130,26 @@ class Annotation(models.Model):
self.set_public_id()
if self.duration != self.end - self.start:
self.update_calculated_values()
if not self.clip and not self.layer.private:
self.clip, created = Clip.objects.get_or_create(item=self.item,
start=self.start,
end=self.end)
if created:
#FIXME, only clips should have those values
self.clip.duration = self.duration
self.clip.hue = self.hue
self.clip.saturation = self.saturation
self.clip.lightness = self.lightness
self.clip.volume = self.volume
self.clip.save()
super(Annotation, self).save(*args, **kwargs)
def json(self, layer=False, keys=None):
j = {
'user': self.user.username,
}
for field in ('id', 'in', 'out', 'value', 'created', 'modified',
'hue', 'saturation', 'lightness', 'volume'):
for field in ('id', 'in', 'out', 'value', 'created', 'modified'):
j[field] = getattr(self, {
'id': 'public_id',
'in': 'start',

3
pandora/archive/extract.py
View file

@ -318,6 +318,9 @@ def average_color(prefix, start=0, end=0):
color = list(map(float, color))
return ox.image.getHSL(color)
def average_volume(prefix, start=0, end=0):
#FIXME: actually compute volume
return 0
def get_distance(rgb0, rgb1):
dst = math.sqrt(pow(rgb0[0] - rgb1[0], 2) + pow(rgb0[0] - rgb1[0], 2) + pow(rgb0[0] - rgb1[0], 2))

0
pandora/clip/__init__.py Normal file
View file

85
pandora/clip/models.py Normal file
View file

@ -0,0 +1,85 @@
# -*- coding: utf-8 -*-
# vi:si:et:sw=4:sts=4:ts=4
from __future__ import division, with_statement
from django.db import models
from django.conf import settings
import ox
from archive import extract
import managers
class Clip(models.Model):
class Meta:
unique_together = ("item", "start", "end")
objects = managers.ClipManager()
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
public_id = models.CharField(max_length=128, unique=True)
item = models.ForeignKey('item.Item', related_name='clips')
#seconds
start = models.FloatField(default=-1)
end = models.FloatField(default=-1)
duration = models.FloatField(default=0)
#get from annotation
duration = models.FloatField(default=0, db_index=True)
hue = models.FloatField(default=0, db_index=True)
saturation = models.FloatField(default=0, db_index=True)
lightness = models.FloatField(default=0, db_index=True)
volume = models.FloatField(default=0, db_index=True)
def update_calculated_values(self):
self.duration = self.end - self.start
if self.duration > 0:
self.hue, self.saturation, self.lightness = extract.average_color(
self.item.timeline_prefix, self.start, self.end)
self.volume = extract.average_volume(self.item.timeline_prefix, self.start, self.end)
else:
self.hue = self.saturation = self.lightness = 0
self.volume = 0
def save(self, *args, **kwargs):
self.public_id = u"%s/%s-%s" %(self.item.itemId, self.start, self.end)
if self.duration != self.end - self.start:
self.update_calculated_values()
super(Clip, self).save(*args, **kwargs)
def set_public_id(self):
self.public_id = u"%s/%s-%s" %(self.item.itemId, self.start, self.end)
def json(self, keys=None):
j = {}
for field in ('id', 'in', 'out', 'created', 'modified',
'hue', 'saturation', 'lightness', 'volume'):
j[field] = getattr(self, {
'id': 'public_id',
'in': 'start',
'out': 'end',
}.get(field, field))
if keys:
_j = {}
for key in keys:
if key in j:
_j[key] = j[key]
j = _j
if 'videoRatio' in keys:
streams = self.item.streams()
if streams:
j['videoRatio'] = streams[0].aspect_ratio
public_layers = [l['id']
for l in filter(lambda l: not l.get('private', False),
settings.CONFIG['layers'])]
for layer in filter(lambda l: l in keys, public_layers):
j[layer] = [a.json(keys=['value'])['value']
for a in self.annotations.filter(layer__name=layer)]
return j
def __unicode__(self):
return u"%s/%s-%s" %(self.item, self.start, self.end)

16
pandora/clip/tests.py Normal file
View file

@ -0,0 +1,16 @@
"""
This file demonstrates writing tests using the unittest module. These will pass
when you run "manage.py test".
Replace this with more appropriate tests for your application.
"""
from django.test import TestCase
class SimpleTest(TestCase):
def test_basic_addition(self):
"""
Tests that 1 + 1 always equals 2.
"""
self.assertEqual(1 + 1, 2)

93
pandora/clip/views.py Normal file
View file

@ -0,0 +1,93 @@
# -*- coding: utf-8 -*-
# vi:si:et:sw=4:sts=4:ts=4
from __future__ import division
from ox.utils import json
from ox.django.shortcuts import render_to_json_response, json_response
from api.actions import actions
from item.models import Item
from item import utils
import models
def parse_query(data, user):
query = {}
query['range'] = [0, 100]
query['sort'] = [{'key':'in', 'operator':'+'}]
for key in ('keys', 'group', 'range', 'sort', 'query'):
if key in data:
query[key] = data[key]
query['qs'] = models.Clip.objects.find(query, user)
if 'itemQuery' in data:
item_query = Item.objects.find({'query': data['itemQuery']}, user)
query['qs'] = query['qs'].filter(item__in=item_query)
return query
def order_query(qs, sort):
order_by = []
for e in sort:
operator = e['operator']
if operator != '-':
operator = ''
key = {
'in': 'start',
'out': 'end',
}.get(e['key'], e['key'])
if key.startswith('clip:'):
key = e['key'][len('clip:'):]
key = {
'text': 'annotations__value',
'position': 'start',
}.get(key, key)
elif key not in ('start', 'end', 'annotations__value'):
#key mgith need to be changed, see order_sort in item/views.py
key = "item__sort__%s" % key
order = '%s%s' % (operator, key)
order_by.append(order)
if order_by:
qs = qs.order_by(*order_by, nulls_last=True)
qs = qs.distinct()
return qs
def findClips(request):
'''
param data {
query: ...
itemQuery: ...
}
return {
'status': {'code': int, 'text': string}
'data': {
items = [{..}, {...}, ...]
}
}
'''
data = json.loads(request.POST['data'])
response = json_response()
query = parse_query(data, request.user)
qs = order_query(query['qs'], query['sort'])
if 'keys' in data:
qs = qs[query['range'][0]:query['range'][1]]
response['data']['items'] = [p.json(keys=data['keys']) for p in qs]
elif 'position' in query:
ids = [i.public_id for i in qs]
data['conditions'] = data['conditions'] + {
'value': data['position'],
'key': query['sort'][0]['key'],
'operator': '^'
}
query = parse_query(data, request.user)
qs = order_query(query['qs'], query['sort'])
if qs.count() > 0:
response['data']['position'] = utils.get_positions(ids, [qs[0].itemId])[0]
elif 'positions' in data:
ids = [i.public_id for i in qs]
response['data']['positions'] = utils.get_positions(ids, data['positions'])
else:
response['data']['items'] = qs.count()
return render_to_json_response(response)
actions.register(findClips)

1
pandora/settings.py
View file

@ -123,6 +123,7 @@ INSTALLED_APPS = (
'app',
'annotation',
'clip',
'archive',
'event',
'item',

11
static/js/pandora/ui/clipList.js
View file

@ -24,12 +24,13 @@ pandora.ui.clipList = function(videoRatio) {
info = ['hue', 'saturation', 'lightness'].indexOf(sortKey) > -1
? Ox.formatColor(data[sortKey], sortKey)
: Ox.formatDuration(data['in'], 'short') + ' - '
+ Ox.formatDuration(data['out'], 'short');
+ Ox.formatDuration(data['out'], 'short'),
title = data.subtitles[0]; //fixme: could be other layer
return {
height: height,
id: data.id,
info: info,
title: data.value,
title: title,
url: url,
width: width
};
@ -65,13 +66,13 @@ pandora.ui.clipList = function(videoRatio) {
// we'll need something like itemFind (vs. listFind)
query = {conditions: [], operator: '&'};
}
pandora.api.findAnnotations(Ox.extend({
pandora.api.findClips(Ox.extend({
itemQuery: itemQuery,
query: query
}, data), callback);
},
keys: Ox.merge(
['id', 'in', 'out', 'value'],
['id', 'in', 'out', 'subtitles'], //fixme: could be other layer
!ui.item ? ['videoRatio'] : []
),
max: 1,
@ -178,4 +179,4 @@ pandora.ui.clipList = function(videoRatio) {
return that;
}
}

2
static/js/pandora/ui/item.js
View file

@ -60,7 +60,7 @@ pandora.ui.item = function() {
select: function(event) {
pandora.$ui.clips.options({
items: function(data, callback) {
pandora.api.findAnnotations(Ox.extend(data, {
pandora.api.findClips(Ox.extend(data, {
query: {
conditions:[{
key: 'event',

6
static/js/pandora/ui/list.js
View file

@ -245,11 +245,11 @@ pandora.ui.list = function() {
query.conditions.push({key: 'value', value: q.value, operator: q.operator});
}
});
pandora.api.findAnnotations(Ox.extend({
pandora.api.findClips(Ox.extend({
query: query,
itemQuery: itemQuery
}, range ? {
keys: ['id', 'in', 'out'],
keys: ['id', 'in', 'out', 'subtitles'],
range: range,
sort: pandora.user.ui.listSort
} : {}), function(result) {
@ -355,7 +355,7 @@ pandora.ui.list = function() {
select: function(event) {
pandora.$ui.clips.options({
items: function(data, callback) {
return pandora.api.findAnnotations(Ox.extend(data, {
return pandora.api.findClips(Ox.extend(data, {
query: {
conditions:[{key: 'event',
value: event.id,

4
static/js/pandora/ui/mapView.js
View file

@ -54,7 +54,7 @@ pandora.ui.mapView = function(videoRatio) {
operator: '&'
};
}
return pandora.api.findAnnotations(Ox.extend({
return pandora.api.findClips(Ox.extend({
itemQuery: itemQuery,
query: {
conditions: [{key: 'place', value: id, operator:'=='}],
@ -221,4 +221,4 @@ pandora.ui.mapView = function(videoRatio) {
return that;
};
};