int itkFiltersMedianProcess::updateProcess(medAbstractData* inputData)
{
typename ImageType::Pointer inputImage = static_cast<ImageType*>(inputData->data());
typedef itk::MedianImageFilter< ImageType, ImageType > MedianFilterType;
typename MedianFilterType::Pointer medianFilter = MedianFilterType::New();
typename MedianFilterType::InputSizeType radius;
radius.Fill(d->medianSize);
medianFilter->SetRadius(radius);
medianFilter->SetInput(inputImage);
itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New();
callback->SetClientData ( ( void * ) this );
callback->SetCallback ( itkFiltersProcessBase::eventCallback );
medianFilter->AddObserver ( itk::ProgressEvent(), callback );
medianFilter->Update();
getOutputData()->setData ( medianFilter->GetOutput() );
//Set output description metadata
QString newSeriesDescription = "median filter " + QString::number(d->medianSize);
medUtilities::setDerivedMetaData(getOutputData(), inputData, newSeriesDescription);
return DTK_SUCCEED;
}
int itkFiltersComponentSizeThresholdProcess::updateProcess(medAbstractData* inputData)
{
dtkSmartPointer<medAbstractData> adjustedInputData = inputData;
if (std::is_floating_point<typename InputImageType::PixelType>::value)
{
adjustedInputData = castToOutputType<InputImageType>(inputData);;
}
typename InputImageType::Pointer inputImage = static_cast<InputImageType*>(inputData->data());
typedef itk::ConnectedComponentImageFilter <InputImageType, OutputImageType> ConnectedComponentFilterType;
typename ConnectedComponentFilterType::Pointer connectedComponentFilter = ConnectedComponentFilterType::New();
connectedComponentFilter->SetInput(inputImage);
connectedComponentFilter->Update();
// RELABEL COMPONENTS according to their sizes (0:largest(background))
typedef itk::RelabelComponentImageFilter<OutputImageType, OutputImageType> FilterType;
typename FilterType::Pointer relabelFilter = FilterType::New();
relabelFilter->SetInput(connectedComponentFilter->GetOutput());
relabelFilter->SetMinimumObjectSize(d->minimumSize);
relabelFilter->Update();
// BINARY FILTER
typedef itk::BinaryThresholdImageFilter <OutputImageType, OutputImageType> BinaryThresholdImageFilterType;
typename BinaryThresholdImageFilterType::Pointer thresholdFilter
= BinaryThresholdImageFilterType::New();
thresholdFilter->SetInput(relabelFilter->GetOutput());
thresholdFilter->SetUpperThreshold(0);
thresholdFilter->SetInsideValue(0);
thresholdFilter->SetOutsideValue(1);
thresholdFilter->Update();
itk::CStyleCommand::Pointer callback = itk::CStyleCommand::New();
callback->SetClientData ( ( void * ) this );
callback->SetCallback ( itkFiltersProcessBase::eventCallback );
connectedComponentFilter->AddObserver ( itk::ProgressEvent(), callback );
setOutputData(medAbstractDataFactory::instance()->createSmartPointer(medUtilitiesITK::itkDataImageId<OutputImageType>()));
getOutputData()->setData ( thresholdFilter->GetOutput() );
QString newSeriesDescription = "connectedComponent " + QString::number(d->minimumSize);
medUtilities::setDerivedMetaData(getOutputData(), inputData, newSeriesDescription);
return DTK_SUCCEED;
}
void
SoUnknownEngine::copyContents(const SoFieldContainer *fromFC,
SbBool copyConnections)
//
////////////////////////////////////////////////////////////////////////
{
// Make sure the copy has the correct class name
const SoUnknownEngine *fromUnk = (const SoUnknownEngine *) fromFC;
setClassName(fromUnk->className);
// For each input in the original engine, create a new input and add
// it to the new engine
// NOTE: We can't use SoEngine::copyContents() to copy the field
// data, since that uses SoFieldData::overlay(), which assumes the
// fields have the same offsets in both engines. Instead, we just
// copy the field values ourselves.
const SoFieldData *fromData = fromUnk->getFieldData();
SoFieldData *toData = (SoFieldData *) getFieldData();
int i;
for (i = 0; i < fromData->getNumFields(); i++) {
SoField *fromField = fromData->getField(fromUnk, i);
const SbName fieldName = fromData->getFieldName(i);
SoType fieldType = fromField->getTypeId();
SoField *toField = (SoField *) (fieldType.createInstance());
toField->enableNotify(FALSE);
toField->setContainer(this);
toField->setDefault(TRUE);
toField->enableNotify(TRUE);
toData->addField(this, fieldName.getString(), toField);
toField->setContainer(this);
toField->copyFrom(*fromField);
toField->setIgnored(fromField->isIgnored());
toField->setDefault(fromField->isDefault());
toField->fixCopy(copyConnections);
if (fromField->isConnected() && copyConnections)
toField->copyConnection(fromField);
}
// Copy the outputs
SoEngineOutputData *toOutData = (SoEngineOutputData *) getOutputData();
SoEngineOutputList outList;
fromUnk->getOutputs(outList);
for(i = 0; i < outList.getLength(); i++) {
SoEngineOutput *newOut = new SoEngineOutput;
const SoType outType = outList[i]->getConnectionType();
SbName outName;
getOutputName( outList[i], outName );
toOutData->addOutput(this, outName.getString(), newOut, outType);
newOut->setContainer(this);
}
}
bool DeviceFilter::requestOutput(const std::string& device, DataGroup* outputData)
{
bool state = pullOutput();
if (state)
{
filterOutput(device, getOutputData(), outputData);
}
return state;
}
vector < Result::ResultData > Result::getOutputConformations(Ligand* lig)
{
vector<ResultData> ret;
for (Position i = 0; i < lig->getNumberOfConformations(); i++)
{
Conformation* conf = lig->getConformation(i);
String confid = conf->getId();
if (hasOutputData(confid))
{
Result::ResultData rd = getOutputData(confid);
rd.setConformation(conf);
ret.push_back(rd);
}
}
return ret;
}
int main ( int argc, char **argv )
/*----------------------------------------------------------------------- */
/* Obit task to copy tables arrached to ObitData objects */
/*----------------------------------------------------------------------- */
{
oint ierr = 0;
ObitSystem *mySystem= NULL;
ObitData *inData = NULL, *outData = NULL;
ObitErr *err= NULL;
/* Startup - parse command line */
err = newObitErr();
myInput = TabCopyIn (argc, argv, err);
if (err->error) {ierr = 1; ObitErrLog(err); goto exit;}
/* Initialize logging */
ObitErrInit (err, (gpointer)myInput);
ObitErrLog(err); /* show any error messages on err */
if (ierr!=0) return 1;
/* Initialize Obit */
mySystem = ObitSystemStartup (pgmName, pgmNumber, AIPSuser, nAIPS, AIPSdirs,
nFITS, FITSdirs, (oint)TRUE, (oint)FALSE, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* Digest input */
digestInputs(myInput, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* Get input data */
inData = getInputData (myInput, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* Get output data */
outData = getOutputData (myInput, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* Copy selected tables */
TabCopyCopy (myInput, inData, outData, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* Write history */
TabCopyHistory (myInput, inData, outData, err);
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* show any messages and errors */
if (err->error) ierr = 1; ObitErrLog(err); if (ierr!=0) goto exit;
/* cleanup */
myInput = ObitInfoListUnref(myInput);
inData = ObitUnref(inData);
outData = ObitUnref(outData);
/* Shutdown Obit */
exit:
ObitReturnDumpRetCode (ierr, outfile, myOutput, err); /* Final output */
myOutput = ObitInfoListUnref(myOutput);
mySystem = ObitSystemShutdown (mySystem);
return ierr;
} /* end of main */
// expose the pullOutput method to the world
bool TestDevice::pullOutput()
{
bool result = CommonDevice::pullOutput();
getOutputData().strings().get("data", &lastPulledData);
return result;
}
