des.mc.multitrack.model.base source code

1 module des.mc.multitrack.model.base;
2 
3 import des.mc.multitrack.model;
4 import des.mc.multitrack.model.util;
5 
6 /+ TODO: WIP
7 
8 class BaseClassifier : Classifier
9 {
10     Skeleton[][] opCall( in Skeleton[][] )
11     {
12 
13     }
14 }
15 
16 class BaseComplexer : Complexer
17 {
18     Skeleton[] opCall( in Skeleton[][] )
19     {
20         // TODO
21 
22     }
23 }
24 
25 class BaseUserHandler: UserHandler
26 {
27 protected:
28     size_t overdue_count = 0;
29     size_t max_overdue;
30 
31     User self_user;
32 public:
33 
34     this( User fuser, size_t maxOD=4 )
35     {
36         self_user = fuser;
37         max_overdue = maxOD;
38     }
39 
40     @property 
41     {
42         bool updated() const { return !overdue_count; }
43         ref const(User) user() const { return self_user; }
44         bool isOverdue() const { return overdue_count >= max_overdue; }
45     }
46 
47     void setOverdue() { overdue_count++; }
48 
49     void setSkeleton( in Skeleton s )
50     {
51         self_user.skel = s;
52         overdue_count = 0;
53     }
54 
55     float calcTransformPossibility( in Skeleton s ) const
56     {
57         // TODO
58     }
59 }
60 
61 class BaseDestributor : Destributor
62 {
63     Skeleton[] opCall( UserHandler[] handlers, in Skeleton[] skeletons )
64     {
65         auto table = calcPossibility( handlers, skeletons );
66         bool[] destributed, updated;
67         destributed.length = skeletons.length;
68         updated.length = handlers.length;
69 
70         foreach( k; 0 .. min( skeletons.length, handlers.length) )
71         {
72             float max_possibility = 0;
73             ptrdiff_t max_i = -1;
74             ptrdiff_t max_j = -1;
75 
76             foreach( i, skel_line; table )
77             {
78                 if( destributed[i] ) continue;
79                 foreach( j, coef; skel_line )
80                 {
81                     if( updated[j] ) continue;
82 
83                     if( coef > max_possibility )
84                     {
85                         max_possibility = coef;
86                         max_i = i;
87                         max_j = j;
88                     }
89                 }
90             }
91 
92             if( max_i >= 0 )
93             {
94                 handlers[max_j].setSkeleton( skels[max_i] );
95                 updated[max_j] = true;
96                 destributed[max_i] = true;
97             }
98         }
99 
100         Skeleton[] not_destributed;
101         foreach( i, skel; skeletons )
102             if( !destributed[i] )
103                 not_destributed ~= skel;
104         return not_destributed;
105     }
106 
107 protected:
108 
109     float[][] calcPossibility( UserHandler[] handlers, in Skeleton[] skeletons )
110     {
111         float[][] ret;
112         foreach( skel; skeletons )
113         {
114             float[] buf;
115             foreach( uh; handlers )
116                 buf ~= uh.calcTransformPossibility( skel );
117             ret ~= buf;
118         }
119         return ret;
120     }
121 }
122 
123 class BaseMultiTrackerFactory : MultiTrackerFactory
124 {
125 protected:
126     BaseClassifier baseClassifier;
127     BaseComplexer baseComplexer;
128     BaseDestributor baseDestributor;
129 
130     size_t max_handler_overdue = 4;
131 
132 public:
133     this()
134     {
135         baseClassifier = new BaseClassifier;
136         baseComplexer = new BaseComplexer;
137         baseDestributor = new BaseDestributor;
138     }
139 
140     @property
141     {
142         Classifier classifier() { return baseClassifier; }
143         Complexer complexer() { return baseComplexer; }
144         Destributor destributor() { return baseDestributor; }
145     }
146 
147     UserHandler newUserHandler( User user )
148     {
149         return new BaseUserHandler( user, max_handler_overdue );
150     }
151 }
152 
153 +/