ControlPoints.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class ControlPoints : MonoBehaviour {
    
    private Mesh _mesh;
    private float _epsilon = 0.01f;

    private float _maxDistance = 1.5f;
    private float _scale = 0.8f;

    private List<int>[] _vertexIdentities;
    private List<Vector3>[] _vertexOffsets;

    /*
     * Hand picked Control Points from male_head_obj_MAYA.obj
     */
    /*
     * Left Eye 
     */
    private List<int>[] _lEyeF2v;
    private Vector3[] _lEyeF2world;
    private Vector3[] _lEyeFCP = new Vector3[] {
        new Vector3(0.167f, 1.993f, 0.680f),
        new Vector3(0.241f, 2.049f, 0.704f),
        new Vector3(0.304f, 2.039f, 0.701f),
        new Vector3(0.394f, 2.006f, 0.638f),
        new Vector3(0.328f, 1.967f, 0.684f),
        new Vector3(0.233f, 1.983f, 0.680f)
    };
    public Vector3[] LEyeFCP {
        get { return _lEyeF2world; }    
    }
    /*
     * Left Eyebrow 
     */
    private List<int>[] _lEyebrow2v;
    private Vector3[] _lEyebrow2world;
    private Vector3[] _lEyebrowCP = new Vector3[] {
        new Vector3(0.152f, 2.111f, 0.834f),
        new Vector3(0.184f, 2.202f, 0.832f),
        new Vector3(0.298f, 2.234f, 0.776f),
        new Vector3(0.389f, 2.240f, 0.699f),
        new Vector3(0.464f, 2.184f, 0.601f),
        new Vector3(0.438f, 2.121f, 0.668f),
        new Vector3(0.438f, 2.121f, 0.668f),
        new Vector3(0.354f, 2.162f, 0.745f),
        new Vector3(0.271f, 2.147f, 0.796f),
    };
    public Vector3[] LEyebrowCP {
        get { return _lEyebrow2world; }    
    }
    /*
     * Right Eye
     */
    private List<int>[] _rEyeF2v;
    private Vector3[] _rEyeF2world;
    private Vector3[] _rEyeFCP = new Vector3[] {
        new Vector3(-0.167f, 1.993f, 0.680f),
        new Vector3(-0.241f, 2.049f, 0.704f),
        new Vector3(-0.304f, 2.039f, 0.701f),
        new Vector3(-0.394f, 2.006f, 0.638f),
        new Vector3(-0.328f, 1.967f, 0.684f),
        new Vector3(-0.233f, 1.983f, 0.689f)
    };
    public Vector3[] REyeFCP {
        get { return _rEyeF2world; }
    }
    /*
     * Right Eyebrow
     */
    private List<int>[] _rEyebrow2v;
    private Vector3[] _rEyebrow2world;
    private Vector3[] _rEyebrowCP = new Vector3[] {
        new Vector3(-0.152f, 2.111f, 0.834f),
        new Vector3(-0.184f, 2.202f, 0.832f),
        new Vector3(-0.298f, 2.234f, 0.776f),
        new Vector3(-0.389f, 2.240f, 0.699f),
        new Vector3(-0.464f, 2.184f, 0.601f),
        new Vector3(-0.438f, 2.121f, 0.668f),
        new Vector3(-0.438f, 2.121f, 0.668f),
        new Vector3(-0.354f, 2.162f, 0.745f),
        new Vector3(-0.271f, 2.147f, 0.796f),
    };
    public Vector3[] REyebrowCP {
        get { return _rEyebrow2world; }    
    }

    /*
     * Eye Side
     */
    private List<int>[] _eyeS2v;
    private Vector3[] _eyeS2world;
    private Vector3[] _eyeSCP = new Vector3[] {
        new Vector3(0.241f, 2.049f, 0.704f),
        new Vector3(0.286f, 1.968f, 0.693f),
        new Vector3(0.394f, 2.006f, 0.638f)
    };
    public Vector3[] EyeSCP {
        get { return _eyeS2world; }    
    }

    /*
     * Mouth 
     */
    private List<int>[] _mouthF2v;
    private Vector3[] _mouthF2world;
    private Vector3[] _mouthFCP = new Vector3[] {
//      new Vector3(0.000f, 1.490f, 0.949f),
        new Vector3(0.052f, 1.508f, 0.943f),
//      new Vector3(0.141f, 1.494f, 0.901f),
        new Vector3(0.245f, 1.426f, 0.763f),
        new Vector3(0.145f, 1.494f, 0.901f),
        new Vector3(0.068f, 1.356f, 0.901f),
//      new Vector3(0.068f, 1.356f, 0.901f),
//      new Vector3(-0.068f, 1.356f, 0.901f),
        new Vector3(-0.068f, 1.356f, 0.901f),
        new Vector3(-0.145f, 1.494f, 0.901f),
        new Vector3(-0.245f, 1.426f, 0.763f),
//      new Vector3(-0.141f, 1.494f, 0.901f),
        new Vector3(-0.052f, 1.508f, 0.943f)
    };
    public Vector3[] MouthFCP {
        get { return _mouthF2world; }    
    }

    /*
     * Mouth Side
     */
    private List<int>[] _mouthS2v;
    private Vector3[] _mouthS2world;
    private Vector3[] _mouthSCP = new Vector3[] {
        new Vector3(0.245f, 1.426f, 0.763f),
        new Vector3(0.068f, 1.356f, 0.901f),
        new Vector3(0.000f, 1.490f, 0.949f)
    };
    public Vector3[] MouthSCP {
        get { return _mouthS2world; }    
    }

    /*
     * Contour 
     */
    private List<int>[] _contourF2v;
    private Vector3[] _contourF2world;
    private Vector3[] _contourFCP = new Vector3[] {
        new Vector3(0.000f, 2.944f, -0.038f),
        new Vector3(0.406f, 2.837f, -0.082f),
        new Vector3(0.618f, 2.290f, 0.075f),
        new Vector3(0.542f, 1.742f, 0.256f),
        new Vector3(0.368f, 1.253f, 0.457f),
        new Vector3(0.000f, 1.084f, 0.855f),
        new Vector3(-0.368f, 1.253f, 0.457f),
        new Vector3(-0.542f, 1.742f, 0.256f),
        new Vector3(-0.618f, 2.290f, 0.075f),
        new Vector3(-0.406f, 2.837f, -0.082f)
    };
    public Vector3[] ContourFCP {
        get { return _contourF2world; }    
    }

    /*
     * Contour Side
     */
    private List<int>[] _contourS2v;
    private Vector3[] _contourS2world;
    private Vector3[] _contourSCP = new Vector3[] {
        new Vector3(0.000f, 1.084f, 0.855f),
        new Vector3(0.000f, 1.745f, 1.083f),
        new Vector3(0.000f, 2.382f, 0.815f),
        new Vector3(0.000f, 2.944f, -0.038f),
        new Vector3(0.000f, 2.499f, -0.841f),
        new Vector3(0.000f, 1.587f, -0.799f)
    };
    public Vector3[] ContourSCP {
        get { return _contourS2world; }    
    }

    private bool _enableRotation;
    public bool EnableRotation {
        set { _enableRotation = value; }
        get { return _enableRotation; }
    }
    private float _sensitivity;
    private Vector3 _mouseReference;
    private Vector3 _mouseOffset;
    private Vector3 _rotation;
    private bool _isRotating;
    
    void Start () {
        _mesh = GetComponent<MeshFilter>().mesh;

        Vector3[] vertices = _mesh.vertices;
        /*Color[] colors = new Color[vertices.Length];
        for (int i = 0; i < vertices.Length; i++) {
            colors[i] = Color.white;
        }
        _mesh.colors = colors;*/

        _vertexOffsets = new List<Vector3>[vertices.Length];

        //search for duplicate vertices
        _vertexIdentities = new List<int>[vertices.Length];
        for (int i = 0; i < vertices.Length; i++) {
            for (int j = 0; j < vertices.Length; j++) {
                
                if (vertices [i].x == vertices [j].x
                    && vertices [i].y == vertices [j].y
                    && vertices [i].z == vertices [j].z) {
                    
                    if (_vertexIdentities [i] == null) {
                        _vertexIdentities [i] = new List<int> ();
                    }
                    _vertexIdentities [i].Add (j);
                }
            }
        }

        FindControlPoints (_lEyeFCP, out _lEyeF2v, out _lEyeF2world);
        FindControlPoints (_rEyeFCP, out _rEyeF2v, out _rEyeF2world);

        FindControlPoints (_lEyebrowCP, out _lEyebrow2v, out _lEyebrow2world);
        FindControlPoints (_rEyebrowCP, out _rEyebrow2v, out _rEyebrow2world);

        FindControlPoints (_mouthFCP, out _mouthF2v, out _mouthF2world);
        FindControlPoints (_contourFCP, out _contourF2v, out _contourF2world);

        /*
         * Find Side CP
         */
        RotateToProfile ();

        FindControlPoints (_lEyebrowCP, out _lEyebrow2v, out _lEyebrow2world);
        FindControlPoints (_rEyebrowCP, out _rEyebrow2v, out _rEyebrow2world);
        FindControlPoints (_mouthSCP, out _mouthS2v, out _mouthS2world);
        FindControlPoints (_eyeSCP, out _eyeS2v, out _eyeS2world);
        FindControlPoints (_contourSCP, out _contourS2v, out _contourS2world);

        RotateToFront ();

        _sensitivity = 0.2f;
        _rotation = Vector3.zero;
    }

    void Update() {
        if(_enableRotation && Input.GetMouseButtonDown(0)) {
            // rotating flag
            _isRotating = true;
            // store mouse
            _mouseReference = Input.mousePosition;
        }

        if(Input.GetMouseButtonUp(0))
            _isRotating = false;

        if(_isRotating)
        {
            // offset
            _mouseOffset = (Input.mousePosition - _mouseReference);

            _rotation.y = -(_mouseOffset.x) * _sensitivity;
            _rotation.x = -(_mouseOffset.y) * _sensitivity;

            // rotate
            transform.eulerAngles += _rotation;
            // store mouse
            _mouseReference = Input.mousePosition;
        }
    }

    public Vector3[] CalculateOffset(Vector3[] startPoints, Vector3[] endPoints, bool side = false) {

        if(side) RotateToProfile ();

        Vector3[] offsets = new Vector3[startPoints.Length];
        for (int i = 0; i < startPoints.Length; i++) {
            
            Vector3 startM = transform.InverseTransformPoint(startPoints[i]);
            Vector3 endM = transform.InverseTransformPoint(endPoints[i]);
            offsets[i] = endM - startM;
        }

        if(side) RotateToFront ();

        return offsets;
    }
    
    public void DeformContour(Vector3[] offsets) {
        DeformModel(offsets, _contourF2v, new List<int>() { 4, 5, 6 } );
    }

    public void DeformLEye(Vector3[] offsets) {
        DeformModel(offsets, _lEyeF2v);
    }

    public void DeformREye(Vector3[] offsets) {
        DeformModel(offsets, _rEyeF2v);
    }

    public void DeformLEyeBrow(Vector3[] offsets) {
        DeformModel(offsets, _lEyebrow2v);
    }

    public void DeformREyeBrow(Vector3[] offsets) {
        DeformModel(offsets, _rEyebrow2v);
    }
    
    public void DeformMouth(Vector3[] offsets) {
        DeformModel(offsets, _mouthF2v);
    }

    private void DeformModel(Vector3[] offsets, List<int>[] idxCP) {
        DeformModel(offsets, idxCP, new List<int>());
    }

    private void DeformModel(Vector3[] offsets, List<int>[] idxCP, List<int> ignore) {
        for(int i = 0; i < offsets.Length; i++) {

            if(ignore.IndexOf(i) != -1) continue;

            MoveVertex (idxCP [i], offsets[i]);
        }
    }

    public void ApplyDeformation() {
    
        Vector3[] vertices = _mesh.vertices;
        Vector2[] uvs = _mesh.uv;

        for(int i = 0; i < vertices.Length; i++) {
            List<Vector3> offsets = _vertexOffsets[i];

            //Calculate new UV coordinates
            Vector3 origin = transform.TransformPoint(vertices[i]);
            Vector3 direction = new Vector3(vertices[i].x, 0.0f, vertices[i].z);
            direction.Normalize();

            //Hit with cylinder;
            Ray r = new Ray(origin, direction);
            RaycastHit hit;
            if (Physics.Raycast (r, out hit))
                uvs[i] = hit.textureCoord;
            
            if(offsets == null) continue;

            Vector3 sum = Vector3.zero;

            foreach(Vector3 offset in offsets) {
                sum += offset * 2.0f;
            }

            //Apply average deformation
            vertices[i] += sum / offsets.Count;
        }

        _mesh.vertices = vertices;
        _mesh.uv = uvs;
    }

    void MoveVertex(List<int> vertexIndices, Vector3 transpose) {

        //Move all Control Points (on same pos)
        for (int i = 0; i < vertexIndices.Count; i++) {
            if(_vertexOffsets[vertexIndices[i]] == null)
                _vertexOffsets[vertexIndices[i]] = new List<Vector3>();

            _vertexOffsets[vertexIndices[i]].Add (transpose);
        }
        //Take first index as reference control point
        int controlPointIndex = vertexIndices [0];

        List<int> neighbours = GetNeighbors (controlPointIndex);
        //Create list of indices that should not be tested again
        List<int> ignore = new List<int> (neighbours);
        ignore.AddRange (vertexIndices);

        //Move all neighbours
        for (int i = 0; i < neighbours.Count; i++) {
            int neighbourIndex = neighbours[i];

            //all neighbour identities should not be tested again
            ignore.AddRange (_vertexIdentities[neighbourIndex]);

            float distance = Vector3.Distance (_mesh.vertices[neighbourIndex], _mesh.vertices[controlPointIndex]);

            //Debug.Log ("Distance " + vertexIndices[0] + " to " + neighbours[i] + " is " + distance);

            if(distance > _maxDistance) continue;

            float distProb = Gauss(0);

            //Move the neighbor
            MoveVertexRec(controlPointIndex, neighbourIndex, transpose * distProb, ref ignore);
        }
    }

    void MoveVertexRec(int controlPointIndex, int currentVertexIndex, Vector3 transpose, ref List<int> ignore) {
    
        //Save offset for all Vertex identities
        for (int i = 0; i < _vertexIdentities[currentVertexIndex].Count; i++) {
            if(_vertexOffsets[_vertexIdentities[currentVertexIndex][i]] == null)
                _vertexOffsets[_vertexIdentities[currentVertexIndex][i]] = new List<Vector3>();
            
            _vertexOffsets[_vertexIdentities[currentVertexIndex][i]].Add (transpose);
        }
        List<int> neighbours = GetNeighbors (currentVertexIndex);
        List<int> oldIgnore = new List<int> (ignore);
        ignore.AddRange(neighbours);

        //Save offset for all neighbours
        for (int i = 0; i < neighbours.Count; i++) {
            int neighborIndex = neighbours[i];

            if(oldIgnore.IndexOf(neighborIndex) != -1) continue;

            //all neighbor identities should not be tested again
            ignore.AddRange (_vertexIdentities[neighborIndex]);

            float distance = Vector3.Distance (_mesh.vertices[neighborIndex], _mesh.vertices[controlPointIndex]);

            //Debug.Log ("Distance " + controlPointIndex + " to " + neighborIndex + " is " + distance);

            if(distance > _maxDistance) continue;

            float distProb = Gauss(distance * _scale);

            //Move the neighbor
            MoveVertexRec(controlPointIndex, neighborIndex, transpose * distProb, ref ignore);
        }
    }

    void FindControlPoints(Vector3[] cp, out List<int>[] cp2v, out Vector3[] cp2world) {
        cp2v = new List<int>[cp.Length];
        cp2world = new Vector3[cp.Length];
        Vector3[] vertices = _mesh.vertices;

        int found = 0;

        for (int i = 0; i < vertices.Length; i++) {
            //search for control points
            for (int j = 0; j < cp.Length; j++) {

                if(_epsilon > Mathf.Abs(vertices[i].x - cp[j].x)
                   && _epsilon > Mathf.Abs(vertices[i].y - cp[j].y) 
                   && _epsilon > Mathf.Abs(vertices[i].z - cp[j].z)) {

                    //Debug.Log (cp[j] + " " + vertices[i]);

                    if(cp2v[j] == null) {
                        cp2v[j] = new List<int>();

                        //Save WordPoint just once!
                        cp2world[j] = transform.TransformPoint(vertices[i]);
                    }
                    cp2v[j].Add(i);

                    found++;
                }
            }
        }

        if (found < cp.Length) {
            throw new MissingComponentException ("Could not find all control points (" + found + "/" + cp.Length + ")");
        }
    }

    float Gauss(float x)
    {
        float sigma = 0.5f;
        float a = 1.0f / (sigma * Mathf.Sqrt (2.0f * Mathf.PI));
        return a * Mathf.Exp ( - Mathf.Pow(x, 2.0f) / (2.0f * Mathf.Pow(sigma, 2.0f)) );

        //paper
        //return Mathf.Exp ( - Mathf.Pow(x, 2.0f) / (sigma) );
    }

    List<int> GetNeighbors(int index) {
        int[] triangles = _mesh.triangles;

        List<int> verts = new List<int>();
        for(int i = 0; i < triangles.Length / 3; i++){
            // see if the triangle contains the index
            bool found = false;
            for(int j = 0; j < 3; j++){
                int cur = triangles[i * 3 + j];
                if(cur == index) found = true;
            }
            // if we found the index in the triangle, append the others.
            if(found){
                for(int j = 0; j < 3 ; j++){
                    int cur = triangles[i * 3 + j];
                    if(verts.IndexOf(cur) == -1 && cur != index){
                        verts.Add(cur);
                    }
                }
            }
        }
        return verts;
    }

    public void RotateToProfile() {
        transform.Rotate (Vector3.up * 90.0f);
    }
    void RotateToFront() {
        transform.Rotate (Vector3.up * -90.0f);
    }
}