ImageType::Pointer SBFilterUtils::RegionGrowing(ImageType::Pointer image, ImageType::IndexType seed, bool fullConnectivity, int lowerThreshold, int upperThreshold, int replaceValue) {
	
	ConnectedFilterType::Pointer connectedThreshold = ConnectedFilterType::New();
	connectedThreshold->SetInput(image);
	connectedThreshold->SetSeed(seed);
	connectedThreshold->SetLower(lowerThreshold);
	connectedThreshold->SetUpper(upperThreshold);
	connectedThreshold->SetReplaceValue(replaceValue);
	if(fullConnectivity)
		connectedThreshold->SetConnectivity(ConnectedFilterType::FullConnectivity);
	connectedThreshold->Update();

	return connectedThreshold->GetOutput();
}
InputImageType::Pointer getLargeComponents(InputImageType::Pointer im, int n)
{
	printf("Removing small connected components ...");
	typedef itk::Image<short int,3> LabelImageType;
	typedef itk::ConnectedComponentImageFilter<InputImageType,LabelImageType> ConnectedFilterType;
	typedef itk::RelabelComponentImageFilter<LabelImageType,LabelImageType> RelabelFilterType;

	ConnectedFilterType::Pointer cfilter = ConnectedFilterType::New();
	cfilter->SetInput(im);
	cfilter->Update();

	RelabelFilterType::Pointer rfilter = RelabelFilterType::New();
	rfilter->SetInput(cfilter->GetOutput());
	rfilter->InPlaceOn();

	rfilter->Update();
	std::vector<long unsigned int> sizes = rfilter->GetSizeOfObjectsInPixels();
	int threshsize = -1;
	for(unsigned int counter=0; counter<sizes.size(); counter++)
	{
		if(sizes[counter] < (unsigned int)n)
		{
			threshsize = counter;
			break;
		}
	}

	typedef itk::BinaryThresholdImageFilter<LabelImageType,InputImageType> BinFilterType;
	BinFilterType::Pointer bfilter = BinFilterType::New();

	bfilter->SetInput(rfilter->GetOutput());
	bfilter->SetInsideValue(255);
	bfilter->SetOutsideValue(0);
	bfilter->SetLowerThreshold(1);
	if(threshsize>1)
		bfilter->SetUpperThreshold(threshsize-1);
	else
		bfilter->SetUpperThreshold(1);
	bfilter->Update();
	printf(" Done.\n");

	return bfilter->GetOutput();

}
vtkImageData* ROISegmentation::startRegionGrow(){
	typedef itk::CastImageFilter< ImageType, ImageType >
		CastingFilterType;
	CastingFilterType::Pointer caster = CastingFilterType::New();
	typedef itk::CurvatureFlowImageFilter< ImageType, ImageType >
		CurvatureFlowImageFilterType;
	CurvatureFlowImageFilterType::Pointer smoothing =
		CurvatureFlowImageFilterType::New();
	typedef itk::ConfidenceConnectedImageFilter<ImageType, ImageType>
		ConnectedFilterType;
	ConnectedFilterType::Pointer confidenceConnected = ConnectedFilterType::New();
	smoothing->SetInput(pDCM->getITKRawImage());
	confidenceConnected->SetInput(smoothing->GetOutput());
	caster->SetInput(confidenceConnected->GetOutput());

	//Parameter Settings
	smoothing->SetNumberOfIterations(2);
	smoothing->SetTimeStep(0.05);
	confidenceConnected->SetMultiplier(2.5);
	confidenceConnected->SetNumberOfIterations(2);
	confidenceConnected->SetInitialNeighborhoodRadius(1);
	confidenceConnected->SetReplaceValue(255);
	if (!_index.empty()){
		ImageType::PointType seedPoint;
		ImageType::IndexType seedIndex;
		std::vector<CursorDim>::iterator iter = _index.begin();
		for (iter; iter != _index.end(); ++iter){
			seedPoint[0] = iter->_x;
			seedPoint[1] = iter->_y;
			seedPoint[2] = iter->_z;
			if (pDCM->getITKRawImage()->TransformPhysicalPointToIndex(seedPoint, seedIndex)){
				qDebug()<<"SeedIndex:    " << seedIndex[0] << "  " << seedIndex[1] << "  " << seedIndex[2] << endl;
				confidenceConnected->AddSeed(seedIndex);
			}
		}
		caster->Update();

		typedef itk::ImageToVTKImageFilter<ImageType>       ConnectorType;
		ConnectorType::Pointer connector = ConnectorType::New();
		connector->SetInput(caster->GetOutput());
		connector->Update();
		vtkImageData * rawImage = vtkImageData::New();
		rawImage->DeepCopy(connector->GetOutput());
		return rawImage;
	}
	else{
		return NULL;
	}
}
int exampleProcessImageFilter::update()
{
    typedef unsigned short PixelType;
    const unsigned int Dimension = 3;
    typedef itk::Image< PixelType, Dimension > ImageType;

    qDebug() << d->inputA->identifier();

    if (d->option == optionA)
    {

        if (d->inputA->identifier()=="itkDataImageUShort3" && d->inputB->identifier()=="itkDataImageUShort3")
        {
            typedef itk::MaskImageFilter< ImageType,ImageType,ImageType >    MaskFilterType;
            MaskFilterType::Pointer maskFilter = MaskFilterType::New();

            //convert from dtkImages to ItkImages and set as intputs for the itk::MaskImageFilter
            maskFilter->SetInput1(dynamic_cast<ImageType*>((itk::Object*)(d->inputA->output())));
            maskFilter->SetInput2(dynamic_cast<ImageType*>((itk::Object*)(d->inputB->output())));

            //Create an image where the output of the filter is going to be displayed
            d->output =dynamic_cast<medAbstractDataImage *>(dtkAbstractDataFactory::instance()->create ("itkDataImageUShort3"));

            maskFilter->Update();

            //Set the data for the output
            d->output->setData(maskFilter->GetOutput());

        }
        else if(d->inputA->identifier()=="itkDataImageDouble4" && d->inputB->identifier()=="itkDataImageDouble4")
        {
            typedef double PixelType4;
            const unsigned int Dimension4 = 4;
            typedef itk::Image< PixelType4, Dimension4 > ImageType4;

            typedef itk::MaskImageFilter< ImageType4,ImageType4,ImageType4 >    MaskFilterType4;
            MaskFilterType4::Pointer maskFilter4 = MaskFilterType4::New();

            //convert from dtkImages to ItkImages and set as intputs for the itk::MaskImageFilter
            maskFilter4->SetInput1(dynamic_cast<ImageType4*>((itk::Object*)(d->inputA->output())));
            maskFilter4->SetInput2(dynamic_cast<ImageType4*>((itk::Object*)(d->inputB->output())));

            maskFilter4->Update();

            //Create an image where the output of the filter is going to be displayed
            d->output =dynamic_cast<medAbstractDataImage *> (dtkAbstractDataFactory::instance()->create ("itkDataImageDouble4"));

            //Set the data for the output
            d->output->setData(maskFilter4->GetOutput());

            typedef itk::ImageFileWriter< ImageType4 > WriterType;
            WriterType::Pointer writer = WriterType::New();
            writer->SetFileName("/user/jgarciag/home/AnalyzeStuff/headerModify/ResulHalfMask4D.mha");
            writer->SetInput(/*dynamic_cast<ImageType4*>((itk::Object*)(d->output->output()))*/maskFilter4->GetOutput());
            writer->Update();
        }
        else
            qDebug("Not the right itkDataImageUShort3 type of images");
    }

    else if (d->option == optionB)
    {

        if (d->inputA->identifier()=="itkDataImageUShort3" && d->inputB->identifier()=="itkDataImageUShort3")
        {
            typedef itk::AddImageFilter< ImageType,ImageType,ImageType >    AddFilterType;
            AddFilterType::Pointer AddFilter = AddFilterType::New();

            AddFilter->SetInput1(dynamic_cast<ImageType*>((itk::Object*)(d->inputA->output())));
            AddFilter->SetInput2(dynamic_cast<ImageType*>((itk::Object*)(d->inputB->output())));

            d->output =dynamic_cast<medAbstractDataImage *> (dtkAbstractDataFactory::instance()->create ("itkDataImageUShort3"));
            AddFilter->Update();
            d->output->setData(AddFilter->GetOutput());


        }
        else
            qDebug("Not the right itkDataImageUShort3 type of images");
    }

    else if (d->option == optionC)
    {
        if (d->inputA->identifier()=="itkDataImageUShort3" && d->inputB->identifier()=="itkDataImageUShort3")
        {
            typedef itk::ConnectedThresholdImageFilter< ImageType, ImageType > ConnectedFilterType;
            ConnectedFilterType::Pointer connectedThreshold = ConnectedFilterType::New();
            connectedThreshold->SetInput( dynamic_cast<ImageType*>((itk::Object*)(d->inputA->output())) );
            connectedThreshold->SetLower((d->lowerThreshold));
            connectedThreshold->SetUpper((d->lowerThreshold)+150);

            ImageType::IndexType  index;

            index[0] = d->x;
            index[1] = d->y;
            index[2] = d->z;

            connectedThreshold->SetSeed( index );

            connectedThreshold->Update();

            d->output =dynamic_cast<medAbstractDataImage *> (dtkAbstractDataFactory::instance()->create ("itkDataImageUShort3"));

            d->output->setData(connectedThreshold->GetOutput());
        }
        else
            qDebug("Not the right itkDataImageUShort3 type of image");
    }
//    emit progressed (100);
    qDebug("Adios");
    return 0;
}