MStatus PushDeformer::deform(MDataBlock& dataBlock,
MItGeometry& itGeo,
const MMatrix& localToWorldMatrix,
unsigned int geomIndex)
{
MStatus status;
//get attribute handles
double bulgeAmount = dataBlock.inputValue(aAmount, &status).asDouble();
CHECK_MSTATUS_AND_RETURN_IT(status);
m_taskData.envelope = dataBlock.inputValue(envelope, &status).asFloat();
CHECK_MSTATUS_AND_RETURN_IT(status);
bool useStressV = dataBlock.inputValue(aUseStress, &status).asBool();
CHECK_MSTATUS_AND_RETURN_IT(status);
int multiThreadingType = dataBlock.inputValue(aMultiThreadingType, &status).asBool();
CHECK_MSTATUS_AND_RETURN_IT(status);
if (m_taskData.envelope <= 0.001)
{
return MS::kSuccess;
}
// if the use stress plug is turned on pull
MDoubleArray stressV;
if (useStressV == true)
{
//pull out the raw data as an Mobject
MObject stressMap = dataBlock.inputValue(aStressMap, &status).data();
CHECK_MSTATUS_AND_RETURN_IT(status);
MFnDoubleArrayData stressDataFn(stressMap);
m_taskData.stressV = stressDataFn.array();
}
//retrieve the handle to the output array attribute
MArrayDataHandle hInput = dataBlock.outputArrayValue(input, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
//get the input array index handle
status = hInput.jumpToElement(geomIndex);
//get the handle of geomIndex attribute
MDataHandle hInputElement = hInput.outputValue(&status);
CHECK_MSTATUS_AND_RETURN_IT(status);
//Get the MObject of the input geometry of geomindex
MObject oInputGeom = hInputElement.child(inputGeom).asMesh();
MFnMesh fnMesh(oInputGeom, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
fnMesh.getVertexNormals(false, m_taskData.normals, MSpace::kWorld);
itGeo.allPositions(m_taskData.points, MSpace::kWorld);
//MGlobal::displayInfo( "test" );
/*for (int i = 0; i < itGeo.count(); i++)
{
MGlobal::displayInfo( MFnAttribute(weightList).isArray );
}*/
m_taskData.bulgeAmount = bulgeAmount;
if(multiThreadingType == 1)
{
ThreadData* pThreadData = createThreadData( NUM_TASKS, &m_taskData );
MThreadPool::newParallelRegion( createTasks, (void*)pThreadData );
itGeo.setAllPositions(m_taskData.points);
delete [] pThreadData;
return MS::kSuccess;
}
else if(multiThreadingType == 2)
{
tbb::parallel_for(size_t(0), size_t(itGeo.count()), [this](size_t i)
{
//const float w = weightValue(dataBlock, geomIndex, i);
const float w = 1.0;
if (m_taskData.useStressV == true && (m_taskData.stressV.length() > 0))
{
//deform
m_taskData.points[i] += (MVector(m_taskData.normals[i]) * m_taskData.bulgeAmount * m_taskData.envelope * w * m_taskData.stressV[i]);
}
else
{
//deform
m_taskData.points[i] += m_taskData.normals[i] * m_taskData.bulgeAmount * m_taskData.envelope * w;
}
});
}
//
else if(multiThreadingType == 3)
#pragma omp parallel for
for (int i = 0; i < itGeo.count(); i++)
{
float w = weightValue(dataBlock, geomIndex, itGeo.index());
if (useStressV == true && (stressV.length() > 0))
{
//deform
m_taskData.points[i] += (MVector(m_taskData.normals[i]) * bulgeAmount * m_taskData.envelope * w * m_taskData.stressV[i]);
}
else
{
//deform
m_taskData.points[i] += m_taskData.normals[i] * bulgeAmount * m_taskData.envelope * w;
}
}
else
{
for (; !itGeo.isDone(); itGeo.next())
{
float w = weightValue(dataBlock, geomIndex, itGeo.index());
if (useStressV == true && (stressV.length() > 0))
{
//deform
m_taskData.points[itGeo.index()] += (MVector(m_taskData.normals[itGeo.index()]) * bulgeAmount * m_taskData.envelope * w * m_taskData.stressV[itGeo.index()]);
}
else
{
//deform
m_taskData.points[itGeo.index()] += m_taskData.normals[itGeo.index()] * bulgeAmount * m_taskData.envelope * w;
}
}
}
itGeo.setAllPositions(m_taskData.points);
return MS::kSuccess;
}
MStatus sphericalBlendShape::deform(MDataBlock& data, MItGeometry& itGeo, const MMatrix& mat, unsigned int geomIndex)
{
MStatus status = MS::kSuccess;
float env = data.inputValue(envelope).asFloat();
if (env <= 0.0f) {
return MS::kSuccess;
}
MMatrix spaceMatrix = data.inputValue(aSpaceMatrix).asMatrix();
short poleAxis = data.inputValue(aPoleAxis).asShort();
short seamAxis = data.inputValue(aSeamAxis).asShort();
short method = data.inputValue(aMethod).asShort();
MMatrix warpMatrix = data.inputValue(aWarpMatrix).asMatrix();
MTransformationMatrix warpTransMatrix(warpMatrix);
MPoint warpPoint = warpTransMatrix.getTranslation(MSpace::kWorld);
status = checkPoleAndSeam(poleAxis, seamAxis);
CHECK_MSTATUS_AND_RETURN_IT(status);
MMatrix invGeoMatrix = mat.inverse();
MMatrix invSpaceMatrix = spaceMatrix.inverse();
MPointArray defPoints;
MPoint* defPoint;
MPoint inPoint, returnPoint;
itGeo.allPositions(defPoints);
unsigned int count = defPoints.length();
unsigned int i;
switch(method) {
// XYZ to Spherical
case 0:
for (i=0; i<count; i++) {
defPoint = &defPoints[i];
inPoint = *defPoint;
// bring the point into world space
inPoint *= invGeoMatrix;
// bring into local space of the input matrix
inPoint *= invSpaceMatrix;
cartesianToSpherical(inPoint, poleAxis, seamAxis, warpPoint, returnPoint);
// bring the point back into world space
returnPoint *= spaceMatrix;
// bring the point back into local space
returnPoint *= mat;
lerp(*defPoint, returnPoint, env, *defPoint);
}
break;
case 1:
for (i=0; i<count; i++) {
defPoint = &defPoints[i];
inPoint = *defPoint;
// bring the point into world space
inPoint *= invGeoMatrix;
// bring into local space of the input matrix
inPoint *= invSpaceMatrix;
sphericalToCartesian(inPoint, poleAxis, seamAxis, warpPoint, returnPoint);
// bring the point back into world space
returnPoint *= spaceMatrix;
// bring the point back into local space
returnPoint *= mat;
lerp(*defPoint, returnPoint, env, *defPoint);
}
break;
}
itGeo.setAllPositions(defPoints);
return MS::kSuccess;
}
MStatus nwayDeformerNode::deform( MDataBlock& data, MItGeometry& itGeo, const MMatrix &localToWorldMatrix, unsigned int mIndex )
{
// clock_t clock_start=clock();
MObject thisNode = thisMObject();
MStatus status;
MThreadUtils::syncNumOpenMPThreads(); // for OpenMP
MArrayDataHandle hBlendMesh = data.inputArrayValue(aBlendMesh);
short numIter = data.inputValue( aIteration ).asShort();
short nblendMode = data.inputValue( aBlendMode ).asShort();
short ntetMode = data.inputValue( aTetMode ).asShort();
double visualisationMultiplier = data.inputValue(aVisualisationMultiplier).asDouble();
bool visualiseEnergy = data.inputValue( aVisualiseEnergy ).asBool();
bool nrotationCosistency = data.inputValue( aRotationConsistency ).asBool();
if( nrotationCosistency != rotationCosistency) {
numMesh = 0;
rotationCosistency = nrotationCosistency;
}
MPointArray Mpts;
itGeo.allPositions(Mpts);
int nnumMesh = hBlendMesh.elementCount();
int numPts = Mpts.length();
int numTet = (int)tetList.size()/4;
// initialisation
if(tetMode != ntetMode) {
// clock_t clock_start=clock();
tetMode = ntetMode;
numMesh = 0;
// point list
pts.resize(numPts);
for(int i=0; i<numPts; i++) {
pts[i] << Mpts[i].x, Mpts[i].y, Mpts[i].z;
}
std::vector<Matrix4d> P;
getMeshData(data, input, inputGeom, mIndex, tetMode, pts, tetList, faceList, edgeList, vertexList, P);
dim = removeDegenerate(tetMode, numPts, tetList, faceList, edgeList, vertexList, P);
makeAdjacencyList(tetMode, tetList, edgeList, vertexList, adjacencyList);
makeTetMatrix(tetMode, pts, tetList, faceList, edgeList, vertexList, P);
// prepare ARAP solver
numTet = (int)tetList.size()/4;
PI.resize(numTet);
for(int i=0; i<numTet; i++) {
PI[i] = P[i].inverse().eval();
}
std::vector<double> tetWeight(numTet,1.0);
std::vector< std::map<int,double> > constraint(0);
//constraint[0][0]=1.0;
isError = ARAPprecompute(PI, tetList, tetWeight, constraint, EPSILON, dim, constraintMat, solver);
// MString es="Init timing: ";
// double timing=(double)(clock()- clock_start)/CLOCKS_PER_SEC;
// es += timing;
// MGlobal::displayInfo(es);
}
if(isError>0) return MS::kFailure;
// if blend mesh is added, compute log for each tet
logR.resize(nnumMesh);
logS.resize(nnumMesh);
R.resize(nnumMesh);
S.resize(nnumMesh);
GL.resize(nnumMesh);
logGL.resize(nnumMesh);
quat.resize(nnumMesh);
L.resize(nnumMesh);
// for recomputation of parametrisation
if(numMesh>nnumMesh || nblendMode != blendMode) {
numMesh =0;
blendMode = nblendMode;
}
for(int j=numMesh; j<nnumMesh; j++) {
hBlendMesh.jumpToElement(j);
MFnMesh blendMesh(hBlendMesh.inputValue().asMesh());
MPointArray Mbpts;
blendMesh.getPoints( Mbpts );
if(numPts != Mbpts.length()) {
MGlobal::displayInfo("incompatible mesh");
return MS::kFailure;
}
std::vector<Vector3d> bpts(numPts);
for(int i=0; i<numPts; i++) {
bpts[i] << Mbpts[i].x, Mbpts[i].y, Mbpts[i].z;
}
std::vector<Matrix4d> Q(numTet);
makeTetMatrix(tetMode, bpts, tetList, faceList, edgeList, vertexList, Q);
logR[j].resize(numTet);
logS[j].resize(numTet);
R[j].resize(numTet);
S[j].resize(numTet);
GL[j].resize(numTet);
logGL[j].resize(numTet);
quat[j].resize(numTet);
L[j].resize(numTet);
for(int i=0; i<numTet; i++) {
Matrix4d aff=PI[i]*Q[i];
GL[j][i]=aff.block(0,0,3,3);
L[j][i]=transPart(aff);
parametriseGL(GL[j][i], logS[j][i] ,R[j][i]);
}
if( blendMode == BM_LOG3) {
for(int i=0; i<numTet; i++)
logGL[j][i]=GL[j][i].log();
} else if( blendMode == BM_SQL) {
for(int i=0; i<numTet; i++) {
S[j][i]=expSym(logS[j][i]);
Quaternion<double> q(R[j][i].transpose());
quat[j][i] << q.x(), q.y(), q.z(), q.w();
}
} else if( blendMode == BM_SlRL) {
for(int i=0; i<numTet; i++) {
S[j][i]=expSym(logS[j][i]);
}
}
// traverse tetrahedra to compute continuous log of rotation
if(rotationCosistency) {
std::set<int> remain;
std::queue<int> later;
// load initial rotation from the attr
Matrix3d initR;
double angle = data.inputValue(aInitRotation).asDouble();
initR << 0,M_PI * angle/180.0,0, -M_PI * angle/180.0,0,0, 0,0,0;
std::vector<Matrix3d> prevSO(numTet, initR);
// create the adjacency graph to traverse
for(int i=0; i<numTet; i++) {
remain.insert(remain.end(),i);
}
while(!remain.empty()) {
int next;
if( !later.empty()) {
next = later.front();
later.pop();
remain.erase(next);
} else {
next = *remain.begin();
remain.erase(remain.begin());
}
logR[j][next]=logSOc(R[j][next],prevSO[next]);
for(int k=0; k<adjacencyList[next].size(); k++) {
int f=adjacencyList[next][k];
if(remain.erase(f)>0) {
prevSO[f]=logR[j][next];
later.push(f);
}
}
}
} else {
for(int i=0; i<numTet; i++)
logR[j][i] = logSO(R[j][i]);
}
}
numMesh=nnumMesh;
if(numMesh == 0) return MS::kSuccess;
// load weights
std::vector<double> weight(numMesh);
MArrayDataHandle hWeight = data.inputArrayValue(aWeight);
if(hWeight.elementCount() != numMesh) {
return MS::kSuccess;
}
for(int i=0; i<numMesh; i++) {
hWeight.jumpToArrayElement(i);
weight[i]=hWeight.inputValue().asDouble();
}
// compute ideal affine
std::vector<Vector3d> new_pts(numPts);
std::vector<Matrix4d> A(numTet);
std::vector<Matrix3d> AR(numTet),AS(numTet);
std::vector<Vector3d> AL(numTet);
blendMatList(L, weight, AL);
if(blendMode==BM_SRL) {
blendMatList(logR, weight, AR);
blendMatList(logS, weight, AS);
#pragma omp parallel for
for(int i=0; i<numTet; i++) {
AR[i] = expSO(AR[i]);
AS[i] = expSym(AS[i]);
}
} else if(blendMode == BM_LOG3) { // log
blendMatList(logGL, weight, AR);
#pragma omp parallel for
for(int i=0; i<numTet; i++) {
AR[i] = AR[i].exp();
AS[i] = Matrix3d::Identity();
}
} else if(blendMode == BM_SQL) { // quaternion
std::vector<Vector4d> Aq(numTet);
blendMatLinList(S, weight, AS);
blendQuatList(quat, weight, Aq);
#pragma omp parallel for
for(int i=0; i<numTet; i++) {
Quaternion<double> Q(Aq[i]);
AR[i] = Q.matrix().transpose();
}
} else if(blendMode == BM_SlRL) { // expSO+linear Sym
blendMatList(logR, weight, AR);
blendMatLinList(S, weight, AS);
#pragma omp parallel for
for(int i=0; i<numTet; i++) {
AR[i] = expSO(AR[i]);
}
} else if(blendMode == BM_AFF) { // linear
blendMatLinList(GL, weight, AR);
for(int i=0; i<numTet; i++) {
AS[i] = Matrix3d::Identity();
}
} else {
return MS::kFailure;
}
MatrixXd G(dim+1,3),Sol;
std::vector<double> tetEnergy(numTet);
// iterate to determine vertices position
for(int k=0; k<numIter; k++) {
for(int i=0; i<numTet; i++) {
A[i]=pad(AS[i]*AR[i],AL[i]);
}
// solve ARAP
std::vector<Vector3d> constraintVector(0);
std::vector<double> tetWeight(numTet,1.0);
//constraintVector[0]=pts[0];
ARAPSolve(A, PI, tetList, tetWeight, constraintVector, EPSILON, dim, constraintMat, solver, Sol);
// set new vertices position
for(int i=0; i<numPts; i++) {
new_pts[i][0]=Sol(i,0);
new_pts[i][1]=Sol(i,1);
new_pts[i][2]=Sol(i,2);
}
// if iteration continues
if(k+1<numIter || visualiseEnergy) {
std::vector<Matrix4d> Q(numTet);
makeTetMatrix(tetMode, new_pts, tetList, faceList, edgeList, vertexList, Q);
Matrix3d S,R;
#pragma omp parallel for
for(int i=0; i<numTet; i++) {
polarHigham((PI[i]*Q[i]).block(0,0,3,3), S, AR[i]);
tetEnergy[i] = (S-AS[i]).squaredNorm();
}
}
}
// set new vertex position
for(int i=0; i<numPts; i++) {
Mpts[i].x=Sol(i,0);
Mpts[i].y=Sol(i,1);
Mpts[i].z=Sol(i,2);
}
itGeo.setAllPositions(Mpts);
// set vertex color according to ARAP energy
if(visualiseEnergy) {
std::vector<double> ptsEnergy;
makePtsWeightList(tetMode, numPts, tetList, faceList, edgeList, vertexList, tetEnergy, ptsEnergy);
//double max_energy = *std::max_element(ptsEnergy.begin(), ptsEnergy.end());
outputAttr(data, aEnergy, ptsEnergy);
for(int i=0; i<numPts; i++) {
ptsEnergy[i] *= visualisationMultiplier; // or /= max_energy
}
visualise(data, outputGeom, ptsEnergy);
}
// MString es="Runtime timing: ";
// double timing=(double)(clock()- clock_start)/CLOCKS_PER_SEC;
// es += timing;
// MGlobal::displayInfo(es);
return MS::kSuccess;
}
MStatus sgBulgeDeformer::deform(MDataBlock& dataBlock, MItGeometry& iter, const MMatrix& mtx, unsigned int index)
{
MStatus status;
float bulgeWeight = dataBlock.inputValue(aBulgeWeight).asFloat();
double bulgeRadius = dataBlock.inputValue(aBulgeRadius).asDouble();
MArrayDataHandle hArrInputs = dataBlock.inputArrayValue(aBulgeInputs);
MPointArray allPositions;
iter.allPositions(allPositions);
if (mem_resetElements)
{
unsigned int elementCount = hArrInputs.elementCount();
mem_meshInfosInner.resize(mem_maxLogicalIndex);
mem_meshInfosOuter.resize(mem_maxLogicalIndex);
for (unsigned int i = 0; i < elementCount; i++, hArrInputs.next())
{
MDataHandle hInput = hArrInputs.inputValue();
MDataHandle hMatrix = hInput.child(aMatrix);
MDataHandle hMesh = hInput.child(aMesh);
MMatrix mtxMesh = hMatrix.asMatrix();
MObject oMesh = hMesh.asMesh();
MFnMeshData meshDataInner, meshDataOuter;
MObject oMeshInner = meshDataInner.create();
MObject oMeshOuter = meshDataOuter.create();
MFnMesh fnMesh;
fnMesh.copy(oMesh, oMeshInner);
fnMesh.copy(oMesh, oMeshOuter);
sgMeshInfo* newMeshInfoInner = new sgMeshInfo(oMeshInner, hMatrix.asMatrix());
sgMeshInfo* newMeshInfoOuter = new sgMeshInfo(oMeshOuter, hMatrix.asMatrix());
mem_meshInfosInner[hArrInputs.elementIndex()] = newMeshInfoInner;
mem_meshInfosOuter[hArrInputs.elementIndex()] = newMeshInfoOuter;
}
}
for (unsigned int i = 0; i < elementCount; i++)
{
mem_meshInfosInner[i]->setBulge(bulgeWeight, MSpace::kWorld );
}
MFloatArray weightList;
weightList.setLength(allPositions.length());
for (unsigned int i = 0; i < weightList.length(); i++)
weightList[i] = 0.0f;
MMatrixArray inputMeshMatrixInverses;
inputMeshMatrixInverses.setLength(elementCount);
for (unsigned int i = 0; i < elementCount; i++)
{
inputMeshMatrixInverses[i] = mem_meshInfosInner[i]->matrix();
}
for (unsigned int i = 0; i < allPositions.length(); i++)
{
float resultWeight = 0;
for (unsigned int infoIndex = 0; infoIndex < elementCount; infoIndex++)
{
MPoint localPoint = allPositions[i] * mtx* inputMeshMatrixInverses[infoIndex];
MPoint innerPoint = mem_meshInfosInner[infoIndex]->getClosestPoint(localPoint);
MPoint outerPoint = mem_meshInfosOuter[infoIndex]->getClosestPoint(localPoint);
MVector innerVector = innerPoint - localPoint;
MVector outerVector = outerPoint - localPoint;
if (innerVector * outerVector < 0)
{
double innerLength = innerVector.length();
double outerLength = outerVector.length();
double allLength = innerLength + outerLength;
float numerator = float( innerLength * outerLength );
float denominator = float( pow(allLength / 2.0, 2) );
resultWeight = numerator / denominator;
}
}
weightList[i] = resultWeight;
}
for (unsigned int i = 0; i < allPositions.length(); i++)
{
allPositions[i] += weightList[i] * MVector(0, 1, 0);
}
iter.setAllPositions(allPositions);
return MS::kSuccess;
}
MStatus CageDeformerNode::deform( MDataBlock& data, MItGeometry& itGeo, const MMatrix &localToWorldMatrix, unsigned int mIndex )
{
/// main
MStatus status;
MThreadUtils::syncNumOpenMPThreads(); // for OpenMP
// load cage mesh and other attributes
MObject oCageMesh = data.inputValue( aCageMesh ).asMesh();
short blendMode = data.inputValue(aBlendMode).asShort();
bool rotationCosistency = data.inputValue( aRotationConsistency ).asBool();
bool frechetSum = data.inputValue( aFrechetSum ).asBool();
short newConstraintMode = data.inputValue(aConstraintMode).asShort();
double newConstraintWeight = data.inputValue( aConstraintWeight ).asDouble();
if ( oCageMesh.isNull() || blendMode == 99)
return MS::kSuccess;
short newCageMode = data.inputValue(aCageMode).asShort();
MFnMesh fnCageMesh( oCageMesh, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MPointArray cagePoints;
fnCageMesh.getPoints( cagePoints, MSpace::kWorld );
// save initial cage state
if (initCagePoints.length() != cagePoints.length()){
initCageMesh = oCageMesh;
initCagePoints=cagePoints;
}
// when cage mode is changed
if(newCageMode != cageMode || newConstraintMode != constraintMode || newConstraintWeight != constraintWeight)
{
cageMode = newCageMode;
constraintMode = newConstraintMode;
constraintWeight = newConstraintWeight;
std::vector<double> tetWeight;
// read target mesh data
MArrayDataHandle hInput = data.outputArrayValue( input, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = hInput.jumpToElement( mIndex );
CHECK_MSTATUS_AND_RETURN_IT( status );
MObject oInputGeom = hInput.outputValue().child( inputGeom ).asMesh();
MFnMesh inputMesh(oInputGeom);
inputMesh.getPoints( pts );
numPts=pts.length();
for(int j=0; j<numPts; j++ )
pts[j] *= localToWorldMatrix;
MIntArray count;
inputMesh.getTriangles( count, meshTriangles );
numTet=meshTriangles.length()/3;
std::vector<Matrix4d> P(numTet);
tetCenter.resize(numTet);
tetMatrixC(pts, meshTriangles, P, tetCenter);
PI.resize(numTet);
for(int i=0;i<numTet;i++)
PI[i] = P[i].inverse();
// prepare cage tetrahedra
MFnMesh fnInitCageMesh( initCageMesh, &status );
if(cageMode == 10 || cageMode == 11) // face mode
{
if(cageMode == 10){ // triangulate faces by MAYA standard
MIntArray count;
fnInitCageMesh.getTriangles( count, triangles );
tetWeight.resize(triangles.length()/3, 1.0f);
}else if(cageMode ==11){ // trianglate faces with more than 3 edges in a symmetric way
triangles.clear();
MItMeshPolygon iter(initCageMesh);
MIntArray tmp;
MVector normal;
tetWeight.reserve(4*iter.count());
unsigned int l;
for(unsigned int i=0; ! iter.isDone(); i++){
iter.getVertices(tmp);
l=tmp.length();
if(l==3){
tetWeight.push_back(1.0);
triangles.append(tmp[0]);
triangles.append(tmp[1]);
triangles.append(tmp[2]);
}else{
for(unsigned int j=0;j<l;j++){
tetWeight.push_back((l-2.0)/l);
triangles.append(tmp[j]);
triangles.append(tmp[(j+1) % l]);
triangles.append(tmp[(j+2) % l]);
}
}
iter.next();
}
}
// face mode compute init matrix
numPrb=triangles.length()/3;
initMatrix.resize(numPrb);
tetMatrix(initCagePoints, triangles, cageMode, initMatrix);
// compute weight
w.resize(numTet);
std::vector< std::vector<double> > idist(numTet);
for(int j=0;j<numTet;j++){
idist[j].resize(numPrb);
w[j].resize(numPrb);
double sidist = 0.0;
for(int i=0;i<numPrb;i++){
idist[j][i] = tetWeight[i]/distPtTri(tetCenter[j],initMatrix[i]);
sidist += idist[j][i];
}
assert(sidist>0.0f);
for(int i=0;i<numPrb;i++)
w[j][i] = idist[j][i] /sidist;
}// face mode end
}else if(cageMode == 0 || cageMode == 1){ // vertex mode
triangles.clear();
std::vector<int> tetCount(initCagePoints.length());
MItMeshVertex iter(initCageMesh);
for(int j=0; ! iter.isDone(); j++){
MIntArray v;
iter.getConnectedVertices(v); // at each vertex, construct tetrahedra from connected edges
int l=v.length();
if(l==3){
if(isDegenerate(initCagePoints[j],initCagePoints[v[0]],initCagePoints[v[1]],initCagePoints[v[2]]) != 0){
tetCount[j]++;
triangles.append(j);
triangles.append(v[0]);
triangles.append(v[1]);
triangles.append(v[2]);
}
}else{
for(int k=0;k<l;k++){
if(isDegenerate(initCagePoints[j],initCagePoints[v[k]],initCagePoints[v[(k+1) % l]],initCagePoints[v[(k+2) % l]]) != 0){
tetCount[j]++;
triangles.append(j);
triangles.append(v[k]);
triangles.append(v[(k+1) % l]);
triangles.append(v[(k+2) % l]);
}
}
}
iter.next();
}
numPrb=triangles.length()/4;
initMatrix.resize(numPrb);
tetMatrix(initCagePoints, triangles, cageMode, initMatrix);
// vertex mode compute weight
w.resize(numTet);
std::vector< std::vector<double> > idist(numTet);
tetWeight.resize(numPrb);
for(int i=0;i<numPrb;i++)
tetWeight[i]=1.0/(double)tetCount[triangles[4*i]];
for(int j=0;j<numTet;j++){
idist[j].resize(numPrb);
w[j].resize(numPrb);
double sidist = 0.0;
for(int i=0;i<numPrb;i++){
Vector3d c(initCagePoints[triangles[4*i]].x,initCagePoints[triangles[4*i]].y,initCagePoints[triangles[4*i]].z);
idist[j][i] = tetWeight[i] / ((tetCenter[j]-c).squaredNorm());
sidist += idist[j][i];
}
assert(sidist>0.0f);
for(int i=0;i<numPrb;i++)
w[j][i] = idist[j][i] /sidist;
}
}else if(cageMode == 5 || cageMode == 6 ){ // vertex averaged normal mode
triangles.clear();
std::vector<int> tetCount(initCagePoints.length());
MItMeshVertex iter(initCageMesh);
for(int j=0; ! iter.isDone(); j++){
MIntArray v;
iter.getConnectedVertices(v);
int l=v.length();
for(int k=0;k<l;k++){
tetCount[j]++;
triangles.append(j);
triangles.append(v[k]);
triangles.append(v[(k+1) % l]);
}
iter.next();
}
numPrb=triangles.length()/3;
initMatrix.resize(numPrb);
tetMatrix(initCagePoints, triangles, cageMode, initMatrix);
// vertex mode compute weight
w.resize(numTet);
std::vector< std::vector<double> > idist(numTet);
tetWeight.resize(numPrb);
for(int i=0;i<numPrb;i++)
tetWeight[i]=1.0/(double)tetCount[triangles[3*i]];
for(int j=0;j<numTet;j++){
idist[j].resize(numPrb);
w[j].resize(numPrb);
double sidist = 0.0;
for(int i=0;i<numPrb;i++){
Vector3d c(initCagePoints[triangles[3*i]].x,initCagePoints[triangles[3*i]].y,initCagePoints[triangles[3*i]].z);
idist[j][i] = tetWeight[i] / ((tetCenter[j]-c).squaredNorm());
sidist += idist[j][i];
}
assert(sidist>0.0f);
for(int i=0;i<numPrb;i++)
w[j][i] = idist[j][i] /sidist;
}
}// end of cage setup
// find constraint points
if(constraintMode == 1){
numConstraint = numPrb;
}else{
numConstraint = 1; // at least one constraint is necessary to determine global translation
}
constraintTet.resize(numConstraint);
constraintVector.resize(numConstraint);
// for each cage tetrahedra, constraint the point on the mesh with largest weight
for(int i=0;i<numConstraint;i++){
constraintTet[i] = 0;
for(int j=1;j<numTet;j++){
if(w[j][i] > w[constraintTet[i]][i]){
constraintTet[i] = j;
}
}
constraintVector[i] << tetCenter[constraintTet[i]](0), tetCenter[constraintTet[i]](1), tetCenter[constraintTet[i]](2), 1.0;
}
// precompute arap solver
arapHI(PI, meshTriangles);
}
// compute deformation
if( ! rotationCosistency || numPrb != prevNs.size()){ // clear previous rotation
prevThetas.clear();
prevThetas.resize(numPrb, 0.0);
prevNs.clear();
prevNs.resize(numPrb, Vector3d::Zero());
}
// find affine transformations for tetrahedra
std::vector<Matrix4d> cageMatrix(numPrb), SE(numPrb), logSE(numPrb),logAff(numPrb),aff(numPrb);
std::vector<Matrix3d> logR(numPrb),R(numPrb),logS(numPrb),logGL(numPrb);
std::vector<Vector3d> L(numPrb);
std::vector<Vector4d> quat(numPrb);
tetMatrix(cagePoints, triangles, cageMode, cageMatrix);
for(int i=0; i<numPrb; i++)
aff[i]=initMatrix[i].inverse()*cageMatrix[i];
// compute parametrisation
if(blendMode == 0 || blendMode == 1 || blendMode == 5) // polarexp or quaternion
{
for(unsigned int i=0;i<numPrb;i++){
parametriseGL(aff[i].block(0,0,3,3), logS[i] ,R[i]);
L[i] = transPart(aff[i]);
if(blendMode == 0){ // Rotational log
logR[i]=logSOc(R[i], prevThetas[i], prevNs[i]);
}else if(blendMode == 1){ // Eucledian log
SE[i]=affine(R[i], L[i]);
logSE[i]=logSEc(SE[i], prevThetas[i], prevNs[i]);
}else if(blendMode == 5){ // quaternion
Quaternion<double> Q(R[i].transpose());
quat[i] << Q.x(), Q.y(), Q.z(), Q.w();
}
}
}else if(blendMode == 2){ //logmatrix3
for(unsigned int i=0;i<numPrb;i++){
logGL[i] = aff[i].block(0,0,3,3).log();
L[i] = transPart(aff[i]);
}
}else if(blendMode == 3){ // logmatrix4
for(unsigned int i=0;i<numPrb;i++){
logAff[i] = aff[i].log();
}
}
// compute blended matrices
#pragma omp parallel for
std::vector<Matrix4d> At(numTet);
for(int j=0; j<numTet; j++ ){
if(blendMode==0){
Matrix3d RR=Matrix3d::Zero();
Matrix3d SS=Matrix3d::Zero();
Vector3d l=Vector3d::Zero();
for(unsigned int i=0; i<numPrb; i++){
RR += w[j][i] * logR[i];
SS += w[j][i] * logS[i];
l += w[j][i] * L[i];
}
SS = expSym(SS);
if(frechetSum){
RR = frechetSO(R, w[j]);
}else{
RR = expSO(RR);
}
At[j] = affine(SS*RR, l);
}else if(blendMode==1){ // rigid transformation
Matrix4d EE=Matrix4d::Zero();
Matrix3d SS=Matrix3d::Zero();
for(unsigned int i=0; i<numPrb; i++){
EE += w[j][i] * logSE[i];
SS += w[j][i] * logS[i];
}
if(frechetSum){
EE = frechetSE(SE, w[j]);
}else{
EE = expSE(EE);
}
At[j] = affine(expSym(SS),Vector3d::Zero())*EE;
}else if(blendMode == 2){ //logmatrix3
Matrix3d G=Matrix3d::Zero();
Vector3d l=Vector3d::Zero();
for(unsigned int i=0; i<numPrb; i++){
G += w[j][i] * logGL[i];
l += w[j][i] * L[i];
}
At[j] = affine(G.exp(), l);
}else if(blendMode == 3){ // logmatrix4
Matrix4d A=Matrix4d::Zero();
for(unsigned int i=0; i<numPrb; i++)
A += w[j][i] * logAff[i];
At[j] = A.exp();
}else if(blendMode == 5){ // quaternion
Vector4d q=Vector4d::Zero();
Matrix3d SS=Matrix3d::Zero();
Vector3d l=Vector3d::Zero();
for(unsigned int i=0; i<numPrb; i++){
q += w[j][i] * quat[i];
SS += w[j][i] * logS[i];
l += w[j][i] * L[i];
}
SS = expSym(SS);
Quaternion<double> Q(q);
Matrix3d RR = Q.matrix().transpose();
At[j] = affine(SS*RR, l);
}else if(blendMode==10){
At[j] = Matrix4d::Zero();
for(unsigned int i=0; i<numPrb; i++){
At[j] += w[j][i] * aff[i];
}
}
}
// compute target vertices position
MatrixXd G=MatrixXd::Zero(numTet+numPts,3);
arapG(At, PI, meshTriangles, aff, G);
MatrixXd Sol = solver.solve(G);
for(unsigned int i=0;i<numPts;i++){
pts[i].x=Sol(i,0);
pts[i].y=Sol(i,1);
pts[i].z=Sol(i,2);
pts[i] *= localToWorldMatrix.inverse();
}
itGeo.setAllPositions(pts);
return MS::kSuccess;
}
MStatus probeDeformerARAPNode::deform( MDataBlock& data, MItGeometry& itGeo, const MMatrix &localToWorldMatrix, unsigned int mIndex )
{
MObject thisNode = thisMObject();
MStatus status;
MThreadUtils::syncNumOpenMPThreads(); // for OpenMP
bool worldMode = data.inputValue( aWorldMode ).asBool();
bool areaWeighted = data.inputValue( aAreaWeighted ).asBool();
short stiffnessMode = data.inputValue( aStiffness ).asShort();
short blendMode = data.inputValue( aBlendMode ).asShort();
short tetMode = data.inputValue( aTetMode ).asShort();
short numIter = data.inputValue( aIteration ).asShort();
short constraintMode = data.inputValue( aConstraintMode ).asShort();
short visualisationMode = data.inputValue( aVisualisationMode ).asShort();
mesh.transWeight = data.inputValue( aTransWeight ).asDouble();
double constraintWeight = data.inputValue( aConstraintWeight ).asDouble();
double normExponent = data.inputValue( aNormExponent ).asDouble();
double visualisationMultiplier = data.inputValue(aVisualisationMultiplier).asDouble();
MArrayDataHandle hMatrixArray = data.inputArrayValue(aMatrix);
MArrayDataHandle hInitMatrixArray = data.inputArrayValue(aInitMatrix);
// check connection
if(hMatrixArray.elementCount() > hInitMatrixArray.elementCount() || hMatrixArray.elementCount() == 0 || blendMode == BM_OFF){
return MS::kSuccess;
}else if(hMatrixArray.elementCount() < hInitMatrixArray.elementCount()){
std::set<int> indices;
for(int i=0;i<hInitMatrixArray.elementCount();i++){
hInitMatrixArray.jumpToArrayElement(i);
indices.insert(hInitMatrixArray.elementIndex());
}
for(int i=0;i<hMatrixArray.elementCount();i++){
hMatrixArray.jumpToArrayElement(i);
indices.erase(hMatrixArray.elementIndex());
}
deleteAttr(data, aInitMatrix, indices);
deleteAttr(data, aProbeConstraintRadius, indices);
deleteAttr(data, aProbeWeight, indices);
}
bool isNumProbeChanged = (numPrb != hMatrixArray.elementCount());
numPrb = hMatrixArray.elementCount();
B.setNum(numPrb);
// read matrices from probes
std::vector<Matrix4d> initMatrix(numPrb), matrix(numPrb);
readMatrixArray(hInitMatrixArray, initMatrix);
readMatrixArray(hMatrixArray, matrix);
// read vertex positions
MPointArray Mpts;
itGeo.allPositions(Mpts);
int numPts = Mpts.length();
// compute distance
if(!data.isClean(aARAP) || !data.isClean(aComputeWeight) || isNumProbeChanged){
// load points list
if(worldMode){
for(int j=0; j<numPts; j++ )
Mpts[j] *= localToWorldMatrix;
}
pts.resize(numPts);
for(int i=0;i<numPts;i++){
pts[i] << Mpts[i].x, Mpts[i].y, Mpts[i].z;
}
// make tetrahedral structure
getMeshData(data, input, inputGeom, mIndex, tetMode, pts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix, mesh.tetWeight);
mesh.dim = removeDegenerate(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix);
makeTetMatrix(tetMode, pts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetMatrix, mesh.tetWeight);
makeTetCenterList(tetMode, pts, mesh.tetList, tetCenter);
mesh.numTet = (int)mesh.tetList.size()/4;
mesh.computeTetMatrixInverse();
// initial probe position
for(int i=0;i<numPrb;i++){
B.centre[i] = transPart(initMatrix[i]);
}
// compute distance between probe and tetrahedra
D.setNum(numPrb, numPts, mesh.numTet);
D.computeDistTet(tetCenter, B.centre);
D.findClosestTet();
D.computeDistPts(pts, B.centre);
D.findClosestPts();
if(!areaWeighted){
mesh.tetWeight.clear();
mesh.tetWeight.resize(mesh.numTet,1.0);
}
}
// (re)compute ARAP
if(!data.isClean(aARAP) || isNumProbeChanged){
// load painted weights
if(stiffnessMode == SM_PAINT) {
VectorXd ptsWeight(numPts);
for (int i=0; !itGeo.isDone(); itGeo.next()){
double w=weightValue(data, mIndex, itGeo.index());
ptsWeight[i++] = (w>EPSILON) ? w : EPSILON;
}
makeTetWeightList(tetMode, mesh.tetList, faceList, edgeList, vertexList, ptsWeight, mesh.tetWeight);
}else if(stiffnessMode == SM_LEARN) {
std::vector<double> tetEnergy(mesh.numTet,0);
MArrayDataHandle hSupervisedMesh = data.inputArrayValue(aSupervisedMesh);
int numSupervisedMesh = hSupervisedMesh.elementCount();
for(int j=0;j<numSupervisedMesh;j++){
hSupervisedMesh.jumpToElement(j);
MFnMesh ex_mesh(hSupervisedMesh.inputValue().asMesh());
MPointArray Mspts;
ex_mesh.getPoints( Mspts );
if(numPts != Mspts.length()){
MGlobal::displayInfo("incompatible mesh");
return MS::kFailure;
}
std::vector<Vector3d> spts(numPts);
for(int i=0;i<numPts;i++){
spts[i] << Mspts[i].x, Mspts[i].y, Mspts[i].z;
}
std::vector<double> dummy_weight;
makeTetMatrix(tetMode, spts, mesh.tetList, faceList, edgeList, vertexList, Q, dummy_weight);
Matrix3d S,R;
for(int i=0;i<mesh.numTet;i++) {
polarHigham((mesh.tetMatrixInverse[i]*Q[i]).block(0,0,3,3), S, R);
tetEnergy[i] += (S-Matrix3d::Identity()).squaredNorm();
}
}
// compute weight (stiffness)
double max_energy = *std::max_element(tetEnergy.begin(), tetEnergy.end());
for(int i=0;i<mesh.numTet;i++) {
double w = 1.0 - tetEnergy[i]/(max_energy+EPSILON);
mesh.tetWeight[i] *= w*w;
}
}
// find constraint points
constraint.resize(3*numPrb);
for(int i=0;i<numPrb;i++){
constraint[3*i] = T(i,mesh.tetList[4*D.closestTet[i]],constraintWeight);
constraint[3*i+1] = T(i,mesh.tetList[4*D.closestTet[i]+1],constraintWeight);
constraint[3*i+2] = T(i,mesh.tetList[4*D.closestTet[i]+2],constraintWeight);
}
if( constraintMode == CONSTRAINT_NEIGHBOUR ){
std::vector<double> probeConstraintRadius(numPrb);
MArrayDataHandle handle = data.inputArrayValue(aProbeConstraintRadius);
if(handle.elementCount() != numPrb){
MGlobal::displayInfo("# of Probes and probeConstraintRadius are different");
return MS::kFailure;
}
for(int i=0;i<numPrb;i++){
handle.jumpToArrayElement(i);
probeConstraintRadius[i]=handle.inputValue().asDouble();
}
double constraintRadius = data.inputValue( aConstraintRadius ).asDouble();
for(int i=0;i<numPrb;i++){
double r = constraintRadius * probeConstraintRadius[i];
for(int j=0;j<numPts;j++){
if(D.distPts[i][j]<r){
constraint.push_back(T(i,j,constraintWeight * pow((r-D.distPts[i][j])/r,normExponent)));
}
}
}
}
int numConstraint=constraint.size();
mesh.constraintWeight.resize(numConstraint);
mesh.constraintVal.resize(numConstraint,numPrb);
for(int cur=0;cur<numConstraint;cur++){
mesh.constraintWeight[cur] = std::make_pair(constraint[cur].col(), constraint[cur].value());
}
//
isError = mesh.ARAPprecompute();
status = data.setClean(aARAP);
} // END of ARAP precomputation
if(isError>0){
return MS::kFailure;
}
// probe weight computation
if(!data.isClean(aComputeWeight) || isNumProbeChanged){
// load probe weights
MArrayDataHandle handle = data.inputArrayValue(aProbeWeight);
if(handle.elementCount() != numPrb){
MGlobal::displayInfo("# of Probes and probeWeight are different");
isError = ERROR_ATTR;
return MS::kFailure;
}
double effectRadius = data.inputValue( aEffectRadius ).asDouble();
std::vector<double> probeWeight(numPrb), probeRadius(numPrb);
for(int i=0;i<numPrb;i++){
handle.jumpToArrayElement(i);
probeWeight[i] = handle.inputValue().asDouble();
probeRadius[i] = probeWeight[i] * effectRadius;
}
wr.resize(mesh.numTet);ws.resize(mesh.numTet);wl.resize(mesh.numTet);
for(int j=0;j<mesh.numTet;j++){
wr[j].resize(numPrb); ws[j].resize(numPrb); wl[j].resize(numPrb);
}
short weightMode = data.inputValue( aWeightMode ).asShort();
if (weightMode == WM_INV_DISTANCE){
for(int j=0;j<mesh.numTet;j++){
double sum=0.0;
std::vector<double> idist(numPrb);
for (int i = 0; i<numPrb; i++){
idist[i] = probeRadius[i] / pow(D.distTet[i][j], normExponent);
sum += idist[i];
}
for (int i = 0; i<numPrb; i++){
wr[j][i] = ws[j][i] = wl[j][i] = sum > 0 ? idist[i] / sum : 0.0;
}
}
}
else if (weightMode == WM_CUTOFF_DISTANCE){
for(int j=0;j<mesh.numTet;j++){
for (int i = 0; i<numPrb; i++){
wr[j][i] = ws[j][i] = wl[j][i] = (D.distTet[i][j] > probeRadius[i])
? 0 : pow((probeRadius[i] - D.distTet[i][j]) / probeRadius[i], normExponent);
}
}
}else if (weightMode == WM_DRAW){
float val;
MRampAttribute rWeightCurveR( thisNode, aWeightCurveR, &status );
MRampAttribute rWeightCurveS( thisNode, aWeightCurveS, &status );
MRampAttribute rWeightCurveL( thisNode, aWeightCurveL, &status );
for(int j=0;j<mesh.numTet;j++){
for (int i = 0; i < numPrb; i++){
rWeightCurveR.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
wr[j][i] = val;
rWeightCurveS.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
ws[j][i] = val;
rWeightCurveL.getValueAtPosition(D.distTet[i][j] / probeRadius[i], val);
wl[j][i] = val;
}
}
}else if(weightMode & WM_HARMONIC){
Laplacian harmonicWeighting;
makeFaceTet(data, input, inputGeom, mIndex, pts, harmonicWeighting.tetList, harmonicWeighting.tetMatrix, harmonicWeighting.tetWeight);
harmonicWeighting.numTet = (int)harmonicWeighting.tetList.size()/4;
std::vector<T> weightConstraint(numPrb);
// the vertex closest to the probe is given probeWeight
for(int i=0;i<numPrb;i++){
weightConstraint[i]=T(i,D.closestPts[i],probeWeight[i]);
}
// vertices within effectRadius are given probeWeight
if( data.inputValue( aNeighbourWeighting ).asBool() ){
for(int i=0;i<numPrb;i++){
for(int j=0;j<numPts;j++){
if(D.distPts[i][j]<probeRadius[i]){
weightConstraint.push_back(T(i,j,probeWeight[i]));
}
}
}
}
// set boundary condition for weight computation
int numConstraint=weightConstraint.size();
harmonicWeighting.constraintWeight.resize(numConstraint);
harmonicWeighting.constraintVal.resize(numConstraint,numPrb);
harmonicWeighting.constraintVal.setZero();
for(int i=0;i<numConstraint;i++){
harmonicWeighting.constraintVal(i,weightConstraint[i].row())=weightConstraint[i].value();
harmonicWeighting.constraintWeight[i] = std::make_pair(weightConstraint[i].col(), weightConstraint[i].value());
}
// clear tetWeight
if(!areaWeighted){
harmonicWeighting.tetWeight.clear();
harmonicWeighting.tetWeight.resize(harmonicWeighting.numTet,1.0);
}
// solve the laplace equation
if( weightMode == WM_HARMONIC_ARAP){
harmonicWeighting.computeTetMatrixInverse();
harmonicWeighting.dim = numPts + harmonicWeighting.numTet;
isError = harmonicWeighting.ARAPprecompute();
}else if(weightMode == WM_HARMONIC_COTAN){
harmonicWeighting.dim = numPts;
isError = harmonicWeighting.cotanPrecompute();
}
if(isError>0) return MS::kFailure;
std::vector< std::vector<double> > w_tet(numPrb);
harmonicWeighting.harmonicSolve();
for(int i=0;i<numPrb;i++){
makeTetWeightList(tetMode, mesh.tetList, faceList, edgeList, vertexList, harmonicWeighting.Sol.col(i), w_tet[i]);
for(int j=0;j<mesh.numTet; j++){
wr[j][i] = ws[j][i] = wl[j][i] = w_tet[i][j];
}
}
}
// normalise weights
short normaliseWeightMode = data.inputValue( aNormaliseWeight ).asShort();
for(int j=0;j<mesh.numTet;j++){
D.normaliseWeight(normaliseWeightMode, wr[j]);
D.normaliseWeight(normaliseWeightMode, ws[j]);
D.normaliseWeight(normaliseWeightMode, wl[j]);
}
status = data.setClean(aComputeWeight);
} // END of weight computation
// setting up transformation matrix
B.rotationConsistency = data.inputValue( aRotationConsistency ).asBool();
bool frechetSum = data.inputValue( aFrechetSum ).asBool();
blendedSE.resize(mesh.numTet); blendedR.resize(mesh.numTet); blendedS.resize(mesh.numTet); blendedL.resize(mesh.numTet);A.resize(mesh.numTet);
for(int i=0;i<numPrb;i++){
B.Aff[i]=initMatrix[i].inverse()*matrix[i];
}
B.parametrise(blendMode);
// prepare transform matrix for each simplex
#pragma omp parallel for
for (int j = 0; j < mesh.numTet; j++){
// blend matrix
if (blendMode == BM_SRL){
blendedS[j] = expSym(blendMat(B.logS, ws[j]));
Vector3d l = blendMat(B.L, wl[j]);
blendedR[j] = frechetSum ? frechetSO(B.R, wr[j]) : expSO(blendMat(B.logR, wr[j]));
A[j] = pad(blendedS[j]*blendedR[j], l);
}
else if (blendMode == BM_SSE){
blendedS[j] = expSym(blendMat(B.logS, ws[j]));
blendedSE[j] = expSE(blendMat(B.logSE, wr[j]));
A[j] = pad(blendedS[j], Vector3d::Zero()) * blendedSE[j];
}
else if (blendMode == BM_LOG3){
blendedR[j] = blendMat(B.logGL, wr[j]).exp();
Vector3d l = blendMat(B.L, wl[j]);
A[j] = pad(blendedR[j], l);
}
else if (blendMode == BM_LOG4){
A[j] = blendMat(B.logAff, wr[j]).exp();
}
else if (blendMode == BM_SQL){
Vector4d q = blendQuat(B.quat, wr[j]);
Vector3d l = blendMat(B.L, wl[j]);
blendedS[j] = blendMatLin(B.S, ws[j]);
Quaternion<double> RQ(q);
blendedR[j] = RQ.matrix().transpose();
A[j] = pad(blendedS[j]*blendedR[j], l);
}
else if (blendMode == BM_AFF){
A[j] = blendMatLin(B.Aff, wr[j]);
}
}
// compute target vertices position
tetEnergy.resize(mesh.numTet);
// set constraint
int numConstraints = constraint.size();
mesh.constraintVal.resize(numConstraints,3);
RowVector4d cv;
for(int cur=0;cur<numConstraints;cur++){
cv = pad(pts[constraint[cur].col()]) * B.Aff[constraint[cur].row()];
mesh.constraintVal(cur,0) = cv[0];
mesh.constraintVal(cur,1) = cv[1];
mesh.constraintVal(cur,2) = cv[2];
}
// iterate to determine vertices position
for(int k=0;k<numIter;k++){
// solve ARAP
mesh.ARAPSolve(A);
// set new vertices position
new_pts.resize(numPts);
for(int i=0;i<numPts;i++){
new_pts[i][0]=mesh.Sol(i,0);
new_pts[i][1]=mesh.Sol(i,1);
new_pts[i][2]=mesh.Sol(i,2);
}
// if iteration continues
if(k+1<numIter || visualisationMode == VM_ENERGY){
std::vector<double> dummy_weight;
makeTetMatrix(tetMode, new_pts, mesh.tetList, faceList, edgeList, vertexList, Q, dummy_weight);
Matrix3d S,R,newS,newR;
if(blendMode == BM_AFF || blendMode == BM_LOG4 || blendMode == BM_LOG3){
for(int i=0;i<mesh.numTet;i++){
polarHigham(A[i].block(0,0,3,3), blendedS[i], blendedR[i]);
}
}
#pragma omp parallel for
for(int i=0;i<mesh.numTet;i++){
polarHigham((mesh.tetMatrixInverse[i]*Q[i]).block(0,0,3,3), newS, newR);
tetEnergy[i] = (newS-blendedS[i]).squaredNorm();
A[i].block(0,0,3,3) = blendedS[i]*newR;
// polarHigham((A[i].transpose()*PI[i]*Q[i]).block(0,0,3,3), newS, newR);
// A[i].block(0,0,3,3) *= newR;
}
}
}
for(int i=0;i<numPts;i++){
Mpts[i].x=mesh.Sol(i,0);
Mpts[i].y=mesh.Sol(i,1);
Mpts[i].z=mesh.Sol(i,2);
}
if(worldMode){
for(int i=0;i<numPts;i++)
Mpts[i] *= localToWorldMatrix.inverse();
}
itGeo.setAllPositions(Mpts);
// set vertex colour
if(visualisationMode != VM_OFF){
std::vector<double> ptsColour(numPts, 0.0);
if(visualisationMode == VM_ENERGY){
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, tetEnergy, ptsColour);
for(int i=0;i<numPts;i++){
ptsColour[i] *= visualisationMultiplier;
}
}else if(visualisationMode == VM_STIFFNESS){
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, mesh.tetWeight, ptsColour);
double maxval = *std::max_element(ptsColour.begin(), ptsColour.end());
for(int i=0;i<numPts;i++){
ptsColour[i] = 1.0 - ptsColour[i]/maxval;
}
}else if(visualisationMode == VM_CONSTRAINT){
for(int i=0;i<constraint.size();i++){
ptsColour[constraint[i].col()] += constraint[i].value();
}
}else if(visualisationMode == VM_EFFECT){
std:vector<double> wsum(mesh.numTet);
for(int j=0;j<mesh.numTet;j++){
//wsum[j] = std::accumulate(wr[j].begin(), wr[j].end(), 0.0);
wsum[j]= visualisationMultiplier * wr[j][numPrb-1];
}
makePtsWeightList(tetMode, numPts, mesh.tetList, faceList, edgeList, vertexList, wsum, ptsColour);
}
visualise(data, outputGeom, ptsColour);
}
return MS::kSuccess;
}
MStatus inverseSkinCluster::deform(MDataBlock& data,
MItGeometry& itGeo,
const MMatrix& localToWorldMatrix,
unsigned int geomIndex)
{
MStatus status;
MMatrix geomMatrix;
bool updateSkinInfo;
MDataHandle hInMesh = data.inputValue( aInMesh, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
MObject oInMesh = hInMesh.asMesh();
if( oInMesh.isNull() )
return MS::kFailure;
MFnMesh inMesh = oInMesh;
inMesh.getPoints( m_meshPoints );
if( originalMeshUpdated )
{
itGeo.allPositions( pTaskData->basePoints );
originalMeshUpdated = false;
}
MDataHandle hGeomMatrix = data.inputValue( aGeomMatrix );
geomMatrix = hGeomMatrix.asMatrix();
MDataHandle hUpdateWeightList = data.inputValue( aUpdateWeightList );
updateSkinInfo = hUpdateWeightList.asBool();
MDataHandle hEnvelop = data.inputValue( envelope );
envelopValue = hEnvelop.asFloat();
pTaskData->envelop = envelopValue;
pTaskData->invEnv = 1.0f - envelopValue;
pTaskData->beforePoints = m_meshPoints;
if( updateSkinInfo )
{
MDataHandle hUpdateSkinInfoOutput = data.outputValue( aUpdateWeightList );
hUpdateSkinInfoOutput.set( false );
weightListUpdated = false;
}
if( logicalIndexArray.length() == 0 )
updateLogicalIndexArray();
MDataHandle hUpdateMatrix = data.inputValue( aUpdateMatrix );
if( hUpdateMatrix.asBool() )
{
matrixAttrUpdated = false;
matrixInfoUpdated = false;
}
MArrayDataHandle hArrMatrix = data.inputArrayValue( aMatrix );
MArrayDataHandle hArrBindPreMatrix = data.inputArrayValue( aBindPreMatrix );
updateMatrixAttribute( hArrMatrix, hArrBindPreMatrix );
if( !matrixInfoUpdated )
{
updateMatrixInfo( hArrMatrix, hArrBindPreMatrix );
}
if( !weightListUpdated )
{
pTaskData->afterPoints.setLength( m_meshPoints.length() );
pTaskData->envPoints.setLength( m_meshPoints.length() );
updateWeightList();
}
if( !matrixInfoUpdated || !weightListUpdated )
{
if( pSkinInfo->weightsArray.size() > 0 )
getWeightedMatrices( geomMatrix );
else
return MS::kFailure;
matrixInfoUpdated = true;
weightListUpdated = true;
}
if( envelopValue )
{
setThread();
MThreadPool::newParallelRegion( parallelCompute, pThread );
endThread();
itGeo.setAllPositions( pTaskData->envPoints );
}
else
{
itGeo.setAllPositions( pTaskData->basePoints );
}
return MS::kSuccess;
}
