Peter M. Groen / openbr

Browse Code »

Commit d54b1db01e74c5b08c8cbcb0bd012399378e9a4b

Authored by Scott Klum 2015-05-05 12:51:55 -0400

2 parents 6dd79bd3 5328152f

Merge branch 'master' of https://github.com/biometrics/openbr

Inline Side-by-side

Showing 2 changed files with 242 additions and 613 deletions

openbr/plugins/core/align.cpp deleted

View file @6dd79bd

1		-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2		- * Copyright 2015 Noblis *
3		- * *
4		- * Licensed under the Apache License, Version 2.0 (the "License"); *
5		- * you may not use this file except in compliance with the License. *
6		- * You may obtain a copy of the License at *
7		- * *
8		- * http://www.apache.org/licenses/LICENSE-2.0 *
9		- * *
10		- * Unless required by applicable law or agreed to in writing, software *
11		- * distributed under the License is distributed on an "AS IS" BASIS, *
12		- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
13		- * See the License for the specific language governing permissions and *
14		- * limitations under the License. *
15		- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
16		-
17		-#include <opencv2/opencv.hpp>
18		-#include "openbr/plugins/openbr_internal.h"
19		-#include "openbr/core/qtutils.h"
20		-#include "openbr/core/opencvutils.h"
21		-#include "openbr/core/eigenutils.h"
22		-#include "openbr/core/common.h"
23		-#include <QString>
24		-#include <Eigen/SVD>
25		-#include <Eigen/Dense>
26		-
27		-using namespace std;
28		-using namespace cv;
29		-using namespace Eigen;
30		-
31		-namespace br
32		-{
33		-
34		-/*!
35		- * \ingroup transforms
36		- * \brief Improved procrustes alignment of points, to include a post processing scaling of points
37		- * to faciliate subsequent texture mapping.
38		- * \author Brendan Klare \cite bklare
39		- * \param width Width of output coordinate space (before padding)
40		- * \param padding Amount of padding around the coordinate space
41		- * \param useFirst whether or not to use the first instance as the reference object
42		- */
43		-class ProcrustesAlignTransform : public Transform
44		-{
45		- Q_OBJECT
46		-
47		- Q_PROPERTY(float width READ get_width WRITE set_width RESET reset_width STORED false)
48		- Q_PROPERTY(float padding READ get_padding WRITE set_padding RESET reset_padding STORED false)
49		- Q_PROPERTY(bool useFirst READ get_useFirst WRITE set_useFirst RESET reset_useFirst STORED false)
50		- BR_PROPERTY(float, width, 80)
51		- BR_PROPERTY(float, padding, 8)
52		- BR_PROPERTY(bool, useFirst, false)
53		-
54		-
55		- Eigen::MatrixXf referenceShape;
56		- float minX;
57		- float minY;
58		- float maxX;
59		- float maxY;
60		- float aspectRatio;
61		-
62		- void init() {
63		- aspectRatio = 0;
64		- }
65		-
66		- static MatrixXf getRotation(MatrixXf ref, MatrixXf sample) {
67		- MatrixXf R = sample.transpose() * ref;
68		- JacobiSVD<MatrixXf> svd(R, ComputeFullU \| ComputeFullV);
69		- R = svd.matrixU() * svd.matrixV().transpose();
70		- return R;
71		- }
72		-
73		- //Converts x y points in a single vector to two column matrix
74		- static MatrixXf vectorToMatrix(MatrixXf vector) {
75		- int n = vector.rows();
76		- MatrixXf matrix(n / 2, 2);
77		- for (int i = 0; i < n / 2; i++) {
78		- for (int j = 0; j < 2; j++) {
79		- matrix(i, j) = vector(i * 2 + j);
80		- }
81		- }
82		- return matrix;
83		- }
84		-
85		- static MatrixXf matrixToVector(MatrixXf matrix) {
86		- int n2 = matrix.rows();
87		- MatrixXf vector(n2 * 2, 1);
88		- for (int i = 0; i < n2; i++) {
89		- for (int j = 0; j < 2; j++) {
90		- vector(i * 2 + j) = matrix(i, j);
91		- }
92		- }
93		- return vector;
94		- }
95		-
96		- void train(const TemplateList &data)
97		- {
98		- MatrixXf points(data[0].file.points().size() * 2, data.size());
99		-
100		- // Normalize all sets of points
101		- int skip = 0;
102		- for (int j = 0; j < data.size(); j++) {
103		- QList<QPointF> imagePoints = data[j].file.points();
104		- if (imagePoints.size() == 0) {
105		- skip++;
106		- continue;
107		- }
108		-
109		- float meanX = 0,
110		- meanY = 0;
111		- for (int i = 0; i < imagePoints.size(); i++) {
112		- points(i * 2, j - skip) = imagePoints[i].x();
113		- points(i * 2 + 1, j - skip) = imagePoints[i].y();
114		-
115		- meanX += imagePoints[i].x();
116		- meanY += imagePoints[i].y();
117		- }
118		-
119		- meanX /= imagePoints.size();
120		- meanY /= imagePoints.size();
121		-
122		- for (int i = 0; i < imagePoints.size(); i++) {
123		- points(i * 2, j - skip) -= meanX;
124		- points(i * 2 + 1, j - skip) -= meanY;
125		- }
126		- }
127		-
128		- points = MatrixXf(points.leftCols(data.size() - skip));
129		-
130		- //normalize scale
131		- for (int i = 0; i < points.cols(); i++)
132		- points.col(i) = points.col(i) / points.col(i).norm();
133		-
134		- //Normalize rotation
135		- if (!useFirst) {
136		- referenceShape = vectorToMatrix(points.rowwise().sum() / points.cols());
137		- } else {
138		- referenceShape = vectorToMatrix(points.col(0));
139		- }
140		-
141		- for (int i = 0; i < points.cols(); i++) {
142		- MatrixXf p = vectorToMatrix(points.col(i));
143		- MatrixXf R = getRotation(referenceShape, p);
144		- points.col(i) = matrixToVector(p * R);
145		- }
146		-
147		- //Choose crop boundaries and adjustments that captures most data
148		- MatrixXf minXs(points.cols(),1);
149		- MatrixXf minYs(points.cols(),1);
150		- MatrixXf maxXs(points.cols(),1);
151		- MatrixXf maxYs(points.cols(),1);
152		- for (int j = 0; j < points.cols(); j++) {
153		- minX = FLT_MAX,
154		- minY = FLT_MAX,
155		- maxX = -FLT_MAX,
156		- maxY = -FLT_MAX;
157		- for (int i = 0; i < points.rows(); i++) {
158		- if (i % 2 == 0) {
159		- if (points(i,j) > maxX)
160		- maxX = points(i, j);
161		- if (points(i,j) < minX)
162		- minX = points(i, j);
163		- } else {
164		- if (points(i,j) > maxY)
165		- maxY = points(i, j);
166		- if (points(i,j) < minY)
167		- minY = points(i, j);
168		- }
169		- }
170		-
171		- minXs(j) = minX;
172		- maxXs(j) = maxX;
173		- minYs(j) = minY;
174		- maxYs(j) = maxY;
175		- }
176		-
177		- minX = minXs.mean() - 0 * EigenUtils::stddev(minXs);
178		- minY = minYs.mean() - 0 * EigenUtils::stddev(minYs);
179		- maxX = maxXs.mean() + 0 * EigenUtils::stddev(maxXs);
180		- maxY = maxYs.mean() + 0 * EigenUtils::stddev(maxYs);
181		- aspectRatio = (maxX - minX) / (maxY - minY);
182		- }
183		-
184		- void project(const Template &src, Template &dst) const
185		- {
186		- QList<QPointF> imagePoints = src.file.points();
187		- if (imagePoints.size() == 0) {
188		- dst.file.fte = true;
189		- qDebug() << "No points for file " << src.file.name;
190		- return;
191		- }
192		-
193		- MatrixXf p(imagePoints.size() * 2, 1);
194		- for (int i = 0; i < imagePoints.size(); i++) {
195		- p(i * 2) = imagePoints[i].x();
196		- p(i * 2 + 1) = imagePoints[i].y();
197		- }
198		- p = vectorToMatrix(p);
199		-
200		- //Normalize translation
201		- p.col(0) = p.col(0) - MatrixXf::Ones(p.rows(),1) * (p.col(0).sum() / p.rows());
202		- p.col(1) = p.col(1) - MatrixXf::Ones(p.rows(),1) * (p.col(1).sum() / p.rows());
203		-
204		- //Normalize scale
205		- p /= matrixToVector(p).norm();
206		-
207		- //Normalize rotation
208		- MatrixXf R = getRotation(referenceShape, p);
209		- p = p * R;
210		-
211		- //Translate and scale into output space and store in output list
212		- QList<QPointF> procrustesPoints;
213		- for (int i = 0; i < p.rows(); i++)
214		- procrustesPoints.append( QPointF(
215		- (p(i, 0) - minX) / (maxX - minX) * (width - 1) + padding,
216		- (p(i, 1) - minY) / (maxY - minY) * (qRound( width / aspectRatio) - 1) + padding));
217		-
218		- dst = src;
219		- dst.file.setList<QPointF>("ProcrustesPoints", procrustesPoints);
220		- dst.file.set("ProcrustesBound", QRectF(0, 0, width + 2 * padding, (qRound(width / aspectRatio) + 2 * padding)));
221		- dst.file.set("ProcrustesPadding", padding);
222		- }
223		-
224		- void store(QDataStream &stream) const
225		- {
226		- stream << referenceShape;
227		- stream << minX;
228		- stream << minY;
229		- stream << maxX;
230		- stream << maxY;
231		- stream << aspectRatio;
232		- }
233		-
234		- void load(QDataStream &stream)
235		- {
236		- stream >> referenceShape;
237		- stream >> minX;
238		- stream >> minY;
239		- stream >> maxX;
240		- stream >> maxY;
241		- stream >> aspectRatio;
242		- }
243		-};
244		-BR_REGISTER(Transform, ProcrustesAlignTransform)
245		-
246		-/*!
247		- * \ingroup transforms
248		- * \brief Maps texture from one set of points to another. Assumes that points are rigidly transformed
249		- * \author Brendan Klare \cite bklare
250		- * \author Scott Klum \cite sklum
251		- */
252		-class TextureMapTransform : public UntrainableTransform
253		-{
254		- Q_OBJECT
255		-
256		-public:
257		- static QRectF getBounds(const QList<QPointF> &points, int dstPadding)
258		- {
259		- float srcMinX = FLT_MAX;
260		- float srcMinY = FLT_MAX;
261		- float srcMaxX = -FLT_MAX;
262		- float srcMaxY = -FLT_MAX;
263		- foreach (const QPointF &point, points) {
264		- if (point.x() < srcMinX) srcMinX = point.x();
265		- if (point.y() < srcMinY) srcMinY = point.y();
266		- if (point.x() > srcMaxX) srcMaxX = point.x();
267		- if (point.y() > srcMaxY) srcMaxY = point.y();
268		- }
269		-
270		- const float padding = (srcMaxX - srcMinX) / 80 * dstPadding;
271		- return QRectF(qRound(srcMinX - padding), qRound(srcMinY - padding), qRound(srcMaxX - srcMinX + 2 * padding), qRound(srcMaxY - srcMinY + 2 * padding));
272		- }
273		-
274		- static int getVertexIndex(const QPointF &trianglePts, const QList<QPointF> &pts)
275		- {
276		- for (int i = 0; i < pts.size(); i++)
277		- // Check points using single precision accuracy to avoid potential rounding error
278		- if ((float(trianglePts.x()) == float(pts[i].x())) && (float(trianglePts.y()) == float(pts[i].y())))
279		- return i;
280		- qFatal("Couldn't identify index of requested point!");
281		- return -1;
282		- }
283		-
284		- static QList<QPointF> addBounds(QList<QPointF> points, const QRectF &bound)
285		- {
286		- points.append(bound.topLeft());
287		- points.append(QPointF(bound.right() - 1, bound.top()));
288		- points.append(QPointF(bound.left(), bound.bottom() - 1));
289		- points.append(QPointF(bound.right() - 1, bound.bottom() - 1));
290		- return points;
291		- }
292		-
293		- static QList<QPointF> removeBounds(const QList<QPointF> &points)
294		- {
295		- return points.mid(0, points.size() - 4);
296		- }
297		-
298		- //Expand out bounds placed at end of point list by addBounds
299		- static QList<QPointF> expandBounds(QList<QPointF> points, int pad)
300		- {
301		- const int n = points.size();
302		- points[n-4] = QPointF(points[n-4].x() - pad, points[n-4].y() - pad);
303		- points[n-3] = QPointF(points[n-3].x() + pad, points[n-3].y() - pad);
304		- points[n-2] = QPointF(points[n-2].x() - pad, points[n-2].y() + pad);
305		- points[n-1] = QPointF(points[n-1].x() + pad, points[n-1].y() + pad);
306		- return points;
307		- }
308		-
309		- //Contract in bounds placed at end of point list by addBounds
310		- static QList<QPointF> contractBounds(QList<QPointF> points, int pad)
311		- {
312		- const int n = points.size();
313		- points[n-4] = QPointF(points[n-4].x() + pad, points[n-4].y() + pad);
314		- points[n-3] = QPointF(points[n-3].x() - pad, points[n-3].y() + pad);
315		- points[n-2] = QPointF(points[n-2].x() + pad, points[n-2].y() - pad);
316		- points[n-1] = QPointF(points[n-1].x() - pad, points[n-1].y() - pad);
317		- return points;
318		- }
319		-
320		- static QList<QList<int> > getTriangulation(const QList<QPointF> &points, const QRectF &bound)
321		- {
322		- Subdiv2D subdiv(OpenCVUtils::toRect(bound));
323		- foreach (const QPointF &point, points) {
324		- if (!bound.contains(point))
325		- return QList<QList<int> >();
326		- subdiv.insert(OpenCVUtils::toPoint(point));
327		- }
328		-
329		-
330		- vector<Vec6f> triangleList;
331		- subdiv.getTriangleList(triangleList);
332		-
333		- QList<QList<int> > triangleIndices;
334		- foreach (const Vec6f &triangle, triangleList) {
335		- bool valid = true;
336		- const QPointF vertices[3] = { QPointF(triangle[0], triangle[1]),
337		- QPointF(triangle[2], triangle[3]),
338		- QPointF(triangle[4], triangle[5]) };
339		- for (int j = 0; j < 3; j++)
340		- if (vertices[j].x() > bound.right() \|\| vertices[j].y() > bound.bottom() \|\| vertices[j].x() < bound.left() \|\| vertices[j].y() < bound.top()) {
341		- valid = false;
342		- break;
343		- }
344		-
345		- if (valid) {
346		- QList<int> tri;
347		- for (int j = 0; j < 3; j++)
348		- tri.append(getVertexIndex(vertices[j], points));
349		- triangleIndices.append(tri);
350		- }
351		- }
352		-
353		- return triangleIndices;
354		- }
355		-
356		-private:
357		- void project(const Template &src, Template &dst) const
358		- {
359		- QList<QPointF> dstPoints = dst.file.getList<QPointF>("ProcrustesPoints");
360		- QList<QPointF> srcPoints = dst.file.points();
361		- if (dstPoints.empty() \|\| srcPoints.empty()) {
362		- dst = src;
363		- if (Globals->verbose) {
364		- qWarning("Delauney triangulation failed because points or rects are empty.");
365		- dst.file.fte = true;
366		- }
367		- return;
368		- }
369		-
370		- QRectF dstBound = dst.file.get<QRectF>("ProcrustesBound");
371		- dstPoints = addBounds(dstPoints, dstBound);
372		-
373		- /Add a wider bound for triangulation to prevent border triangles from being missing/
374		- QRectF srcBound = getBounds(srcPoints, dst.file.get<int>("ProcrustesPadding") + 20);
375		- srcPoints = addBounds(srcPoints, srcBound);
376		- QList<QList<int> > triIndices = getTriangulation(srcPoints, srcBound);
377		-
378		- /Remove wider bound for texture mapping/
379		- srcPoints = removeBounds(srcPoints);
380		- srcBound = getBounds(srcPoints, dst.file.get<int>("ProcrustesPadding"));
381		- srcPoints = addBounds(srcPoints, srcBound);
382		-
383		- int dstWidth = dstBound.width() + dstBound.x();
384		- int dstHeight = dstBound.height() + dstBound.y();
385		- dst.m() = Mat::zeros(dstHeight, dstWidth, src.m().type());
386		- for (int i = 0; i < triIndices.size(); i++) {
387		- Point2f srcPoint1[3];
388		- Point2f dstPoint1[3];
389		- for (int j = 0; j < 3; j++) {
390		- srcPoint1[j] = OpenCVUtils::toPoint(srcPoints[triIndices[i][j]]);
391		- dstPoint1[j] = OpenCVUtils::toPoint(dstPoints[triIndices[i][j]]);
392		- }
393		-
394		- Mat buffer(dstHeight, dstWidth, src.m().type());
395		- warpAffine(src.m(), buffer, getAffineTransform(srcPoint1, dstPoint1), Size(dstBound.width(), dstBound.height()));
396		-
397		- Mat mask = Mat::zeros(dstHeight, dstWidth, CV_8UC1);
398		- Point maskPoints[1][3];
399		- maskPoints[0][0] = dstPoint1[0];
400		- maskPoints[0][1] = dstPoint1[1];
401		- maskPoints[0][2] = dstPoint1[2];
402		- const Point* ppt = { maskPoints[0] };
403		- fillConvexPoly(mask, ppt, 3, Scalar(255, 255, 255), 8);
404		-
405		- for (int i = 0; i < dstHeight; i++) {
406		- for (int j = 0; j < dstWidth; j++) {
407		- if (mask.at<uchar>(i,j) == 255) {
408		- if (dst.m().type() == CV_32FC3 \|\| dst.m().type() == CV_8UC3)
409		- dst.m().at<cv::Vec3b>(i,j) = buffer.at<cv::Vec3b>(i,j);
410		- else if (dst.m().type() == CV_32F)
411		- dst.m().at<float>(i,j) = buffer.at<float>(i,j);
412		- else if (dst.m().type() == CV_8U)
413		- dst.m().at<uchar>(i,j) = buffer.at<uchar>(i,j);
414		- else
415		- qFatal("Unsupported pixel format.");
416		- }
417		- }
418		- }
419		-
420		- }
421		-
422		- dst.file = src.file;
423		- dst.file.clearPoints();
424		- dst.file.clearRects();
425		- dst.file.remove("ProcrustesPoints");
426		- dst.file.remove("ProcrustesPadding");
427		- dst.file.remove("ProcrustesBounds");
428		- }
429		-};
430		-
431		-BR_REGISTER(Transform, TextureMapTransform)
432		-
433		-// SynthesizePointsTransform helper class
434		-struct TriangleIndicies
435		-{
436		- int indicies[3];
437		-
438		- TriangleIndicies()
439		- {
440		- indicies[0] = 0;
441		- indicies[1] = 0;
442		- indicies[2] = 0;
443		- }
444		-
445		- TriangleIndicies(QList<int> indexList)
446		- {
447		- assert(indexList.size() == 3);
448		- qSort(indexList);
449		- indicies[0] = indexList[0];
450		- indicies[1] = indexList[1];
451		- indicies[2] = indexList[2];
452		- }
453		-};
454		-
455		-inline bool operator==(const TriangleIndicies &a, const TriangleIndicies &b)
456		-{
457		- return (a.indicies[0] == b.indicies[0]) && (a.indicies[1] == b.indicies[1]) && (a.indicies[2] == b.indicies[2]);
458		-}
459		-
460		-inline uint qHash(const TriangleIndicies &key)
461		-{
462		- return ::qHash(key.indicies[0]) ^ ::qHash(key.indicies[1]) ^ ::qHash(key.indicies[2]);
463		-}
464		-
465		-QDataStream &operator<<(QDataStream &stream, const TriangleIndicies &ti)
466		-{
467		- return stream << ti.indicies[0] << ti.indicies[1] << ti.indicies[2];
468		-}
469		-
470		-QDataStream &operator>>(QDataStream &stream, TriangleIndicies &ti)
471		-{
472		- return stream >> ti.indicies[0] >> ti.indicies[1] >> ti.indicies[2];
473		-}
474		-
475		-/*!
476		- * \ingroup transforms
477		- * \brief Synthesize additional points via triangulation.
478		- * \author Josh Klontz \cite jklontz
479		- */
480		- class SynthesizePointsTransform : public MetadataTransform
481		- {
482		- Q_OBJECT
483		- Q_PROPERTY(float minRelativeDistance READ get_minRelativeDistance WRITE set_minRelativeDistance RESET reset_minRelativeDistance STORED false)
484		- BR_PROPERTY(float, minRelativeDistance, 0) // [0, 1] range controlling whether or not to nearby synthetic points.
485		- // 0 = keep all points, 1 = keep only the most distance point.
486		-
487		- QList<TriangleIndicies> triangles;
488		-
489		- void train(const TemplateList &data)
490		- {
491		- // Because not all triangulations are the same, we have to decide on a canonical set of triangles at training time.
492		- QHash<TriangleIndicies, int> counts;
493		- foreach (const Template &datum, data) {
494		-
495		- const QList<QPointF> points = datum.file.points();
496		- if (points.size() == 0)
497		- continue;
498		- const QList< QList<int> > triangulation = TextureMapTransform::getTriangulation(points, TextureMapTransform::getBounds(points, 10));
499		- if (triangulation.empty())
500		- continue;
501		-
502		- foreach (const QList<int> &indicies, triangulation)
503		- counts[TriangleIndicies(indicies)]++;
504		- }
505		-
506		- triangles.clear();
507		- QHash<TriangleIndicies, int>::const_iterator i = counts.constBegin();
508		- while (i != counts.constEnd()) {
509		- if (3 * i.value() > data.size())
510		- triangles.append(i.key()); // Keep triangles that occur in at least a third of the training instances
511		- ++i;
512		- }
513		-
514		- if (minRelativeDistance > 0) { // Discard relatively small triangles
515		- QVector<float> averageMinDistances(triangles.size());
516		- foreach (const Template &datum, data) {
517		- File dst;
518		- projectMetadata(datum.file, dst);
519		- const QList<QPointF> points = dst.points();
520		-
521		- QVector<float> minDistances(triangles.size());
522		- for (int i=0; i<triangles.size(); i++) {
523		- // Work backwards so that we can also consider distances between synthetic points
524		- const QPointF &point = points[points.size()-1-i];
525		- float minDistance = std::numeric_limits<float>::max();
526		- for (int j=0; j<points.size()-1-i; j++)
527		- minDistance = min(minDistance, sqrtf(powf(point.x() - points[j].x(), 2.f) + powf(point.y() - points[j].y(), 2.f)));
528		- minDistances[triangles.size()-1-i] = minDistance;
529		- }
530		-
531		- const float maxMinDistance = Common::Max(minDistances);
532		- for (int i=0; i<minDistances.size(); i++)
533		- averageMinDistances[i] += (minDistances[i] / maxMinDistance);
534		- }
535		-
536		- const float maxAverageMinDistance = Common::Max(averageMinDistances);
537		- for (int i=averageMinDistances.size()-1; i>=0; i--)
538		- if (averageMinDistances[i] / maxAverageMinDistance < minRelativeDistance)
539		- triangles.removeAt(i);
540		- }
541		-
542		- if (Globals->verbose)
543		- qDebug() << "Kept" << triangles.size() << "of" << counts.size() << "triangles.";
544		- }
545		-
546		- void projectMetadata(const File &src, File &dst) const
547		- {
548		- QList<QPointF> points = src.points();
549		- if (points.size() == 0) {
550		- dst.fte = true;
551		- return;
552		- }
553		-
554		- foreach (const TriangleIndicies &triangle, triangles) {
555		- const QPointF &p0 = points[triangle.indicies[0]];
556		- const QPointF &p1 = points[triangle.indicies[1]];
557		- const QPointF &p2 = points[triangle.indicies[2]];
558		- points.append((p0 + p1 + p2) / 3 /* append the centroid of the triangle */);
559		- }
560		- dst.setPoints(points);
561		- }
562		-
563		- void store(QDataStream &stream) const
564		- {
565		- stream << triangles;
566		- }
567		-
568		- void load(QDataStream &stream)
569		- {
570		- stream >> triangles;
571		- }
572		- };
573		- BR_REGISTER(Transform, SynthesizePointsTransform)
574		-
575		-/*!
576		- * \ingroup initializers
577		- * \brief Initialize Procrustes croppings
578		- * \author Brendan Klare \cite bklare
579		- */
580		-class ProcrustesInitializer : public Initializer
581		-{
582		- Q_OBJECT
583		-
584		- void initialize() const
585		- {
586		- Globals->abbreviations.insert("ProcrustesStasmFace","SelectPoints([17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76])+ProcrustesAlign(padding=6,width=120)+TextureMap+Resize(96,96)");
587		- Globals->abbreviations.insert("ProcrustesStasmEyes","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
588		- Globals->abbreviations.insert("ProcrustesStasmPeriocular","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=10)+TextureMap+Resize(36,48)");
589		- Globals->abbreviations.insert("ProcrustesStasmBrow","SelectPoints([16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
590		- Globals->abbreviations.insert("ProcrustesStasmNose","SelectPoints([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58])+ProcrustesAlign(padding=12)+TextureMap+Resize(36,48)");
591		- Globals->abbreviations.insert("ProcrustesStasmMouth","SelectPoints([59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76])+ProcrustesAlign(padding=10)+TextureMap+Resize(36,48)");
592		- Globals->abbreviations.insert("ProcrustesStasmJaw", "SelectPoints([2,3,4,5,6,7,8,9,10])+ProcrustesAlign(padding=8)+TextureMap+Resize(36,48)");
593		-
594		- Globals->abbreviations.insert("ProcrustesEyes","SelectPoints([19,20,21,22,23,24,25,26,27,28,29,30])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
595		- Globals->abbreviations.insert("ProcrustesNose","SelectPoints([12,13,14,15,16,17,18])+ProcrustesAlign(padding=30)+TextureMap+Resize(36,48)");
596		- Globals->abbreviations.insert("ProcrustesMouth","SelectPoints([31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50])+ProcrustesAlign(padding=6)+TextureMap+Resize(36,48)");
597		- Globals->abbreviations.insert("ProcrustesBrow","SelectPoints([0,1,2,3,4,5,6,7,8,9])+ProcrustesAlign(padding=6)+TextureMap+Resize(24,48)");
598		- Globals->abbreviations.insert("ProcrustesFace","ProcrustesAlign(padding=6,width=120)+TextureMap+Resize(96,96)");
599		-
600		- Globals->abbreviations.insert("ProcrustesLargeStasmFace","ProcrustesAlign(padding=18)+TextureMap+Resize(480,480)");
601		- Globals->abbreviations.insert("ProcrustesLargeStasmEyes","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47])+ProcrustesAlign(padding=8)+TextureMap+Resize(240,480)");
602		- Globals->abbreviations.insert("ProcrustesLargeStasmPeriocular","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=10)+TextureMap+Resize(360,480)");
603		- Globals->abbreviations.insert("ProcrustesLargeStasmBrow","SelectPoints([16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=8)+TextureMap+Resize(240,480)");
604		- Globals->abbreviations.insert("ProcrustesLargeStasmNose","SelectPoints([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58])+ProcrustesAlign(padding=12)+TextureMap+Resize(360,480)");
605		- Globals->abbreviations.insert("ProcrustesLargeStasmMouth","SelectPoints([59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76])+ProcrustesAlign(padding=20)+TextureMap+Resize(360,480)");
606		- Globals->abbreviations.insert("ProcrustesLargeStasmJaw", "SelectPoints([2,3,4,5,6,7,8,9,10])+ProcrustesAlign(padding=8)+TextureMap+Resize(360,480)");
607		- }
608		-};
609		-BR_REGISTER(Initializer, ProcrustesInitializer)
610		-
611		-} // namespace br
612		-
613		-#include "align.moc"

openbr/plugins/imgproc/synthesizekeypoints.cpp 0 → 100644

View file @d54b1db

	1	+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	+ * Copyright 2015 Noblis *
	3	+ * *
	4	+ * Licensed under the Apache License, Version 2.0 (the "License"); *
	5	+ * you may not use this file except in compliance with the License. *
	6	+ * You may obtain a copy of the License at *
	7	+ * *
	8	+ * http://www.apache.org/licenses/LICENSE-2.0 *
	9	+ * *
	10	+ * Unless required by applicable law or agreed to in writing, software *
	11	+ * distributed under the License is distributed on an "AS IS" BASIS, *
	12	+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
	13	+ * See the License for the specific language governing permissions and *
	14	+ * limitations under the License. *
	15	+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	16	+
	17	+#include <opencv2/opencv.hpp>
	18	+#include "openbr/plugins/openbr_internal.h"
	19	+#include "openbr/core/qtutils.h"
	20	+#include "openbr/core/opencvutils.h"
	21	+#include "openbr/core/eigenutils.h"
	22	+#include "openbr/core/common.h"
	23	+#include <QString>
	24	+#include <Eigen/SVD>
	25	+#include <Eigen/Dense>
	26	+
	27	+using namespace std;
	28	+using namespace cv;
	29	+using namespace Eigen;
	30	+
	31	+namespace br
	32	+{
	33	+
	34	+// SynthesizePointsTransform helper class
	35	+struct TriangleIndicies
	36	+{
	37	+ int indicies[3];
	38	+
	39	+ TriangleIndicies()
	40	+ {
	41	+ indicies[0] = 0;
	42	+ indicies[1] = 0;
	43	+ indicies[2] = 0;
	44	+ }
	45	+
	46	+ TriangleIndicies(QList<int> indexList)
	47	+ {
	48	+ assert(indexList.size() == 3);
	49	+ qSort(indexList);
	50	+ indicies[0] = indexList[0];
	51	+ indicies[1] = indexList[1];
	52	+ indicies[2] = indexList[2];
	53	+ }
	54	+};
	55	+
	56	+inline bool operator==(const TriangleIndicies &a, const TriangleIndicies &b)
	57	+{
	58	+ return (a.indicies[0] == b.indicies[0]) && (a.indicies[1] == b.indicies[1]) && (a.indicies[2] == b.indicies[2]);
	59	+}
	60	+
	61	+inline uint qHash(const TriangleIndicies &key)
	62	+{
	63	+ return ::qHash(key.indicies[0]) ^ ::qHash(key.indicies[1]) ^ ::qHash(key.indicies[2]);
	64	+}
	65	+
	66	+QDataStream &operator<<(QDataStream &stream, const TriangleIndicies &ti)
	67	+{
	68	+ return stream << ti.indicies[0] << ti.indicies[1] << ti.indicies[2];
	69	+}
	70	+
	71	+QDataStream &operator>>(QDataStream &stream, TriangleIndicies &ti)
	72	+{
	73	+ return stream >> ti.indicies[0] >> ti.indicies[1] >> ti.indicies[2];
	74	+}
	75	+
	76	+/*!
	77	+ * \ingroup transforms
	78	+ * \brief Synthesize additional points via triangulation.
	79	+ * \author Josh Klontz \cite jklontz
	80	+ */
	81	+class SynthesizePointsTransform : public MetadataTransform
	82	+{
	83	+ Q_OBJECT
	84	+ Q_PROPERTY(float minRelativeDistance READ get_minRelativeDistance WRITE set_minRelativeDistance RESET reset_minRelativeDistance STORED false)
	85	+ BR_PROPERTY(float, minRelativeDistance, 0) // [0, 1] range controlling whether or not to nearby synthetic points.
	86	+ // 0 = keep all points, 1 = keep only the most distance point.
	87	+
	88	+ QList<TriangleIndicies> triangles;
	89	+
	90	+ static QRectF getBounds(const QList<QPointF> &points, int dstPadding)
	91	+ {
	92	+ float srcMinX = FLT_MAX;
	93	+ float srcMinY = FLT_MAX;
	94	+ float srcMaxX = -FLT_MAX;
	95	+ float srcMaxY = -FLT_MAX;
	96	+ foreach (const QPointF &point, points) {
	97	+ if (point.x() < srcMinX) srcMinX = point.x();
	98	+ if (point.y() < srcMinY) srcMinY = point.y();
	99	+ if (point.x() > srcMaxX) srcMaxX = point.x();
	100	+ if (point.y() > srcMaxY) srcMaxY = point.y();
	101	+ }
	102	+
	103	+ const float padding = (srcMaxX - srcMinX) / 80 * dstPadding;
	104	+ return QRectF(qRound(srcMinX - padding), qRound(srcMinY - padding), qRound(srcMaxX - srcMinX + 2 * padding), qRound(srcMaxY - srcMinY + 2 * padding));
	105	+ }
	106	+
	107	+ static int getVertexIndex(const QPointF &trianglePts, const QList<QPointF> &pts)
	108	+ {
	109	+ for (int i = 0; i < pts.size(); i++)
	110	+ // Check points using single precision accuracy to avoid potential rounding error
	111	+ if ((float(trianglePts.x()) == float(pts[i].x())) && (float(trianglePts.y()) == float(pts[i].y())))
	112	+ return i;
	113	+ qFatal("Couldn't identify index of requested point!");
	114	+ return -1;
	115	+ }
	116	+
	117	+ static QList<QList<int> > getTriangulation(const QList<QPointF> &points, const QRectF &bound)
	118	+ {
	119	+ Subdiv2D subdiv(OpenCVUtils::toRect(bound));
	120	+ foreach (const QPointF &point, points) {
	121	+ if (!bound.contains(point))
	122	+ return QList<QList<int> >();
	123	+ subdiv.insert(OpenCVUtils::toPoint(point));
	124	+ }
	125	+
	126	+
	127	+ vector<Vec6f> triangleList;
	128	+ subdiv.getTriangleList(triangleList);
	129	+
	130	+ QList<QList<int> > triangleIndices;
	131	+ foreach (const Vec6f &triangle, triangleList) {
	132	+ bool valid = true;
	133	+ const QPointF vertices[3] = { QPointF(triangle[0], triangle[1]),
	134	+ QPointF(triangle[2], triangle[3]),
	135	+ QPointF(triangle[4], triangle[5]) };
	136	+ for (int j = 0; j < 3; j++)
	137	+ if (vertices[j].x() > bound.right() \|\| vertices[j].y() > bound.bottom() \|\| vertices[j].x() < bound.left() \|\| vertices[j].y() < bound.top()) {
	138	+ valid = false;
	139	+ break;
	140	+ }
	141	+
	142	+ if (valid) {
	143	+ QList<int> tri;
	144	+ for (int j = 0; j < 3; j++)
	145	+ tri.append(getVertexIndex(vertices[j], points));
	146	+ triangleIndices.append(tri);
	147	+ }
	148	+ }
	149	+
	150	+ return triangleIndices;
	151	+ }
	152	+
	153	+ void train(const TemplateList &data)
	154	+ {
	155	+ // Because not all triangulations are the same, we have to decide on a canonical set of triangles at training time.
	156	+ QHash<TriangleIndicies, int> counts;
	157	+ foreach (const Template &datum, data) {
	158	+
	159	+ const QList<QPointF> points = datum.file.points();
	160	+ if (points.size() == 0)
	161	+ continue;
	162	+ const QList< QList<int> > triangulation = getTriangulation(points, getBounds(points, 10));
	163	+ if (triangulation.empty())
	164	+ continue;
	165	+
	166	+ foreach (const QList<int> &indicies, triangulation)
	167	+ counts[TriangleIndicies(indicies)]++;
	168	+ }
	169	+
	170	+ triangles.clear();
	171	+ QHash<TriangleIndicies, int>::const_iterator i = counts.constBegin();
	172	+ while (i != counts.constEnd()) {
	173	+ if (3 * i.value() > data.size())
	174	+ triangles.append(i.key()); // Keep triangles that occur in at least a third of the training instances
	175	+ ++i;
	176	+ }
	177	+
	178	+ if (minRelativeDistance > 0) { // Discard relatively small triangles
	179	+ QVector<float> averageMinDistances(triangles.size());
	180	+ foreach (const Template &datum, data) {
	181	+ File dst;
	182	+ projectMetadata(datum.file, dst);
	183	+ const QList<QPointF> points = dst.points();
	184	+
	185	+ QVector<float> minDistances(triangles.size());
	186	+ for (int i=0; i<triangles.size(); i++) {
	187	+ // Work backwards so that we can also consider distances between synthetic points
	188	+ const QPointF &point = points[points.size()-1-i];
	189	+ float minDistance = std::numeric_limits<float>::max();
	190	+ for (int j=0; j<points.size()-1-i; j++)
	191	+ minDistance = min(minDistance, sqrtf(powf(point.x() - points[j].x(), 2.f) + powf(point.y() - points[j].y(), 2.f)));
	192	+ minDistances[triangles.size()-1-i] = minDistance;
	193	+ }
	194	+
	195	+ const float maxMinDistance = Common::Max(minDistances);
	196	+ for (int i=0; i<minDistances.size(); i++)
	197	+ averageMinDistances[i] += (minDistances[i] / maxMinDistance);
	198	+ }
	199	+
	200	+ const float maxAverageMinDistance = Common::Max(averageMinDistances);
	201	+ for (int i=averageMinDistances.size()-1; i>=0; i--)
	202	+ if (averageMinDistances[i] / maxAverageMinDistance < minRelativeDistance)
	203	+ triangles.removeAt(i);
	204	+ }
	205	+
	206	+ if (Globals->verbose)
	207	+ qDebug() << "Kept" << triangles.size() << "of" << counts.size() << "triangles.";
	208	+ }
	209	+
	210	+ void projectMetadata(const File &src, File &dst) const
	211	+ {
	212	+ QList<QPointF> points = src.points();
	213	+ if (points.size() == 0) {
	214	+ dst.fte = true;
	215	+ return;
	216	+ }
	217	+
	218	+ foreach (const TriangleIndicies &triangle, triangles) {
	219	+ const QPointF &p0 = points[triangle.indicies[0]];
	220	+ const QPointF &p1 = points[triangle.indicies[1]];
	221	+ const QPointF &p2 = points[triangle.indicies[2]];
	222	+ points.append((p0 + p1 + p2) / 3 /* append the centroid of the triangle */);
	223	+ }
	224	+ dst.setPoints(points);
	225	+ }
	226	+
	227	+ void store(QDataStream &stream) const
	228	+ {
	229	+ stream << triangles;
	230	+ }
	231	+
	232	+ void load(QDataStream &stream)
	233	+ {
	234	+ stream >> triangles;
	235	+ }
	236	+};
	237	+
	238	+BR_REGISTER(Transform, SynthesizePointsTransform)
	239	+
	240	+} // namespace br
	241	+
	242	+#include "synthesizekeypoints.moc"
...	...