// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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);
}
