//=====================================================
void GlCurve::draw(float, Camera *) {
// tlp::warning() << ".";
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
//glEnable(GL_COLOR_MATERIAL);
vector<Coord> newPoints(_points.size());
for(unsigned int i=0; i < _points.size(); ++i) {
newPoints[i] = _points[i];
}
glLineWidth(2);
glPushAttrib(GL_ALL_ATTRIB_BITS);
tlp::splineLine(newPoints,
_beginFillColor,
_endFillColor);
glPopAttrib();
if(texture!="") {
GlTextureManager::getInst().activateTexture(texture);
}
tlp::splineQuad(newPoints,
_beginFillColor,
_endFillColor,
_beginSize,
_endSize,
newPoints[0] - Coord(1. , 0.0, 0.),
newPoints[3] + Coord(1. , 0.0, 0.));
GlTextureManager::getInst().desactivateTexture();
glEnable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
}
void Foam::layeredEngineMesh::move()
{
scalar deltaZ = engineDB_.pistonDisplacement().value();
Info<< "deltaZ = " << deltaZ << endl;
// Position of the top of the static mesh layers above the piston
scalar pistonPlusLayers = pistonPosition_.value() + pistonLayers_.value();
pointField newPoints(points());
forAll(newPoints, pointi)
{
point& p = newPoints[pointi];
if (p.z() < pistonPlusLayers) // In piston bowl
{
p.z() += deltaZ;
}
else if (p.z() < deckHeight_.value()) // In liner region
{
p.z() +=
deltaZ
*(deckHeight_.value() - p.z())
/(deckHeight_.value() - pistonPlusLayers);
}
}
void SwaptionVolCube1::Cube::expandLayers(
Size i, bool expandOptionTimes,
Size j, bool expandSwapLengths) {
QL_REQUIRE(i<=optionTimes_.size(),"Cube::expandLayers: incompatible size 1");
QL_REQUIRE(j<=swapLengths_.size(),"Cube::expandLayers: incompatible size 2");
if (expandOptionTimes) {
optionTimes_.insert(optionTimes_.begin()+i,0.);
optionDates_.insert(optionDates_.begin()+i, Date());
}
if (expandSwapLengths) {
swapLengths_.insert(swapLengths_.begin()+j,0.);
swapTenors_.insert(swapTenors_.begin()+j, Period());
}
std::vector<Matrix> newPoints(nLayers_,Matrix(optionTimes_.size(),
swapLengths_.size(), 0.));
for (Size k=0; k<nLayers_; ++k) {
for (Size u=0; u<points_[k].rows(); ++u) {
Size indexOfRow = u;
if (u>=i && expandOptionTimes) indexOfRow = u+1;
for (Size v=0; v<points_[k].columns(); ++v) {
Size indexOfCol = v;
if (v>=j && expandSwapLengths) indexOfCol = v+1;
newPoints[k][indexOfRow][indexOfCol]=points_[k][u][v];
}
}
}
setPoints(newPoints);
}
void QLCDNumberPrivate::internalSetString(const QString& s)
{
Q_Q(QLCDNumber);
QString buffer;
int i;
int len = s.length();
QBitArray newPoints(ndigits);
if (!smallPoint) {
if (len == ndigits)
buffer = s;
else
buffer = s.right(ndigits).rightJustified(ndigits, QLatin1Char(' '));
} else {
int index = -1;
bool lastWasPoint = true;
newPoints.clearBit(0);
for (i=0; i<len; i++) {
if (s[i] == QLatin1Char('.')) {
if (lastWasPoint) { // point already set for digit?
if (index == ndigits - 1) // no more digits
break;
index++;
buffer[index] = QLatin1Char(' '); // 2 points in a row, add space
}
newPoints.setBit(index); // set decimal point
lastWasPoint = true;
} else {
if (index == ndigits - 1)
break;
index++;
buffer[index] = s[i];
newPoints.clearBit(index); // decimal point default off
lastWasPoint = false;
}
}
if (index < ((int) ndigits) - 1) {
for(i=index; i>=0; i--) {
buffer[ndigits - 1 - index + i] = buffer[i];
newPoints.setBit(ndigits - 1 - index + i,
newPoints.testBit(i));
}
for(i=0; i<ndigits-index-1; i++) {
buffer[i] = QLatin1Char(' ');
newPoints.clearBit(i);
}
}
}
if (buffer == digitStr)
return;
digitStr = buffer;
if (smallPoint)
points = newPoints;
q->update();
}
void
MainWindow::newPointSet()
{
bool ok;
int numberOfPoints = QInputDialog::getInt(this,
"Periodic Lloyd", "Number of points: ", 100, 0, 2147483647, 1, &ok );
if (ok) newPoints(numberOfPoints);
}
void Spline::refineAt(real knotValue, uint multiplicity) {
//A multiplicity of 0 would mean no knot insertion and
//an insertion with multiplicity > m_degree would lead to a hole in the spline curve!
if(multiplicity == 0 || multiplicityOfKnotValue(knotValue) + multiplicity > m_degree)
return;
//Use de Boor scheme to get the new point(s)
uint n = lowerNextKnot(knotValue); // knotValue is element of [knot[n], knot[n+1])
vector<vec2> controlPointsCopy(m_degree + 1);
for(uint i = 0; i <= m_degree; ++i) {
controlPointsCopy[i] = m_controlPoints.at(n - m_degree + 1 + i);
}
vector<vec2> newPoints(m_degree + multiplicity - 1);
//When the new knotVaue is inserted r-times (multiplicity = r) the new points are equal
//to the points of the de boor scheme in the r-th column and the outer way to this column
for(uint i = 1; i <= multiplicity; ++i) {
//do only one step of the de boor algorithm each iteration
//and only multiplicity times
//(so for multiplicity == 1 only one step is done)
deBoor(controlPointsCopy, knotValue, n, m_degree - i + 1, m_degree - i);
if(i == multiplicity) {
//copy all up to now calculated points to the new points
//except first one, which didn't change (exists already in spline)
for(uint j = 1; j <= m_degree; ++j) {
newPoints[j - 1] = controlPointsCopy.at(j);
}
} else {
//copy only last point, as it will be overwritten in next deBoor step
newPoints[newPoints.size() - i] = controlPointsCopy.back();
}
}
//copy now new points into control points vector:
m_controlPoints.resize(m_controlPoints.size() + multiplicity);
int n_int = (int) n;
int i = m_controlPoints.size() - 1 - multiplicity;
for(; i > n_int; --i) {
m_controlPoints[i + multiplicity] = m_controlPoints.at(i);
}
//do NOT replace 'int j' by 'uint j'!!!
for(int j = newPoints.size() - 1; j >= 0; --j, --i) {
m_controlPoints[i + multiplicity] = newPoints[j];
}
for(uint k = 1; k <= multiplicity; ++k) {
m_knots.insert(m_knots.begin() + n + k, knotValue);
}
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
Info<< "Mesh read in = "
<< runTime.cpuTimeIncrement()
<< " s\n" << endl << endl;
Info<< "Time now = " << runTime.timeName() << endl;
// Wall distance
wallDist y(mesh, true);
if (y.nUnset() != 0)
{
WarningIn(args.executable())
<< "There are " << y.nUnset()
<< " remaining unset cells and/or boundary values" << endl;
}
y.write();
runTime++;
Info<< "Time now = " << runTime.timeName() << endl;
// Move points
boundBox meshBb(mesh.points());
pointField newPoints(mesh.points());
const point half(0.5*(meshBb.min() + meshBb.max()));
forAll(newPoints, pointI)
{
point& pt = newPoints[pointI];
// expand around half
pt.y() += pt.y() - half.y();
}
Foam::mirrorFvMesh::mirrorFvMesh(const IOobject& io)
:
fvMesh(io),
mirrorMeshDict_
(
IOobject
(
"mirrorMeshDict",
time().system(),
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
),
mirrorMeshPtr_(NULL)
{
plane mirrorPlane(mirrorMeshDict_);
scalar planeTolerance
(
readScalar(mirrorMeshDict_.lookup("planeTolerance"))
);
const pointField& oldPoints = points();
const faceList& oldFaces = faces();
const cellList& oldCells = cells();
const label nOldInternalFaces = nInternalFaces();
const polyPatchList& oldPatches = boundaryMesh();
// Mirror the points
Info << "Mirroring points. Old points: " << oldPoints.size();
pointField newPoints(2*oldPoints.size());
label nNewPoints = 0;
labelList mirrorPointLookup(oldPoints.size(), -1);
// Grab the old points
forAll (oldPoints, pointI)
{
newPoints[nNewPoints] = oldPoints[pointI];
nNewPoints++;
}
int SimplePolygon::intersectPolygon( DCTPVec2dvector &globalverts, simplepolygonvector &polylist )
{
int oldNum = vertices.size();
int i1, i2;
Vec2d min, max;
Vec2d p3, p4;
unsigned char test, ptest;
// std::cerr << "Removing intersections... " << oldNum << std::endl;
for( i2 = 2; i2 < oldNum; ++i2 )
{
const Vec2d &p1 = globalverts[ vertices[ i2 ] ];
const Vec2d &p2 = globalverts[ vertices[ ( i2 + 1 ) % oldNum ] ];
min = max = p1;
if( min[0] > p2[0] )
min[0] = p2[0];
else if( max[0] < p2[0] )
max[0] = p2[0];
if( min[1] > p2[1] )
min[1] = p2[1];
else if( max[1] < p2[1] )
max[1] = p2[1];
const unsigned int start = ( i2 == oldNum - 1 ) ? 1 : 0;
p4 = globalverts[ vertices[ start ] ];
test = 0;
if( p4[0] - max[0] > DCTP_EPS ) test |= 0x01;
if( min[0] - p4[0] > DCTP_EPS ) test |= 0x02;
if( p4[1] - max[1] > DCTP_EPS ) test |= 0x04;
if( min[1] - p4[1] > DCTP_EPS ) test |= 0x08;
for( i1 = start; i1 < i2 - 1; ++i1 )
{
p3 = p4;
p4 = globalverts[ vertices[ i1 + 1 ] ];
ptest = test;
test = 0;
if( p4[0] - max[0] > DCTP_EPS ) test |= 0x01;
if( min[0] - p4[0] > DCTP_EPS ) test |= 0x02;
if( p4[1] - max[1] > DCTP_EPS ) test |= 0x04;
if( min[1] - p4[1] > DCTP_EPS ) test |= 0x08;
if( ( test & ptest ) == 0 )
{
// std::cerr << i1 << "," << i1 + 1 << " overlaps " << i2 << "," << i2 + 1 << std::endl;
// the bounding boxes overlap
int iip = -1;
bool intersect = false;
double d1[ 2 ] = { p1[0], p1[1] };
double d2[ 2 ] = { p2[0], p2[1] };
double d3[ 2 ] = { p3[0], p3[1] };
double d4[ 2 ] = { p4[0], p4[1] };
if( ( orient2d( d1, d2, d3 ) == 0.0 ) &&
( orient2d( d1, d2, d4 ) == 0.0 ) )
{
// the lines are colinear => ... p1 p4 ... ; p2 ... p3
intersect = true;
}
else
{
if( doIntersect( globalverts, i1, i1 + 1, i2, ( i2 + 1 ) % oldNum ) )
{
// the lines intersect => ... p1 ip p4 ... ; ip p2 ... p3
Vec2d v1 = p2 - p1;
Vec2d v2 = p4 - p3;
Vec2d pp = p3 - p1;
double a = pp[0] * v2[1] - pp[1] * v2[0];
double b = v1[0] * v2[1] - v1[1] * v2[0];
Vec2d ip = p1 + v1 * ( a / b );
if( DCTPVecIsEqual( ip , p1 ) )
{
iip = vertices[ i1 ];
}
else if( DCTPVecIsEqual( ip , p2 ) )
{
iip = vertices[ i1 + 1 ];
}
else if( DCTPVecIsEqual( ip , p3 ) )
{
iip = vertices[ i2 ];
}
else if( DCTPVecIsEqual( ip , p4 ) )
{
iip = vertices[ ( i2 + 1 ) % oldNum ];
}
else
{
iip = globalverts.size();
globalverts.resize( iip + 1 );
globalverts[ iip ] = ip;
}
// std::cerr << p1[0] << "," << p1[1] << " - " << p2[0] << "," << p2[1] << std::endl;
// std::cerr << p3[0] << "," << p3[1] << " - " << p4[0] << "," << p4[1] << std::endl;
// std::cerr << globalverts[ iip ][0] << "," << globalverts[ iip ][1] << " - " << std::endl;
intersect = true;
}
}
if( intersect )
{
int i;
int newNum;
DCTPivector newPoints( oldNum );
SimplePolygon poly;
// std::cerr << i1 << "," << i1 + 1 << " intersects " << i2 << "," << i2 + 1 << std::endl;
// copy points 0 ... i1
for( i = 0; i <= i1; ++i )
{
newPoints[ i ] = vertices[ i ];
}
newNum = i;
// copy iip's
if( iip >= 0 )
{
if( ( iip != vertices[ i1 ] ) &&
( iip != vertices[ ( i2 + 1 ) % oldNum ] ) )
{
newPoints[ newNum ] = iip;
++newNum;
}
if( ( iip != vertices[ i2 ] ) &&
( iip != vertices[ i1 + 1 ] ) )
{
poly.vertices.resize( i2 + 1 - i1 );
poly.vertices[ i2 - i1 ] = iip;
}
else
{
poly.vertices.resize( i2 - i1 );
}
}
else
{
poly.vertices.resize( i2 - i1 );
}
// copy i1+1 ... i2
for( i = 0; i < i2 - i1; ++i )
{
poly.vertices[ i ] = vertices[ i1 + i + 1 ];
}
// copy i2+1 ... n
for( i = i2 + 1; i < oldNum; ++i )
{
newPoints[ newNum ] = vertices[ i ];
++newNum;
}
// copy new points back to polygon
vertices.resize( newNum );
for( i2 = 0; i2 < newNum; ++i2 )
{
vertices[ i2 ] = newPoints[ i2 ];
}
// std::cerr << "split in " << newNum << "," << poly.vertices.size() << std::endl;
// triangulate the new polygon
while( poly.intersectPolygon( globalverts, polylist ) ) { }
if( poly.isReversed( globalverts ) )
{
// std::cerr << "Ignoring reversed polygon." << std::endl;
}
else
{
// Ok, we have a valid polygon, so triangulate it.
poly.triangulate( globalverts, polylist );
}
// check if there are other intersections
return 1;
}
}
}
}
// polygon had no intersections so we are finished
return 0;
}
int SimplePolygon::splitPolygon( DCTPVec2dvector &globalverts, simplepolygonvector &polylist, const Vec2d min, const Vec2d max )
{
DCTPVec2dset vset;
std::pair< DCTPVec2dset::iterator, bool > siv;
int oldNum = vertices.size();
int i1;
// std::cerr << "Removing double vertices... " << oldNum << std::endl;
for( i1 = 0; i1 < oldNum; ++i1 )
{
siv = vset.insert( globalverts[ vertices[ i1 ] ] );
if( !siv.second )
{
// here we need to split the polygon and start with the new ones again.
int i;
DCTPivector newPoints( oldNum ); // waste some memory to have nlogn time
int newNum = 0;
int i2 = 0;
SimplePolygon poly;
// copy points before first intersection
while( DCTPVecIsNotEqual( globalverts[ vertices[ i2 ] ] , globalverts[ vertices[ i1 ] ] ) )
{
newPoints[ i2 ] = vertices[ i2 ];
++i2;
}
newNum = i2;
// std::cerr << i2 << " = " << i1 << std::endl;
// construct new polygon
poly.vertices.resize( i1 - i2 );
for( i = i2; i < i1; ++i )
{
poly.vertices[ i - i2 ] = vertices[ i ];
// std::cerr << vertices[ i ] << " ";
}
// std::cerr << std::endl;
// copy points from second intersection to the end
for( i = i1; i < oldNum; ++i )
{
newPoints[ newNum ] = vertices[ i ];
++newNum;
}
// copy new points back to polygon
vertices.resize( newNum );
for( i = 0; i < newNum; ++i )
{
vertices[ i ] = newPoints[ i ];
// std::cerr << vertices[ i ] << " ";
}
// std::cerr << std::endl;
// triangulate the new polygon
// std::cerr << oldNum << " split in " << vertices.size() << "," << poly.vertices.size() << std::endl;
// need to check for new liear points
// while( poly.removeLinearPoints( globalverts, min, max ) ) { }
while( poly.intersectPolygon( globalverts, polylist ) ) { }
if( poly.isReversed( globalverts ) )
{
// std::cerr << "Ignoring reversed polygon." << std::endl;
}
else
{
// Ok, we have a valid polygon, so triangulate it.
poly.triangulate( globalverts, polylist );
}
// need to check for new liear points
// while( removeLinearPoints( globalverts, min, max ) ) { }
// check if there are other double vertices
return 1;
}
}
// polygon had no double vertices so we are finished
return 0;
}
/*!
* Note that this has complexity O(n).
*
* \param globalverts the global vertices vector
* \return zero on success, and a negative integer if some error occured.
*/
int SimplePolygon::removeLinearPoints( DCTPVec2dvector &globalverts, const Vec2d min, const Vec2d max )
{
int oldNum = vertices.size( );
int newNum = 0;
DCTPivector newPoints( oldNum ); // waste some memory to have linear time
int i;
int last = oldNum - 1;
// std::cerr << "Removing linear points... " << oldNum << std::endl;
// insert nonlienaer points in new array
for( i = 0; i < oldNum; ++i )
{
Vec2d p = globalverts[ vertices[ i ] ];
// check for double vertices
if( DCTPVecIsNotEqual( p , globalverts[ vertices[ last ] ] ) )
{
Vec2d pp = globalverts[ vertices[ last ] ];
Vec2d pn = globalverts[ vertices[ ( i + 1 ) % oldNum ] ];
if( ( ( p[0] - min[0] < DCTP_EPS ) && ( pn[0] - min[0] < DCTP_EPS ) ) ||
( ( p[1] - min[1] < DCTP_EPS ) && ( pn[1] - min[1] < DCTP_EPS ) ) ||
( ( max[0] - p[0] < DCTP_EPS ) && ( max[0] - pn[0] < DCTP_EPS ) ) ||
( ( max[1] - p[1] < DCTP_EPS ) && ( max[1] - pn[1] < DCTP_EPS ) ) )
{
newPoints[ newNum ] = vertices[ i ];
++newNum;
last = i;
}
else
{
double d1[ 2 ], d2[ 2 ], d3[ 2 ];
d1[ 0 ] = pp[0];
d1[ 1 ] = pp[1];
d2[ 0 ] = p[0];
d2[ 1 ] = p[1];
d3[ 0 ] = pn[0];
d3[ 1 ] = pn[1];
if( orient2d( d1, d2, d3 ) != 0 )
{
newPoints[ newNum ] = vertices[ i ];
++newNum;
last = i;
}
/* else if( ( pp[1] != pn[1] ) && ( pp[0] != pn[0] ) )
{
std::cerr << "removing point " <<std::endl;
std::cerr << pp[0] << "," << pp[1] << std::endl;
std::cerr << "(" << p[0] << "," << p[1] << ")" << std::endl;
std::cerr << pn[0] << "," << pn[1] << std::endl;
char x[ 256 ];
gets( x );
}*/
}
}
}
// std::cerr << newNum << " points left." << std::endl;
// copy new points
if( newNum != oldNum )
{
vertices.resize( newNum );
for( i = 0; i < newNum; ++i )
{
vertices[ i ] = newPoints[ i ];
}
return 1;
}
return 0;
}
void QLCDNumber::internalSetString( const QString& s )
{
QString buffer;
int i;
int len = s.length();
QBitArray newPoints(ndigits);
if ( !smallPoint ) {
if ( len == ndigits )
buffer = s;
else
buffer = s.right( ndigits ).rightJustify( ndigits, ' ' );
} else {
int index = -1;
bool lastWasPoint = TRUE;
newPoints.clearBit(0);
for ( i=0; i<len; i++ ) {
if ( s[i] == '.' ) {
if ( lastWasPoint ) { // point already set for digit?
if ( index == ndigits - 1 ) // no more digits
break;
index++;
buffer[index] = ' '; // 2 points in a row, add space
}
newPoints.setBit(index); // set decimal point
lastWasPoint = TRUE;
} else {
if ( index == ndigits - 1 )
break;
index++;
buffer[index] = s[i];
newPoints.clearBit(index); // decimal point default off
lastWasPoint = FALSE;
}
}
if ( index < ((int) ndigits) - 1 ) {
for( i=index; i>=0; i-- ) {
buffer[ndigits - 1 - index + i] = buffer[i];
newPoints.setBit( ndigits - 1 - index + i,
newPoints.testBit(i) );
}
for( i=0; i<ndigits-index-1; i++ ) {
buffer[i] = ' ';
newPoints.clearBit(i);
}
}
}
if ( buffer == digitStr )
return;
if ( backgroundMode() == FixedPixmap
|| colorGroup().brush( QColorGroup::Background ).pixmap() ) {
digitStr = buffer;
if ( smallPoint )
points = newPoints;
repaint( contentsRect() );
}
else {
QPainter p( this );
if ( !smallPoint )
drawString( buffer, p );
else
drawString( buffer, p, &newPoints );
}
}
MStatus puttyNode::deform( MDataBlock& block, MItGeometry& iter, const MMatrix& worldMatrix, unsigned int multiIndex)
{
// MGlobal::displayInfo("deform");
MStatus status = MS::kSuccess;
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// get inputs
//
// get the node ready flag
MDataHandle dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
if (!scriptSourced)
return MS::kSuccess;
dh = block.inputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting node ready data handle\n");
bool nodeReady = dh.asBool();
// if it's not ready, don't do anything
if (!nodeReady)
return MS::kSuccess;
dh = block.inputValue(aDefSpace,&status);
SYS_ERROR_CHECK(status, "Error getting defSpace data handle\n");
short defSpace = dh.asShort();
dh = block.inputValue(aDefWeights,&status);
SYS_ERROR_CHECK(status, "Error getting defWeights data handle\n");
short defWeights = dh.asShort();
dh = block.inputValue(aDefEnvelope,&status);
SYS_ERROR_CHECK(status, "Error getting defEnvelope data handle\n");
short defEnvelope = dh.asShort();
// get the command
dh = block.inputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString script = dh.asString();
/* if (script == "")
{
status = MS::kFailure;
USER_ERROR_CHECK(status, "no script provided!\n");
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// build mel cmd string
//
// check if it's a valid cmd
// get the envelope
//
double env = 1;
if (defEnvelope == MSD_ENVELOPE_AUTO)
{
dh = block.inputValue(envelope,&status);
SYS_ERROR_CHECK(status, "Error getting envelope data handle\n");
env = double(dh.asFloat());
// early stop 'cause there is nothing more to do
if (env == 0.0)
return MS::kSuccess;
}
// get the points, transform them into the right space if needed
//
int count = iter.count();
MVectorArray points(count);
for ( ; !iter.isDone(); iter.next())
points[iter.index()] = iter.position();
if ( defSpace == MSD_SPACE_WORLD )
{
for (int i = 0;i<count;i++)
points[i] = MPoint(points[i]) * worldMatrix;
}
// get the weights
//
MDoubleArray weights;
if ( defWeights == MSD_WEIGHTS_AUTO)
{
weights.setLength(count);
for (int i = 0;i<count;i++)
weights[i] = weightValue(block,multiIndex,i);
}
// get the object name and type
// get the input geometry, traverse through the data handles
MArrayDataHandle adh = block.outputArrayValue( input, &status );
SYS_ERROR_CHECK(status,"error getting input array data handle.\n");
status = adh.jumpToElement( multiIndex );
SYS_ERROR_CHECK(status, "input jumpToElement failed.\n");
// compound data
MDataHandle cdh = adh.inputValue( &status );
SYS_ERROR_CHECK(status, "error getting input inputValue\n");
// input geometry child
dh = cdh.child( inputGeom );
MObject dInputGeometry = dh.data();
// get the type
MString geometryType = dInputGeometry.apiTypeStr();
// get the name
// MFnDagNode dagFn( dInputGeometry, &status);
// SYS_ERROR_CHECK(status, "error converting geometry obj to dag node\n");
// MString geometryName = dagFn.fullPathName(&status);
// SYS_ERROR_CHECK(status, "error getting full path name \n");
// MString geometryType = "";
// MString geometryName = "";
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// set the current values on the temp plugs for the script to be picked up
//
// the position
MObject thisNode = thisMObject();
MPlug currPlug(thisNode,aCurrPosition);
MFnVectorArrayData vecD;
MObject currObj = vecD.create(points,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currPosPlug value\n");
// the weights
currPlug =MPlug(thisNode,aCurrWeight);
MFnDoubleArrayData dblD;
currObj = dblD.create(weights,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWeightsPlug value\n");
// world matrix
currPlug =MPlug(thisNode,aCurrWorldMatrix);
MFnMatrixData matD;
currObj = matD.create(worldMatrix,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWorldMatrixPlug value\n");
// the multi index
currPlug =MPlug(thisNode,aCurrMultiIndex);
currPlug.setValue(int(multiIndex));
SYS_ERROR_CHECK(status, "error setting currMultiIndexPlug value\n");
// geometry name/type
// currPlug =MPlug(thisNode,aCurrGeometryName);
// currPlug.setValue(geometryName);
// SYS_ERROR_CHECK(status, "error setting aCurrGeometryName value\n");
currPlug =MPlug(thisNode,aCurrGeometryType);
currPlug.setValue(geometryType);
SYS_ERROR_CHECK(status, "error setting aCurrGeometryType value\n");
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// execute the mel script
//
MString melCmd = script+"(\"" +name()+"\","+count+")";
MCommandResult melResult;
status = MGlobal::executeCommand(melCmd,melResult);
// if the command did not work, then try to resource the script
// (might have been that we were in a fresh scene and nothing was ready yet
if (status != MS::kSuccess)
{
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString scriptFile = dh.asString();
// try to source the script
MString cmd = "source \"" + scriptFile+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
// if successfull, retry the command
if (!status.error())
{
status = MGlobal::executeCommand(melCmd,melResult);
}
}
USER_ERROR_CHECK(status, "Error executing mel command, please check the function you provided is valid, error free and has the appropriate parameters!");
// check the result type
if ((melResult.resultType()) != (MCommandResult::kDoubleArray))
{
USER_ERROR_CHECK(MS::kFailure, "result of mel command has wrong type, should be doubleArray (which will be interpreted as vectorArray)!");
}
// get the result as a double array
MDoubleArray newP;
status = melResult.getResult(newP);
USER_ERROR_CHECK(status, "Error getting result of mel command!");
int newCount = newP.length()/3;
// size check
if (newCount != count)
{
USER_ERROR_CHECK(MS::kFailure, "the size of the result does not match the size of the input!");
}
// convert the double array into a vector array
MPointArray newPoints(newCount);
for(int i=0;i<newCount;i++)
newPoints[i]=MPoint(newP[i*3],newP[i*3+1],newP[i*3+2]);
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// interprete and apply the result
//
// do the envelope and weights
if ((defEnvelope == MSD_ENVELOPE_AUTO)||((defWeights == MSD_WEIGHTS_AUTO)))
{
MDoubleArray envPP(count, env);
if (defWeights == MSD_WEIGHTS_AUTO)
{
for (int i = 0;i<count;i++)
envPP[i] *= weights[i];
}
// linear interpolation between old and new points
for (int i = 0;i<count;i++)
newPoints[i] = (points[i] * (1-envPP[i])) + (newPoints[i] * envPP[i]);
}
// retransform the result if it was in world space
if ( defSpace == MSD_SPACE_WORLD )
{
MMatrix worldMatrixInv = worldMatrix.inverse();
for (int i = 0;i<count;i++)
newPoints[i] *= worldMatrixInv;
}
// set the points
iter.reset();
for ( ; !iter.isDone(); iter.next())
iter.setPosition(newPoints[iter.index()]);
return status;
}
// Collapses small edge to point, thus removing triangle.
label collapseEdge(triSurface& surf, const scalar minLen)
{
label nTotalCollapsed = 0;
while (true)
{
const pointField& localPoints = surf.localPoints();
const List<labelledTri>& localFaces = surf.localFaces();
// Mapping from old to new points
labelList pointMap(surf.nPoints());
forAll(pointMap, i)
{
pointMap[i] = i;
}
// Storage for new points.
pointField newPoints(localPoints);
// To protect neighbours of collapsed faces.
boolList okToCollapse(surf.size(), true);
label nCollapsed = 0;
forAll(localFaces, faceI)
{
if (okToCollapse[faceI])
{
// Check edge lengths.
const triSurface::FaceType& f = localFaces[faceI];
forAll(f, fp)
{
label v = f[fp];
label v1 = f[f.fcIndex(fp)];
if (mag(localPoints[v1] - localPoints[v]) < minLen)
{
// Collapse f[fp1] onto f[fp].
pointMap[v1] = v;
newPoints[v] = 0.5*(localPoints[v1] + localPoints[v]);
Pout<< "Collapsing triange " << faceI << " to edge mid "
<< newPoints[v] << endl;
nCollapsed++;
okToCollapse[faceI] = false;
// Protect point neighbours from collapsing.
markPointNbrs(surf, faceI, false, okToCollapse);
break;
}
}
}
}
Pout<< "collapseEdge : collapsing " << nCollapsed << " triangles"
<< endl;
nTotalCollapsed += nCollapsed;
if (nCollapsed == 0)
{
break;
}
// Pack the triangles
surf = pack(surf, newPoints, pointMap);
}
void Foam::meshRefinement::snapToSurface
(
labelList& pointSurfaceRegion,
labelList& edgeSurfaceRegion,
scalarField& edgeWeight
)
{
const edgeList& edges = mesh_.edges();
const pointField& points = mesh_.points();
pointSurfaceRegion.setSize(points.size());
pointSurfaceRegion = -1;
edgeSurfaceRegion.setSize(edges.size());
edgeSurfaceRegion = -1;
edgeWeight.setSize(edges.size());
edgeWeight = -GREAT;
// Do test for intersections
// ~~~~~~~~~~~~~~~~~~~~~~~~~
labelList surface1;
List<pointIndexHit> hit1;
labelList region1;
//vectorField normal1;
labelList surface2;
List<pointIndexHit> hit2;
labelList region2;
//vectorField normal2;
{
vectorField start(edges.size());
vectorField end(edges.size());
forAll(edges, edgei)
{
const edge& e = edges[edgei];
start[edgei] = points[e[0]];
end[edgei] = points[e[1]];
}
surfaces_.findNearestIntersection
(
//labelList(1, 0), //identity(surfaces_.surfaces().size()),
identity(surfaces_.surfaces().size()),
start,
end,
surface1,
hit1,
region1,
//normal1,
surface2,
hit2,
region2
//normal2
);
}
// Adjust location
// ~~~~~~~~~~~~~~~
pointField newPoints(points);
label nAdjusted = 0;
const labelListList& pointEdges = mesh_.pointEdges();
forAll(pointEdges, pointi)
{
const point& pt = points[pointi];
const labelList& pEdges = pointEdges[pointi];
// Get the nearest intersection
label minEdgei = -1;
scalar minFraction = 0.5; // Harpoon 0.25; // Samm?
forAll(pEdges, pEdgei)
{
label edgei = pEdges[pEdgei];
if (hit1[edgei].hit())
{
const point& hitPt = hit1[edgei].hitPoint();
const edge& e = edges[edgei];
label otherPointi = e.otherVertex(pointi);
const point& otherPt = points[otherPointi];
vector eVec(otherPt-pt);
scalar f = eVec&(hitPt-pt)/magSqr(eVec);
if (f < minFraction)
{
minEdgei = edgei;
minFraction = f;
}
}
}
if (minEdgei != -1 && minFraction >= 0.01)
{
// Move point to intersection with minEdgei
if (pointSurfaceRegion[pointi] == -1)
{
pointSurfaceRegion[pointi] = surfaces_.globalRegion
(
surface1[minEdgei],
region1[minEdgei]
);
newPoints[pointi] = hit1[minEdgei].hitPoint();
nAdjusted++;
}
}
}
