void SoNodeToName::evaluate()
{
// make room as necessary
SO_ENGINE_OUTPUT(output, SoMFString, setNum(input.getNum()));
int next = 0;
for( int i = 0; i < input.getNum(); i++ )
{
SoNode * node = input[i];
if( node == NULL || node->getName() == "" )
{
if( compact.getValue() == FALSE )
{
SO_ENGINE_OUTPUT(output, SoMFString, set1Value(next, ""));
next++;
}
}
else
{
SO_ENGINE_OUTPUT(output, SoMFString, set1Value(next, node->getName().getString()));
next++;
}
}
// truncate as necessary
SO_ENGINE_OUTPUT(output, SoMFString, setNum(next));
}
void
SoMFColor::set1HSVValue(int index, const float hsv[3])
{
SbColor c;
c.setHSVValue(hsv);
set1Value(index, c);
}
void
SoMFColor::set1HSVValue(int index, float h, float s, float v)
{
SbColor c;
c.setHSVValue(h, s, v);
set1Value(index, c);
}
void
SoBoolOperation::evaluate()
//
////////////////////////////////////////////////////////////////////////
{
int na = a.getNum();
int nb = b.getNum();
int noperation = operation.getNum();
int nout = max(na,nb,noperation);
SO_ENGINE_OUTPUT(output, SoMFBool, setNum(nout));
SO_ENGINE_OUTPUT(inverse, SoMFBool, setNum(nout));
for (int i=0; i<nout; i++) {
SbBool va = a[clamp(i,na)];
SbBool vb = b[clamp(i,nb)];
SbBool result;
switch (operation[clamp(i,noperation)]) {
case CLEAR: result = FALSE; break;
case SET: result = TRUE; break;
case A: result = va; break;
case NOT_A: result = !va; break;
case B: result = vb; break;
case NOT_B: result = !vb; break;
case A_OR_B: result = va || vb; break;
case NOT_A_OR_B: result = (!va) || vb; break;
case A_OR_NOT_B: result = va || (!vb); break;
case NOT_A_OR_NOT_B: result = (!va) || (!vb); break;
case A_AND_B: result = va && vb; break;
case NOT_A_AND_B: result = (!va) && (vb); break;
case A_AND_NOT_B: result = va && (!vb); break;
case NOT_A_AND_NOT_B: result = (!va) && (!vb); break;
case A_EQUALS_B: result = (va == vb); break;
case A_NOT_EQUALS_B: result = (va != vb); break;
}
SO_ENGINE_OUTPUT(output, SoMFBool, set1Value(i, result));
SO_ENGINE_OUTPUT(inverse, SoMFBool, set1Value(i, !result));
}
}
// Documented in superclass.
void
SoDecomposeMatrix::evaluate()
{
int num = this->matrix.getNum();
SO_ENGINE_OUTPUT(translation,SoMFVec3f,setNum(num));
SO_ENGINE_OUTPUT(rotation,SoMFRotation,setNum(num));
SO_ENGINE_OUTPUT(scaleFactor,SoMFVec3f,setNum(num));
SO_ENGINE_OUTPUT(scaleOrientation,SoMFRotation,setNum(num));
int i;
SbVec3f translationVal,scaleFactorVal;
SbRotation rotationVal,scaleOrientationVal;
for (i = 0; i < num; i++) {
SbVec3f c = (i < center.getNum()) ? center[i] : SbVec3f(0.0f, 0.0f, 0.0f);
this->matrix[i].getTransform(translationVal,rotationVal,scaleFactorVal,
scaleOrientationVal, c);
SO_ENGINE_OUTPUT(translation,SoMFVec3f,set1Value(i,translationVal));
SO_ENGINE_OUTPUT(rotation,SoMFRotation,set1Value(i,rotationVal));
SO_ENGINE_OUTPUT(scaleFactor,SoMFVec3f,set1Value(i,scaleFactorVal));
SO_ENGINE_OUTPUT(scaleOrientation,SoMFRotation,
set1Value(i,scaleOrientationVal));
}
}
void MFInt32::setValue(jobject field, int bConstField) {
assert(field);
JNIEnv *jniEnv = getJniEnv();
jclass classid = bConstField ? getConstFieldID() : getFieldID();
jmethodID getSizeMethod = bConstField ? getConstGetSizeMethodID() : getGetSizeMethodID();
jmethodID getValueMethod = bConstField ? getConstGet1ValueMethodID() : getGet1ValueMethodID();
assert(classid && getValueMethod);
jint jsize = jniEnv->CallIntMethod(field, getSizeMethod);
int size = getSize();
for (int n=0; n<jsize; n++) {
jint value = jniEnv->CallIntMethod(field, getValueMethod, n);
if (n < size)
set1Value(0, value);
else
addValue(value);
}
}
// Documented in superclass.
void
SoComposeMatrix::evaluate()
{
int numTranslation = this->translation.getNum();
int numRotation = this->rotation.getNum();
int numScaleFactor = this->scaleFactor.getNum();
int numScaleOrientation = this->scaleOrientation.getNum();
int numCenter = this->center.getNum();
int numOut = numTranslation > numRotation? numTranslation:numRotation;
int numOut2 =
numScaleFactor>numScaleOrientation?numScaleFactor:numScaleOrientation;
numOut2 = numOut2>numCenter?numOut2:numCenter;
numOut = numOut>numOut2?numOut:numOut2;
SO_ENGINE_OUTPUT(matrix,SoMFMatrix,setNum(numOut));
int i;
for (i=0;i<numOut;i++) {
const SbVec3f translationVal=
i<numTranslation?this->translation[i]:this->translation[numTranslation-1];
const SbVec3f scaleFactorVal=
i<numScaleFactor?this->scaleFactor[i]:this->scaleFactor[numScaleFactor-1];
const SbVec3f centerVal=i<numCenter?this->center[i]:this->center[numCenter-1];
const SbRotation rotationVal=
i<numRotation?this->rotation[i]:this->rotation[numRotation-1];
const SbRotation scaleOrientationVal=
i<numScaleOrientation?
this->scaleOrientation[i]:this->scaleOrientation[numScaleOrientation-1];
SbMatrix mat;
mat.setTransform(translationVal,rotationVal,scaleFactorVal,
scaleOrientationVal,centerVal);
SO_ENGINE_OUTPUT(matrix,SoMFMatrix,set1Value(i,mat));
}
}
void
SoDoubleCalculator::evaluate()
//
////////////////////////////////////////////////////////////////////////
{
if (reparse) {
parser->clear();
SbBool OK = TRUE;
int i;
for (i=0; i<expression.getNum(); i++) {
if (!parser->parse(expression[i].getString())) {
OK = FALSE;
break;
}
}
if (! OK) {
#ifdef DEBUG
SoDebugError::post("SoDoubleCalculator::evaluate",
"Invalid expression '%s'",
expression[i].getString());
#endif /* DEBUG */
expression.setValue("");
parser->clear();
}
reparse = FALSE;
}
int max = 0;
int na = a.getNum(); if (na > max) max = na;
int nb = b.getNum(); if (nb > max) max = nb;
int nc = c.getNum(); if (nc > max) max = nc;
int nd = d.getNum(); if (nd > max) max = nd;
int ne = e.getNum(); if (ne > max) max = ne;
int nf = f.getNum(); if (nf > max) max = nf;
int ng = g.getNum(); if (ng > max) max = ng;
int nh = h.getNum(); if (nh > max) max = nh;
int nA = A.getNum(); if (nA > max) max = nA;
int nB = B.getNum(); if (nB > max) max = nB;
int nC = C.getNum(); if (nC > max) max = nC;
int nD = D.getNum(); if (nD > max) max = nD;
int nE = E.getNum(); if (nE > max) max = nE;
int nF = F.getNum(); if (nF > max) max = nF;
int nG = G.getNum(); if (nG > max) max = nG;
int nH = H.getNum(); if (nG > max) max = nH;
int nout = max;
SO_ENGINE_OUTPUT(oa, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(ob, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(oc, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(od, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(oA, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(oB, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(oC, SoMFDouble, setNum(nout));
SO_ENGINE_OUTPUT(oD, SoMFDouble, setNum(nout));
for (int i=0; i<nout; i++) {
va = a[clamp(i,na)];
vb = b[clamp(i,nb)];
vc = c[clamp(i,nc)];
vd = d[clamp(i,nd)];
ve = e[clamp(i,ne)];
vf = f[clamp(i,nf)];
vg = g[clamp(i,ng)];
vh = h[clamp(i,nh)];
vA = A[clamp(i,nA)];
vB = B[clamp(i,nB)];
vC = C[clamp(i,nC)];
vD = D[clamp(i,nD)];
vE = E[clamp(i,nE)];
vF = F[clamp(i,nF)];
vG = G[clamp(i,nG)];
vH = H[clamp(i,nH)];
ova = 0;
ovb = 0;
ovc = 0;
ovd = 0;
ovA = SbVec3f(0,0,0);
ovB = SbVec3f(0,0,0);
ovC = SbVec3f(0,0,0);
ovD = SbVec3f(0,0,0);
parser->eval();
SO_ENGINE_OUTPUT(oa, SoMFDouble, set1Value(i, ova));
SO_ENGINE_OUTPUT(ob, SoMFDouble, set1Value(i, ovb));
SO_ENGINE_OUTPUT(oc, SoMFDouble, set1Value(i, ovc));
SO_ENGINE_OUTPUT(od, SoMFDouble, set1Value(i, ovd));
SO_ENGINE_OUTPUT(oA, SoMFVec3f, set1Value(i, ovA));
SO_ENGINE_OUTPUT(oB, SoMFVec3f, set1Value(i, ovB));
SO_ENGINE_OUTPUT(oC, SoMFVec3f, set1Value(i, ovC));
SO_ENGINE_OUTPUT(oD, SoMFVec3f, set1Value(i, ovD));
}
}
void
SoXipComposeVec6::evaluate()
{
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, setNum(6));
// intersection of plane and volume
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(0, xmin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(1, xmax.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(2, ymin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(3, ymax.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(4, zmin.getValue()) );
SO_ENGINE_OUTPUT(outVOI, SoMFInt32, set1Value(5, zmax.getValue()) );
// Reset outputs
SO_ENGINE_OUTPUT( numSlices, SoSFShort, setValue(0) );
SO_ENGINE_OUTPUT( output, SoXipSFDataImage, setValue(0) );
SoXipDataImage* imageData = image.getValue();
if( mImageData != imageData )
{
mImageData = image.getValue();
// Reset previous outputs
mOutputs.setNum(0);
if( mImageData )
{
SbXipImage* image = mImageData->get();
if( !image )
return ;
// Initialize outputs
unsigned int numSlices = image->getDimStored()[2];
mOutputs.setNum( numSlices );
for( unsigned int i = 0; i < numSlices; ++ i )
mOutputs.set1Value( i, 0 );
}
}
if( imageData )
{
SbXipImage* image = mImageData->get();
if( !image )
return ;
SbXipImageDimensions dimensions = image->getDimStored();
SbXipImageDimensions sliceDimensions = dimensions;
sliceDimensions[2] = 1;
int sliceIndex = this->sliceIndex.getValue();
if( sliceIndex < 0 || sliceIndex >= dimensions[2] )
return ;
if( mOutputs[sliceIndex] == 0 )
{
// Compute the model matrix of the selected frame
SbMatrix sliceModelMatrix = image->getModelMatrix();
sliceModelMatrix[2][0] /= dimensions[2];
sliceModelMatrix[2][1] /= dimensions[2];
sliceModelMatrix[2][2] /= dimensions[2];
sliceModelMatrix[3][0] += sliceIndex * sliceModelMatrix[2][0];
sliceModelMatrix[3][1] += sliceIndex * sliceModelMatrix[2][1];
sliceModelMatrix[3][2] += sliceIndex * sliceModelMatrix[2][2];
// Pointer to the selected slice
char* imagePtr = (char *) image->refBufferPtr();
unsigned int cellSize;
switch( image->getType() )
{
case SbXipImage::UNSIGNED_BYTE: cellSize = sizeof(unsigned char); break ;
case SbXipImage::BYTE: cellSize = sizeof(char); break ;
case SbXipImage::UNSIGNED_SHORT: cellSize = sizeof(unsigned short); break ;
case SbXipImage::SHORT: cellSize = sizeof(short); break ;
case SbXipImage::UNSIGNED_INT: cellSize = sizeof(unsigned int); break ;
case SbXipImage::INT: cellSize = sizeof(int); break ;
case SbXipImage::FLOAT: cellSize = sizeof(float); break ;
case SbXipImage::DOUBLE: cellSize = sizeof(double); break ;
}
void* slicePtr = imagePtr + cellSize * image->getComponents() * dimensions[0] * dimensions[1] * sliceIndex;
SbXipImage* slice = new SbXipImage( sliceDimensions, image->getType(), image->getBitsStored(), slicePtr,
image->getComponents(), image->getComponentType(), image->getComponentLayoutType(), sliceModelMatrix,
image->getLineAlignment() );
image->unrefBufferPtr();
SoXipDataImage* output = new SoXipDataImage();
output->ref();
output->set( slice );
output->addRef( imageData );
mOutputs.set1Value( sliceIndex, output );
}
SO_ENGINE_OUTPUT( output, SoXipSFDataImage, setValue(mOutputs[sliceIndex]) );
}
}
void
SoMFColor::set1Value(int index, const float rgb[3])
{
set1Value(index, SbColor(rgb));
}
void
SoMFColor::set1Value(int index, float r, float g, float b)
{
set1Value(index, SbColor(r, g, b));
}
void
SoMFColor::set1Value(int index, const SbVec3f &vec)
{
set1Value(index, SbColor(vec.getValue()));
}
