Peter M. Groen / openbr

Browse Code »

Commit 21807b946114f4e0616a112e461d226061e99e80

Authored by Josh Klontz 2015-03-09 10:53:15 -0400

1 parent 3b38780b

added some alignment transforms

Inline Side-by-side

Showing 1 changed file with 613 additions and 0 deletions

openbr/plugins/core/align.cpp 0 → 100644

View file @21807b9

	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"
...	...