//----------------------------------------------------------------------------------
//! Handle field changes of the field field.
//----------------------------------------------------------------------------------
void FuzzyConnectedness::handleNotification (Field *field)
{
ML_TRACE_IN("FuzzyConnectedness::handleNotification ()");
// Calculation will only be performed if either the start
// button is pressed or the auto update mechanism is used.
if ((field ==_startButtonFld) || ((field != _startButtonFld) && _autoUpdateFld->isOn()))
{
_state = ML_RESULT_OK;
//If either input image is open the calculation will be cancelled.
if(!getUpdatedInImg(0) || !getUpdatedInImg(1))
{
_state = ML_DISCONNECTED_GRAPH;
clearData();
getOutImg(0)->setOutOfDate();
getOutImg(1)->setOutOfDate();
getOutField(0)->notifyAttachments();
getOutField(1)->notifyAttachments();
}
else
{
// Same extent of image data and seed point image are required
if ( getUpdatedInImg(0)->getImgExt() != getUpdatedInImg(1)->getImgExt() )
{
_state=ML_BAD_DIMENSION;
}
// Calculation will be started here
else{
_state = calculate(getUpdatedInImg(0),getUpdatedInImg(1));
}
}
// Let the connected modules know that the output has changed.
getOutField(0)->notifyAttachments();
getOutField(1)->notifyAttachments();
}
}
//! Modify item at position \a index. If \a fromCurrentItem is true, the
//! item is copied from _currentItem, otherwise the item property corresponding
//! to the property field \a field is modified.
//! Return true if item has been modified.
bool ColoredMarkerListContainer::modifyItem(MLssize_t index, Field *field, bool fromCurrentItem)
{
ML_TRACE_IN("bool ColoredMarkerListContainer::modifyItem(MLssize_t index, Field *field, bool fromCurrentItem)");
ML_TRY{
bool modified = true;
ColoredMarker *marker=NULL;
// Valid list and item?
if (_listPtr && (index >= 0) && (index < mlrange_cast<MLssize_t>(_listPtr->getSize())) )
{
// Modify from property field?
if (!fromCurrentItem)
{
// Pointer to list item
marker = &(*_listPtr)[mlrange_cast<size_t>(index)];
// Position fields
if ((field == _fldPos3D) || (field == _fldPosC) || (field == _fldPosT) || (field == _fldPosU))
{
marker->pos = Vector6(_fldPos3D->getVector3Value(),0,0,0);
marker->c() = _fldPosC->getFloatValue();
marker->t() = _fldPosT->getFloatValue();
marker->u() = _fldPosU->getFloatValue();
}
else if (field == _fldColor || (field == _fldAlpha))
{
// ImageVector field
marker->rgba() = Vector4(_fldColor->getVector3Value(),_fldAlpha->getFloatValue());
}
else if (field == _fldType)
{
// Type field
marker->type = _fldType->getIntValue();
}
else
{
// Not an ColoredMarker-specific field, pass call to base class
modified = ListContainerTemplate<ColoredMarkerList>::modifyItem(index, field, fromCurrentItem);
}
}
else
{
// Modify from _currentItem, handled in base class
modified = ListContainerTemplate<ColoredMarkerList>::modifyItem(index, field, fromCurrentItem);
}
} else
{
modified = false;
}
return modified;
}
ML_CATCH_RETHROW;
}
//----------------------------------------------------------------------------------
//! Handle notifications of CSOList
//----------------------------------------------------------------------------------
void CSOPointsToXMarkers::CSOListNotifyObserverCB(void* userData, int /*notificationFlag*/)
{
ML_TRACE_IN("CSOPointsToXMarkers::_csoListNotifyObserverCB");
CSOPointsToXMarkers * thisPointer = static_cast<CSOPointsToXMarkers*>(userData);
thisPointer->convertCSOToXMarkerList();
}
void ListModifyProperties::activateAttachments() {
ML_TRACE_IN("void ListModifyProperties::activateAttachments()");
Engine::activateAttachments();
_autoUpdateModeFld->touch();
}
//! Return true if \a field points to an item property field
bool ColoredMarkerListContainer::isPropertyField(Field *field)
{
ML_TRACE_IN("bool ColoredMarkerListContainer::isPropertyField(Field *field)");
return ( (field == _fldPos3D) || (field == _fldPosC) || (field == _fldPosT) || (field == _fldPosU) ||
(field == _fldColor) || (field == _fldAlpha) || (field == _fldType) || ListContainerBase::isPropertyField(field) );
}
//----------------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------------
WEMVolume::WEMVolume (std::string type)
: WEMInspector(type)
{
ML_TRACE_IN("WEMVolume::WEMVolume()")
FieldContainer *fields = getFieldContainer();
ML_CHECK(fields);
// Suppress calls of handleNotification on field changes.
handleNotificationOff();
// Add min, max volume, and corresponding index fields
_minVolumeFld = fields->addFloat("minVolume");
_minVolumeFld->setFloatValue(0.0f);
_maxVolumeFld = fields->addFloat("maxVolume");
_maxVolumeFld->setFloatValue(0.0f);
_minVolumeIndexFld = fields->addInt("minVolumePatchIndex");
_minVolumeIndexFld->setIntValue(0);
_maxVolumeIndexFld = fields->addInt("maxVolumePatchIndex");
_maxVolumeIndexFld->setIntValue(0);
// Add output curve field
_outputVolumeCurveFld = fields->addBase("outputVolumeCurve");
_outputVolumeCurveFld->setBaseValue(&_outputVolumeCurve);
// Reactivate calls of handleNotification on field changes.
handleNotificationOn();
}
//----------------------------------------------------------------------------------
//! Handle field changes of the field \c field.
//----------------------------------------------------------------------------------
void WEMVolume::handleNotification (Field *field)
{
ML_TRACE_IN("WEMVolume::handleNotification()")
// call parent class and handle apply/autoApply and in/outputs
WEMInspector::handleNotification(field);
}
void CSODistance::_csoListNotificationCB(void* userData, int notificationFlag)
{
ML_TRACE_IN("void CSODistance::_csoListNotificationCB()");
CSODistance* thisp = static_cast<CSODistance*>(userData);
thisp->_isInNotificationCB = true;
bool autoApply = thisp->_autoApplyFld->getBoolValue();
if ((notificationFlag & CSOList::NOTIFICATION_CSO_SELECTION) ||
(notificationFlag & CSOList::NOTIFICATION_GROUP_SELECTION))
{
if (thisp->_listenToSelectionChangedNotificationsFld->getBoolValue()){
if (autoApply) { thisp->_process(); }
}
}
if ((notificationFlag & CSOList::NOTIFICATION_CSO_FINISHED) ||
(notificationFlag & CSOList::NOTIFICATION_GROUP_FINISHED))
{
if (thisp->_listenToFinishingNotificationsFld->getBoolValue()){
if (autoApply) { thisp->_process(); }
}
}
if (notificationFlag & CSOList::NOTIFICATION_REPAINT){
if (thisp->_listenToRepaintNotificationsFld->getBoolValue()){
if (autoApply) { thisp->_process(); }
}
}
if (notificationFlag & CSOList::NOTIFICATION_INTERACTION_INIT){
// do nothing
}
thisp->_isInNotificationCB = false;
}
//----------------------------------------------------------------------------------
//! Code below is performed after module and network initialization.
//----------------------------------------------------------------------------------
void WEMVolume::activateAttachments()
{
ML_TRACE_IN("WEMVolume::activateAttachments()")
// call parent class
WEMInspector::activateAttachments();
}
//----------------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------------
StringToCurve::StringToCurve () : BaseOp(0, 0)
{
ML_TRACE_IN("StringToCurve::StringToCurve ()")
handleNotificationOff();
FieldContainer *fieldC = getFieldContainer();
m_OutCurveList = new CurveList;
f_OutCurveList = fieldC->addBase( "outCurveList" );
f_OutCurveList->setBaseValue( m_OutCurveList );
f_CurveString = fieldC->addString("curveString");
f_CurveString->setStringValue("");
f_IndexString = fieldC->addString("indexString");
f_IndexString->setStringValue("");
f_ValueSeparator = fieldC->addString("valueSeparator");
f_ValueSeparator->setStringValue(" ");
f_CurveSeparator = fieldC->addString( "curveSeparator" );
f_CurveSeparator->setStringValue(";");
handleNotificationOn();
}
//----------------------------------------------------------------------------------
//! Handle field changes of the field field.
//----------------------------------------------------------------------------------
void StringToCurve::handleNotification (Field * /*field*/)
{
ML_TRACE_IN("StringToCurve::handleNotification ()");
UpdateCurve();
f_OutCurveList->notifyAttachments();
}
//----------------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------------
WEMCMSelectPatches::WEMCMSelectPatches (std::string type)
: WEMProcessor(type, false)
{
ML_TRACE_IN("WEMCMSelectPatches::WEMCMSelectPatches()")
FieldContainer *fields = getFieldContainer();
ML_CHECK(fields);
// Suppress calls of hanbdleNotification on field changes.
handleNotificationOff();
// WEM Patch start and end index field
_patchStartIndexFld = fields->addInt("patchStartIndex");
_patchStartIndexFld->setIntValue(0);
_patchEndIndexFld = fields->addInt("patchEndIndex");
_patchEndIndexFld->setIntValue(0);
// Bool field to enable to select only one patch based on start index value
_onePatchFld = fields->addBool("onePatch");
_onePatchFld->setBoolValue(false);
// Set auto apply fields
_autoApplyFld->setBoolValue(true);
_notifyFld = fields->addNotify("notify");
// Reactivate calls of handleNotification on field changes.
handleNotificationOn();
}
ML_START_NAMESPACE
// Initialization of the run type system
int MLBaseListExtensionsInit()
{
ML_TRACE_IN("MLBaseListExtensionsInit()")
IndexPair ::initClass();
IndexPairList ::initClass();
IndexPairListContainer ::initClass();
ColoredMarker ::initClass();
ColoredMarkerList ::initClass();
ColoredMarkerListContainer ::initClass();
XMarkerToColoredMarker ::initClass();
ColoredMarkerToXMarker ::initClass();
ListInfo ::initClass();
ListFilter ::initClass();
ListModifyProperties ::initClass();
MarkerListImport ::initClass();
return 1;
}
//----------------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------------
CalcCodedSegmentation::CalcCodedSegmentation (void) : BaseOp(1, 1)
{
ML_TRACE_IN("CalcCodedSegmentation::CalcCodedSegmentation()")
FieldContainer *fields = getFieldContainer();
// Suppress calls of handleNotification on field changes.
handleNotificationOff();
MAX_SIZE = SHRT_MAX; //32767
_fld_Add = fields->addNotify("Add");
(_fld_NameToAdd = fields->addString("NameToAdd"))->setStringValue("");
(_fld_addMinValue = fields->addInt("addMinValue"))->setIntValue(1);
(_fld_addMaxValue = fields->addInt("addMaxValue"))->setIntValue(ML_INT_MAX);
(_fld_addAllExceptNull = fields->addBool("addAllExceptNull"))->setBoolValue(false);
_fld_Reset = fields->addNotify("Reset");
_fld_Purge = fields->addNotify("Purge");
_fld_Finish = fields->addNotify("Finish");
(_fld_ImageValues = fields->addString("ImageValues"))->setStringValue("");
(_fld_ObjectValues = fields->addString("ObjectValues"))->setStringValue("");
//All pointer values need to be set NULL here, before reset, otherwise, default random values of pointe can be interpreted as real values and a non existing pointer is tried to delete ... uuhhhh
_virtualVolume = NULL;
replaceValues = NULL;
objectValues = NULL;
valuesForObjects = NULL;
objectNames = NULL;
reset();
// Reactivate calls of handleNotification on field changes.
handleNotificationOn();
}
//----------------------------------------------------------------------------------
//! Constructor
//----------------------------------------------------------------------------------
WEMNodesToFile::WEMNodesToFile (std::string type)
: WEMInspector(type)
{
ML_TRACE_IN("WEMNodesToFile::WEMNodesToFile()")
FieldContainer *fields = getFieldContainer();
ML_CHECK(fields);
// Suppress calls of handleNotification on field changes.
handleNotificationOff();
// Add filename field
_filenameFld = fields->addString("filename");
_filenameFld->setStringValue("");
// Add transformix option field
_transformixCompatibleFld = fields->addBool("transformixCompatible");
_transformixCompatibleFld->setBoolValue(false);
// Add save button
_saveFld = fields->addNotify("save");
// Reactivate calls of handleNotification on field changes.
handleNotificationOn();
}
//----------------------------------------------------------------------------------
//! Code below is performed after module and network initialization.
//----------------------------------------------------------------------------------
void WEMCenterOfMass::activateAttachments()
{
ML_TRACE_IN("WEMCenterOfMass::activateAttachments()")
// call parent class
WEMInspector::activateAttachments();
}
void MainAxisPCA::getInverseMatrix(float **aMatrix, float **invMatrix)
{
ML_TRACE_IN("void MainAxisPCA::getInverseMatrix(float **aMatrix, float **invMatrix) ");
// Compute inverse matrix (only for 3x3 matrices)
// calculate determinant D and multiply the result with 1/D
float det = aMatrix[1][1] * aMatrix[2][2] * aMatrix[3][3]
+ aMatrix[1][2] * aMatrix[2][3] * aMatrix[3][1]
+ aMatrix[1][3] * aMatrix[2][1] * aMatrix[3][2]
- aMatrix[1][3] * aMatrix[2][2] * aMatrix[3][1]
- aMatrix[1][1] * aMatrix[2][3] * aMatrix[3][2]
- aMatrix[1][2] * aMatrix[2][1] * aMatrix[3][3];
if (det != 0){ det = 1.0f/det; }
// Compute adjacent matrix, transpose it and multiply with D
invMatrix[1][1] = det * (aMatrix[2][2] * aMatrix[3][3] - aMatrix[2][3] * aMatrix[3][2]);
invMatrix[2][1] = -det * (aMatrix[2][1] * aMatrix[3][3] - aMatrix[2][3] * aMatrix[3][1]);
invMatrix[3][1] = det * (aMatrix[2][1] * aMatrix[3][2] - aMatrix[2][2] * aMatrix[3][1]);
invMatrix[1][2] = -det * (aMatrix[1][2] * aMatrix[3][3] - aMatrix[1][3] * aMatrix[3][2]);
invMatrix[2][2] = det * (aMatrix[1][1] * aMatrix[3][3] - aMatrix[1][3] * aMatrix[3][1]);
invMatrix[3][2] = -det * (aMatrix[1][1] * aMatrix[3][2] - aMatrix[1][2] * aMatrix[3][1]);
invMatrix[1][3] = det * (aMatrix[1][2] * aMatrix[2][3] - aMatrix[1][3] * aMatrix[2][2]);
invMatrix[2][3] = -det * (aMatrix[1][1] * aMatrix[2][3] - aMatrix[1][3] * aMatrix[2][1]);
invMatrix[3][3] = det * (aMatrix[1][1] * aMatrix[2][2] - aMatrix[1][2] * aMatrix[2][1]);
}
float* MainAxisPCA::calcBaryCenter(const float* vertices, int size)
{
ML_TRACE_IN("float* MainAxisPCA::calcBaryCenter(const float* vertices, int size) ");
// Computes the center of mass of a set of points and returns the center point
if (size != 0) {
float* meanVec = NULL;
ML_CHECK_NEW(meanVec, float[3]);
meanVec[0] = 0;
meanVec[1] = 0;
meanVec[2] = 0;
for (int counter = 0; counter < size; counter++) {
meanVec[0] += *vertices++;
meanVec[1] += *vertices++;
meanVec[2] += *vertices++;
}
// Division by the number of points
meanVec[0] /= size;
meanVec[1] /= size;
meanVec[2] /= size;
return meanVec;
}
else{
return 0;
}
}
float* MainAxisPCA::getLargestMainAxis()
{
ML_TRACE_IN("float* MainAxisPCA::getLargestMainAxis()");
float* lA = NULL;
ML_CHECK_NEW(lA, float[3]);
if (_xDiameter > _yDiameter && _xDiameter > _zDiameter) {
lA[0] = _xAxis[0];
lA[1] = _xAxis[1];
lA[2] = _xAxis[2];
return lA;
}
if (_yDiameter > _xDiameter && _yDiameter > _zDiameter) {
lA[0] = _yAxis[0];
lA[1] = _yAxis[1];
lA[2] = _yAxis[2];
return lA;
}
lA[0] = _zAxis[0];
lA[1] = _zAxis[1];
lA[2] = _zAxis[2];
return lA;
}
float* MainAxisPCA::stretchVector(const float* vector, const float length)
{
ML_TRACE_IN("float* MainAxisPCA::stretchVector(const float* vector, const float length)");
float* strVec = NULL;
ML_CHECK_NEW(strVec, float[3]);
// Sum of squares of the direction vector
float sumVec = vector[0] * vector[0] + vector[1] * vector[1] + vector[2] * vector[2];
// return if this sum equals 0
if (sumVec == 0) {
strVec[0] = strVec[1] = strVec[2] = 0;
return strVec;
}
// |aVector| = sqrt(aVector[0]^2 + aVector[1]^2 + aVector[2]^2):
float factor = sqrtf((length * length) / sumVec);
strVec[0] = vector[0] * factor;
strVec[1] = vector[1] * factor;
strVec[2] = vector[2] * factor;
return strVec;
}
void MainAxisPCA::getBoundingBox(const float* pointSet, const long size,
float& minX, float& maxX,
float& minY, float& maxY,
float& minZ, float& maxZ)
{
ML_TRACE_IN("void MainAxisPCA::getBoundingBox(...)");
// Return the bounding box of a point set
if (pointSet != NULL && size > 0) {
const float* pointer = pointSet;
minX = maxX = *(pointer++);
minY = maxY = *(pointer++);
minZ = maxZ = *(pointer++);
for (long counter = 1; counter < size; counter++) {
if (minX > *pointer) minX = *pointer;
if (maxX < *pointer) maxX = *pointer;
pointer++;
if (minY > *pointer) minY = *pointer;
if (maxY < *pointer) maxY = *pointer;
pointer++;
if (minZ > *pointer) minZ = *pointer;
if (maxZ < *pointer) maxZ = *pointer;
pointer++;
} // for
} // if
}
TileSphere::~TileSphere()
{
ML_TRACE_IN("TileSphere::~TileSphere()");
ML_DELETE_ARR(_tileSpheres);
ML_DELETE_ARR(_subset);
}
void TileSphere::_getSubset(float** &subset, int &size)
{
ML_TRACE_IN("void TileSphere::_getSubset(float** &subset, int &size)");
subset = _subset;
size = _numEntries;
}
void TileSphere::getStatistics(int &_treeDepth, int &_usedSpheres, int &_leafSpheres, int &_maxEnt)
{
ML_TRACE_IN("void TileSphere::getStatistics(int &_treeDepth, int &_usedSpheres, int &_leafSpheres, int &_maxEnt) ");
int treeDepth = 0, treeDepthTmp = 0;
float** dummy = NULL;
int subsetSize = 0;
unsigned int counter=0;
// Has sub spheres
if (_hasSubSpheresFlag) {
for (counter = 0; counter < _cubicPartition; counter++) {
_tileSpheres[counter]._getSubset(dummy, subsetSize);
if (subsetSize != 0 || _tileSpheres[counter]._hasSubSpheres()) {
_tileSpheres[counter].getStatistics(treeDepthTmp, _usedSpheres, _leafSpheres, _maxEnt);
if (treeDepthTmp > treeDepth) {
treeDepth = treeDepthTmp;
}
}
}
} else {
// Has set of points
if (_numEntries > _maxEnt){ _maxEnt = _numEntries; }
_leafSpheres++;
}
treeDepth++;
_usedSpheres++;
_treeDepth = treeDepth;
}
float METKSurfaceDistance3D::getImageValue(const SbVec3f* vertex) {
ML_TRACE_IN("METKSurfaceDistance3D::getImageValue(const SbVec3f* vertex)");
// if intersection contains node, retrieve according
// value, else fill in default value
float imgVal = -1;
if (_inputImageIsValid) {
// compute node's position in voxel space
vec3 pos;
pos[0] = vertex->getValue()[0];
pos[1] = vertex->getValue()[1];
pos[2] = vertex->getValue()[2];
_image->transformToVoxelCoord(pos, pos);
Vector nodeVPos;
nodeVPos.x = pos[0];
nodeVPos.y = pos[1];
nodeVPos.z = pos[2];
if (_intersectBB.contains(nodeVPos)) {
imgVal = _subImageMemory[ (int)std::floor ((nodeVPos.x - _intersectBB.v1.x)) +
(int)std::floor(((nodeVPos.y - _intersectBB.v1.y) * _yStride)) +
(int)std::floor(((nodeVPos.z - _intersectBB.v1.z) * _zStride))];
}
}
return imgVal;
}
//----------------------------------------------------------------------------------
//! Handle field changes of the field \c field.
//----------------------------------------------------------------------------------
void WEMCenterOfMass::handleNotification (Field *field)
{
ML_TRACE_IN("WEMCenterOfMass::handleNotification()");
if ( field == _useSurface ) { this->_process(); }
// call parent class and handle apply/autoApply and in/outputs
WEMInspector::handleNotification(field);
}
void MainAxisPCA::getExtension(float& xExt, float& yExt, float& zExt)
{
ML_TRACE_IN("void MainAxisPCA::getExtension(float& xExt, float& yExt, float& zExt) ");
xExt = _xDiameter;
yExt = _yDiameter;
zExt = _zDiameter;
}
float MainAxisPCA::dotProduct(const float* vec1, const float* vec2)
{
ML_TRACE_IN("float MainAxisPCA::dotProduct(const float* vec1, const float* vec2) ");
return (* vec1 ) * (* vec2 ) +
(*(vec1 + 1)) * (*(vec2 + 1)) +
(*(vec1 + 2)) * (*(vec2 + 2));
}
const void METKMsgManager::add(const ml::METKMsgSender* sender) {
ML_TRACE_IN("METKMsgManager::add(const ml::METKMsgSender* sender)");
// if there is no cache at all, create one
if (!metkMsgManager)
metkMsgManager = new METKMsgManager();
// append sender
metkMsgManager->SenderVec.push_back(sender);
}
TileSphere* TileSphere::_getPreciserSphere(TileSphere* referenceSphere, float closestDistance)
{
ML_TRACE_IN("TileSphere* TileSphere::_getPreciserSphere(TileSphere* referenceSphere, float closestDistance) ");
bool unInit = true;
bool firstRun = false;
if (closestDistance == -1){
firstRun = true;
}
TileSphere *closestTileSphere = NULL, *tmpSphere = NULL;
float tmpDistance=0;
unsigned int counter=0;
// Traverse each sub sphere.
for (counter = 0; counter < _cubicPartition; counter++) {
// Only examine further if the sphere contains more details.
if ((_tileSpheres[counter]._getRadius() != -1) &&
!_minimalDistance->getHashTable()->existPair(&_tileSpheres[counter], referenceSphere))
{
if (unInit) {
// Initialize variables once if they are yet uninitialized.
tmpDistance = _distance(&_tileSpheres[counter], referenceSphere);
if (firstRun) {
unInit = false;
closestTileSphere = &_tileSpheres[counter];
closestDistance = tmpDistance;
} else {
if ((tmpDistance * (1 + _error)) < closestDistance) {
unInit = false;
closestTileSphere = &_tileSpheres[counter];
closestDistance = tmpDistance;
}
}
} else {
tmpSphere = &_tileSpheres[counter];
tmpDistance = _distance(tmpSphere, referenceSphere);
if (firstRun) {
if (tmpDistance < closestDistance) {
closestDistance = tmpDistance;
closestTileSphere = tmpSphere;
}
} else {
if ((tmpDistance * (1 + _error)) < closestDistance) {
closestDistance = tmpDistance;
closestTileSphere = tmpSphere;
}
}
}
}
}
return closestTileSphere;
}
