// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RGBToGray::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayArrayPath( reader->readDataArrayPath( "SelectedCellArrayArrayPath", getSelectedCellArrayArrayPath() ) ); setColorWeights( reader->readFloatVec3("ColorWeights", getColorWeights() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindMaxima::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayPath( reader->readDataArrayPath( "SelectedCellArrayPath", getSelectedCellArrayPath() ) ); setMinValue( reader->readValue( "MinValue", getMinValue() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SobelEdge::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayPath( reader->readDataArrayPath( "SelectedCellArrayPath", getSelectedCellArrayPath() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); setSaveAsNewArray( reader->readValue( "SaveAsNewArray", getSaveAsNewArray() ) ); setSlice( reader->readValue( "Slice", getSlice() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GrayToRGB::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setRedArrayPath( reader->readDataArrayPath( "RedArrayPath", getRedArrayPath() ) ); setGreenArrayPath( reader->readDataArrayPath( "GreenArrayPath", getGreenArrayPath() ) ); setBlueArrayPath( reader->readDataArrayPath( "BlueArrayPath", getBlueArrayPath() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImageCalculator::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayPath1( reader->readDataArrayPath( "SelectedCellArrayPath1", getSelectedCellArrayPath1() ) ); setOperator( reader->readValue( "Operator", getOperator() ) ); setSelectedCellArrayPath2( reader->readDataArrayPath( "SelectedCellArrayPath2", getSelectedCellArrayPath2() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void Threshold::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayName( reader->readValue( "SelectedCellArrayName", getSelectedCellArrayName() ) ); setNewCellArrayName( reader->readValue( "NewCellArrayName", getNewCellArrayName() ) ); setOverwriteArray( reader->readValue( "OverwriteArray", getOverwriteArray() ) ); setSlice( reader->readValue( "Slice", getSlice() ) ); setManualParameter( reader->readValue( "ManualParameter", getManualParameter() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImageMath::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setSelectedCellArrayPath( reader->readDataArrayPath( "SelectedCellArrayPath", getSelectedCellArrayPath() ) ); setOperator( reader->readValue( "Operator", getOperator() ) ); setValue( reader->readValue( "Value", getValue() ) ); setSaveAsNewArray( reader->readValue( "SaveAsNewArray", getSaveAsNewArray() ) ); setNewCellArrayName( reader->readString( "NewCellArrayName", getNewCellArrayName() ) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int Threshold::writeFilterParameters(AbstractFilterParametersWriter* writer, int index) { writer->openFilterGroup(this, index); writer->writeValue("SelectedCellArrayName", getSelectedCellArrayName() ); writer->writeValue("NewCellArrayName", getNewCellArrayName() ); writer->writeValue("OverwriteArray", getOverwriteArray() ); writer->writeValue("Slice", getSlice() ); writer->writeValue("ManualParameter", getManualParameter() ); writer->closeFilterGroup(); return ++index; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RGBToGray::dataCheck() { setErrorCondition(0); DataArrayPath tempPath = getSelectedCellArrayArrayPath(); //check for required arrays QVector<size_t> compDims(1, 3); m_SelectedCellArrayPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, tempPath, compDims); if(NULL != m_SelectedCellArrayPtr.lock().get()) { m_SelectedCellArray = m_SelectedCellArrayPtr.lock().get(); } else // Something went wrong because that should have worked. Bail out now. { return; } #if 0 //get type QString typeName = getDataContainerArray()->getDataContainer(getSelectedCellArrayArrayPath().getDataContainerName())->getAttributeMatrix(getSelectedCellArrayArrayPath().getAttributeMatrixName())->getAttributeArray(getSelectedCellArrayArrayPath().getDataArrayName())->getTypeAsString();; int type = TemplateUtilities::getTypeFromTypeName(typeName); //create new array of same type dims[0] = 1; TEMPLATE_CREATE_NONPREREQ_ARRAY(NewCellArray, tempPath, dims, type); #endif DataContainer::Pointer dc = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getSelectedCellArrayArrayPath().getDataContainerName() ); if(getErrorCondition() < 0) { return; } AttributeMatrix::Pointer am = dc->getPrereqAttributeMatrix<AbstractFilter>(this, getSelectedCellArrayArrayPath().getAttributeMatrixName(), 80000); if(getErrorCondition() < 0) { return; } IDataArray::Pointer data = am->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getSelectedCellArrayArrayPath().getDataArrayName(), 80000); if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image = dc->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if(getErrorCondition() < 0 || NULL == image.get()) { return; } compDims[0] = 1; //configured created name / location tempPath.setDataArrayName(getNewCellArrayName()); m_NewCellArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, compDims, data); if( NULL != m_NewCellArrayPtr.lock().get() ) { m_NewCellArray = m_NewCellArrayPtr.lock()->getVoidPointer(0); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindMaxima::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("Input Array", "SelectedCellArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath(), false, "")); parameters.push_back(FilterParameter::New("Minimum Peak Intensity", "MinValue", FilterParameterWidgetType::DoubleWidget, getMinValue(), false, "")); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GrayToRGB::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("Red Channel", "RedArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getRedArrayPath(), false, "")); parameters.push_back(FilterParameter::New("Green Channel", "GreenArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getGreenArrayPath(), false, "")); parameters.push_back(FilterParameter::New("Blue Channel", "BlueArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getBlueArrayPath(), false, "")); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImageCalculator::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("First Array to Process", "SelectedCellArrayPath1", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath1(), false, "")); { ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New(); parameter->setHumanLabel("Operator"); parameter->setPropertyName("Operator"); parameter->setWidgetType(FilterParameterWidgetType::ChoiceWidget); QVector<QString> choices; choices.push_back("Add"); choices.push_back("Subtract"); choices.push_back("Multiply"); choices.push_back("Divide"); choices.push_back("AND"); choices.push_back("OR"); choices.push_back("XOR"); choices.push_back("Min"); choices.push_back("Max"); choices.push_back("Mean"); choices.push_back("Difference"); parameter->setChoices(choices); parameters.push_back(parameter); } parameters.push_back(FilterParameter::New("Second Array to Process", "SelectedCellArrayPath2", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath2(), false, "")); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImageCalculator::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; QVector<size_t> dims(1, 1); m_SelectedCellArray1Ptr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<ImageProcessing::DefaultPixelType>, AbstractFilter>(this, getSelectedCellArrayPath1(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_SelectedCellArray1Ptr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_SelectedCellArray1 = m_SelectedCellArray1Ptr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image1 = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath1().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if(getErrorCondition() < 0 || NULL == image1.get()) { return; } m_SelectedCellArray2Ptr = getDataContainerArray()->getPrereqArrayFromPath<DataArray<ImageProcessing::DefaultPixelType>, AbstractFilter>(this, getSelectedCellArrayPath2(), dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_SelectedCellArray2Ptr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_SelectedCellArray2 = m_SelectedCellArray2Ptr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image2 = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath2().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if(getErrorCondition() < 0 || NULL == image2.get()) { return; } tempPath.update(getSelectedCellArrayPath1().getDataContainerName(), getSelectedCellArrayPath1().getAttributeMatrixName(), getNewCellArrayName() ); m_NewCellArrayPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<ImageProcessing::DefaultPixelType>, AbstractFilter, ImageProcessing::DefaultPixelType>(this, tempPath, 0, dims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_NewCellArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_NewCellArray = m_NewCellArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void FindMaxima::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; //check for required arrays QVector<size_t> compDims(1, 1); m_SelectedCellArrayPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getSelectedCellArrayPath(), compDims); if(NULL != m_SelectedCellArrayPtr.lock().get()) { m_SelectedCellArray = m_SelectedCellArrayPtr.lock().get(); } if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image = getDataContainerArray()->getDataContainer(getSelectedCellArrayPath().getDataContainerName())->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if(getErrorCondition() < 0 || NULL == image.get()) { return; } //configured created name / location tempPath.update(getSelectedCellArrayPath().getDataContainerName(), getSelectedCellArrayPath().getAttributeMatrixName(), getNewCellArrayName() ); DataContainer::Pointer dataContiner = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getSelectedCellArrayPath().getDataContainerName() ); AttributeMatrix::Pointer attrMatrix = dataContiner->getPrereqAttributeMatrix<AbstractFilter>(this, getSelectedCellArrayPath().getAttributeMatrixName(), 80000); IDataArray::Pointer redArrayptr = attrMatrix->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getSelectedCellArrayPath().getDataArrayName(), 80000); //create new boolean array tempPath.update(getSelectedCellArrayPath().getDataContainerName(), getSelectedCellArrayPath().getAttributeMatrixName(), getNewCellArrayName() ); m_NewCellArrayPtr = getDataContainerArray()->createNonPrereqArrayFromPath<DataArray<bool>, AbstractFilter, bool>(this, tempPath, 0, compDims); /* Assigns the shared_ptr<> to an instance variable that is a weak_ptr<> */ if( NULL != m_NewCellArrayPtr.lock().get() ) /* Validate the Weak Pointer wraps a non-NULL pointer to a DataArray<T> object */ { m_NewCellArray = m_NewCellArrayPtr.lock()->getPointer(0); } /* Now assign the raw pointer to data from the DataArray<T> object */ }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GrayToRGB::dataCheck() { setErrorCondition(0); DataArrayPath tempPath; //check for required arrays QVector<size_t> compDims(1, 1); m_RedPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getRedArrayPath(), compDims); if(NULL != m_RedPtr.lock().get()) { m_Red = m_RedPtr.lock().get(); } m_GreenPtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getGreenArrayPath(), compDims); if(NULL != m_GreenPtr.lock().get()) { m_Green = m_GreenPtr.lock().get(); } m_BluePtr = TemplateHelpers::GetPrereqArrayFromPath<AbstractFilter>()(this, getBlueArrayPath(), compDims); if(NULL != m_BluePtr.lock().get()) { m_Blue = m_BluePtr.lock().get(); } //configured created name / location tempPath.update(getRedArrayPath().getDataContainerName(), getRedArrayPath().getAttributeMatrixName(), getNewCellArrayName() ); DataContainer::Pointer redDC = getDataContainerArray()->getPrereqDataContainer<AbstractFilter>(this, getRedArrayPath().getDataContainerName() ); if(getErrorCondition() < 0) { return; } AttributeMatrix::Pointer redAM = redDC->getPrereqAttributeMatrix<AbstractFilter>(this, getRedArrayPath().getAttributeMatrixName(), 80000); if(getErrorCondition() < 0) { return; } IDataArray::Pointer redArrayptr = redAM->getPrereqIDataArray<IDataArray, AbstractFilter>(this, getRedArrayPath().getDataArrayName(), 80000); if(getErrorCondition() < 0) { return; } ImageGeom::Pointer image = redDC->getPrereqGeometry<ImageGeom, AbstractFilter>(this); if(getErrorCondition() < 0 || NULL == image.get()) { return; } //create new array of same type compDims[0] = 3; m_NewCellArrayPtr = TemplateHelpers::CreateNonPrereqArrayFromArrayType()(this, tempPath, compDims, redArrayptr); if( NULL != m_NewCellArrayPtr.lock().get() ) { m_NewCellArray = m_NewCellArrayPtr.lock()->getVoidPointer(0); } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void SobelEdge::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("Array to Process", "SelectedCellArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath(), false, "")); QStringList linkedProps; linkedProps << "NewCellArrayName"; parameters.push_back(LinkedBooleanFilterParameter::New("Save As New Array", "SaveAsNewArray", getSaveAsNewArray(), linkedProps, false)); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); parameters.push_back(FilterParameter::New("Slice at a Time", "Slice", FilterParameterWidgetType::BooleanWidget, getSlice(), false)); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ImageMath::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("Array to Operate On", "SelectedCellArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayPath(), false, "")); { ChoiceFilterParameter::Pointer parameter = ChoiceFilterParameter::New(); parameter->setHumanLabel("Operator"); parameter->setPropertyName("Operator"); parameter->setWidgetType(FilterParameterWidgetType::ChoiceWidget); QVector<QString> choices; choices.push_back("Add"); choices.push_back("Subtract"); choices.push_back("Multiply"); choices.push_back("Divide"); choices.push_back("Min"); choices.push_back("Max"); choices.push_back("Gamma"); choices.push_back("Log"); choices.push_back("Exp"); choices.push_back("Square"); choices.push_back("Square Root"); choices.push_back("Invert"); parameter->setChoices(choices); parameters.push_back(parameter); } parameters.push_back(FilterParameter::New("Value", "Value", FilterParameterWidgetType::DoubleWidget, getValue(), false, "")); QStringList linkedProps; linkedProps << "NewCellArrayName"; parameters.push_back(LinkedBooleanFilterParameter::New("Save As New Array", "SaveAsNewArray", getSaveAsNewArray(), linkedProps, false)); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void GrayToRGB::execute() { QString ss; dataCheck(); if(getErrorCondition() < 0) { setErrorCondition(-10000); ss = QObject::tr("DataCheck did not pass during execute"); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } //get volume container DataContainer::Pointer m = getDataContainerArray()->getDataContainer(getRedArrayPath().getDataContainerName()); QString attrMatName = getRedArrayPath().getAttributeMatrixName(); //get input and output data IDataArray::Pointer redData = m_RedPtr.lock(); IDataArray::Pointer greenData = m_GreenPtr.lock(); IDataArray::Pointer blueData = m_BluePtr.lock(); IDataArray::Pointer outputData = m_NewCellArrayPtr.lock(); //execute type dependant portion using a Private Implementation that takes care of figuring out if // we can work on the correct type and actually handling the algorithm execution. We pass in "this" so // that the private implementation can get access to the current object to pass up status notifications, // progress or handle "cancel" if needed. if(GrayToRGBPrivate<int8_t>()(redData)) { GrayToRGBPrivate<int8_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<uint8_t>()(redData) ) { GrayToRGBPrivate<uint8_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<int16_t>()(redData) ) { GrayToRGBPrivate<int16_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<uint16_t>()(redData) ) { GrayToRGBPrivate<uint16_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<int32_t>()(redData) ) { GrayToRGBPrivate<int32_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<uint32_t>()(redData) ) { GrayToRGBPrivate<uint32_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<int64_t>()(redData) ) { GrayToRGBPrivate<int64_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<uint64_t>()(redData) ) { GrayToRGBPrivate<uint64_t>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<float>()(redData) ) { GrayToRGBPrivate<float>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else if(GrayToRGBPrivate<double>()(redData) ) { GrayToRGBPrivate<double>::Execute(this, redData, greenData, blueData, outputData, m, attrMatName); } else { setErrorCondition(-10001); ss = QObject::tr("A Supported DataArray type was not used for an input array."); notifyErrorMessage(getHumanLabel(), ss, getErrorCondition()); return; } //array name changing/cleanup AttributeMatrix::Pointer attrMat = m->getAttributeMatrix(m_RedArrayPath.getAttributeMatrixName()); attrMat->addAttributeArray(getNewCellArrayName(), outputData); /* Let the GUI know we are done with this filter */ notifyStatusMessage(getHumanLabel(), "Complete"); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RGBToGray::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FilterParameter::New("Array to Process", "SelectedCellArrayArrayPath", FilterParameterWidgetType::DataArraySelectionWidget, getSelectedCellArrayArrayPath(), false, "")); parameters.push_back(FilterParameter::New("Color Weighting", "ColorWeights", FilterParameterWidgetType::FloatVec3Widget, getColorWeights(), false)); parameters.push_back(FilterParameter::New("Created Array Name", "NewCellArrayName", FilterParameterWidgetType::StringWidget, getNewCellArrayName(), false, "")); setFilterParameters(parameters); }