void ScaleSpaceFilter<GROUP_T, IMAGE_T>::watershed_overlap_merge(GROUP_T* segments, GaussianBlur<IMAGE_T>* gaussian) {
GROUP_T* new_segments = allocate_array<GROUP_T>(nVoxels);
int imageongpu=1;
IMAGE_T *imageptr = gaussian->get_image_d();
if (!imageptr) {
imageptr = gaussian->get_image();
imageongpu=0;
}
Watershed<GROUP_T, IMAGE_T> watershed(height, width, depth, use_cuda);
watershed.watershed(imageptr, imageongpu, new_segments, false);
long max_group_num = sequentialize_group_nums(segments, nVoxels);
#ifdef VMDCUDA
if (use_cuda) {
printf("CUDA watershed overlap merge not implemented.\n");
//watershed_overlap_merge_cuda<GROUP_T>(segments, new_segments, group_map);
} else
#endif
{
watershed_overlap_merge_cpu(segments, new_segments);
}
nGroups = sequentialize_group_nums(segments, max_group_num);
free_array(new_segments);
}
void ScaleSpaceFilter<GROUP_T, IMAGE_T>::watershed_hill_climb_merge(GROUP_T* segments, GaussianBlur<IMAGE_T>* gaussian) {
GROUP_T* new_segments = allocate_array<GROUP_T>(nVoxels);
int imageongpu=1;
IMAGE_T *imageptr = gaussian->get_image_d();
if (!imageptr) {
imageptr = gaussian->get_image();
imageongpu=0;
}
Watershed<GROUP_T, IMAGE_T> watershed(height, width, depth, use_cuda);
watershed.watershed(imageptr, imageongpu, new_segments, false);
long n_new_groups = sequentialize_group_nums(new_segments, nVoxels);
#ifdef VMDCUDA
if (use_cuda) {
watershed_hill_climb_merge_cuda<GROUP_T>(segments, new_segments, imageptr, group_map, max_idx, height, width, depth, nGroups);
} else
#endif
{
watershed_hill_climb_merge_cpu(segments, new_segments, imageptr);
}
nGroups = sequentialize_group_nums(segments, n_new_groups);
free_array(new_segments);
}
int main(int argc, char** argv) {
if(argc != 3){
std::cout << "Usage: Test2DImage inputFilename outputFilename";
return 1;
}
typedef signed int InputPixelType;
const unsigned int Dimension = 2;
typedef itk::Image<InputPixelType, Dimension> InputImageType;
typedef itk::RGBPixel<unsigned char> RGBPixelType;
typedef itk::Image<RGBPixelType, 2> RGBImageType;
typedef itk::ImageFileReader<InputImageType> ReaderType;
typedef itk::ImageFileWriter<RGBImageType> WriterType;
typedef itk::GDCMImageIO ImageIOType;
typedef itk::GradientAnisotropicDiffusionImageFilter<InputImageType,
InputImageType> DiffusionFilterType;
typedef itk::GradientMagnitudeImageFilter<InputImageType, InputImageType>
GradientMagnitudeFilterType;
typedef itk::Functor::ScalarToRGBPixelFunctor<int> ColorMapFunctorType;
typedef itk::UnaryFunctorImageFilter<InputImageType,
RGBImageType, ColorMapFunctorType> ColorMapFilterType;
typedef itk::JPEGImageIO JImageIOType;
ReaderType::Pointer reader = ReaderType::New();
WriterType::Pointer writer = WriterType::New();
ImageIOType::Pointer GDCMImageIO = ImageIOType::New();
JImageIOType::Pointer JPEGImageIO = JImageIOType::New();
ColorMapFilterType::Pointer colormapper = ColorMapFilterType::New();
reader->SetFileName(argv[1]);
reader->SetImageIO(GDCMImageIO);
try {
reader->Update();
}
catch (itk::ExceptionObject & e) {
std::cerr << "exception in file reader " << std::endl;
std::cerr << e << std::endl;
return 1;
}
DiffusionFilterType::Pointer diffusion = DiffusionFilterType::New();
diffusion->SetNumberOfIterations(1);
diffusion->SetConductanceParameter(4);
diffusion->SetTimeStep(0.125);
GradientMagnitudeFilterType::Pointer gradient = GradientMagnitudeFilterType::New();
diffusion->SetInput(reader->GetOutput());
gradient->SetInput(diffusion->GetOutput());
gradient->Update();
MyWatershedSegmenter<InputImageType> watershed(gradient->GetOutput());
watershed.buildLowerCompleteImage();
watershed.buildLabeledImage();
colormapper->SetInput(watershed.returnFinalImage());
writer->SetInput(colormapper->GetOutput());
writer->UseInputMetaDataDictionaryOff();
writer->SetImageIO(JPEGImageIO);
writer->SetFileName(argv[2]);
writer->Update();
}
SegmentList WaterShedDecomposer::decompose(ImageColor const & image) const {
QTime time;
time.start();
// original image
image.save("WS1_original.png");
// filter image
time.restart();
ImageColor filtered = filterGauss(image, radiusGauss->value());
qDebug("Image filtered in %g seconds", time.restart()/1000.0);
filtered.save("WS2_filtered.png");
// calculate gradient magnitude map
time.restart();
ImageGray gradientMap = gradientMagnitude(filtered);
qDebug("Gradient magnitude map calculated in %g seconds", time.restart()/1000.0);
gradientMap.save("WS3_gradient.png");
// apply watershed transformation
time.restart();
SegmentList segments = watershed(gradientMap, image);
qDebug("Watershed transformation applied in %g seconds", time.restart()/1000.0);
qDebug(" Segments: %d", segments.size());
ImageColor debugOut(image.width(), image.height());
segments.copyToImageAVG(debugOut);
debugOut.save("WS4_transformed.png");
// merge similiar and small segments
time.restart();
int oldSegmentsSize;
do {
oldSegmentsSize = segments.size();
mergeSimiliarSegments(segments, epsilonMerge->value()*epsilonMerge->value());
mergeSmallSegments(segments, minSize->value());
} while (segments.size() != oldSegmentsSize);
qDebug("Segments merged in %g seconds", time.restart()/1000.0);
qDebug(" Segments: %d", segments.size());
segments.copyToImageAVG(debugOut);
debugOut.save("WS5_merged.png");
return segments;
}
Mat process(const Mat &image) {
watershed(image,markers);
// 워터쉐드 적용
return markers;
}
