/home/oan/prosjekt/gotools/segmentation/gpl_distro/lsseg_1.0_gpl/include/simple_tools.h

Go to the documentation of this file.

//===========================================================================
// The Level-Set Segmentation Library (LSSEG)
//
//
// Copyright (C) 2000-2005 SINTEF ICT, Applied Mathematics, Norway.
//
// This program is free software; you can redistribute it and/or          
// modify it under the terms of the GNU General Public License            
// as published by the Free Software Foundation version 2 of the License. 
//
// This program is distributed in the hope that it will be useful,        
// but WITHOUT ANY WARRANTY; without even the implied warranty of         
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          
// GNU General Public License for more details.                           
//
// You should have received a copy of the GNU General Public License      
// along with this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: e-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
// 
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//
//===========================================================================
//===========================================================================
//                                                                           
// File: simple_tools.h                                                      
//                                                                           
// Created: Tue Oct 25 13:56:00 2005                                         
//                                                                           
// Author: Odd A. Andersen <Odd.Andersen@sintef.no>
//                                                                           
// Revision: $Id: simple_tools.h,v 1.25 2006/11/16 23:40:17 oan Exp $
//                                                                           
// Description:
//                                                                           
//===========================================================================

// recent changes:
// 2006/03/30:  added function read_image_sequence_multichn() (kgre)

#ifndef _SIMPLE_TOOLS_H
#define _SIMPLE_TOOLS_H

#include "Image.h"
#include "LevelSetFunction.h"
#include "Mask.h"
#include "ParzenDistributionForce.h"

namespace lsseg {

enum SEG_REGION {SEG_NEGATIVE = 0, SEG_POSITIVE};

//===========================================================================
// image transform functions
//===========================================================================

void negate(Image<double>& img, double min = 0, double max = 255);

void rescale(Image<double>& img, double cur_min, double cur_max, double to_min = 0, double to_max = 255);

void rescale_channels(Image<double>& img, double to_min = 0, double to_max = 255);

void clip(Image<double>& img, double min, double max);

template<typename T>
void to_grayscale(Image<T>& img);

void transpose(Image<double>& img);

void transpose(const Image<double>& img, Image<double>& target);

//===========================================================================
// syntetic image generation functions - generate test images, etc.
//===========================================================================

void horizontal_sinusoidal_bands(LevelSetFunction& img, int num_bands, double phase=0);


void rectangle(LevelSetFunction& img, 
               double xmin_ratio, 
               double xmax_ratio,
               double ymin_ratio,
               double ymax_ratio,
               double zmin_ratio = 0,
               double zmax_ratio = 1);

void sphere(LevelSetFunction& img,
            double relrad,  //between 0 and 1
            double xrelpos, // between 0 and 1
            double yrelpos, // between 0 and 1
            double zrelpos = 0);
            
// // @@ document this or remove it....   Is it superfluous given the sphere() function above???
// void distance_from_point(LevelSetFunction& img,
//                       double zero_level, // which distance is considered zero (as ratio of longest
//                                          // dimension
//                       double point_x_relpos, // from 0 to 1
//                       double point_y_relpos, // from 0 to 1
//                       double point_z_relpos = 0); // from 0 to 

void set_from_parzen(LevelSetFunction& img, 
                      const ParzenDistributionForce pf,
                      const Mask* m = 0);

void init_voronoi_regions(LevelSetFunction* regs,
                          const double* center_coords, // each between 0 and 1
                          int num_regions,
                          bool three_d = false); // true if 3D

void random_scattered_voronoi(LevelSetFunction* regs,
                              int num_regs,
                              int num_fragments); // per region

void multiregion_bands(LevelSetFunction* regs,
                       int num_regs,
                       int pixel_bandwidth);

//===========================================================================
// other functions
//===========================================================================

void make_border_mask(const LevelSetFunction& phi, 
                      Mask& target, 
                      int width = 2,
                      const Mask* geom_mask = 0);

void mask_from_segmentation(const LevelSetFunction& phi, Mask& target, SEG_REGION reg);

void read_image_sequence(std::istream& image_list, 
                         Image<double>& result, 
                         bool convert_to_grayscale = false);


// void read_image_sequence_multichn(std::istream& image_list, 
//                       Image<double>& result,
//                       bool convert_to_grayscale = false);

template<typename ImgType>
void resample_into(const ImgType& src, ImgType& target, bool linear = true);

// if not linear, then piecewise constant

template<typename ImgType>
void downsample_series(const ImgType& input, 
                       std::vector<ImgType >& result,
                       int min_num_pixels,
                       bool downscale_z = false,
                       double downscale_factor = 2,
                       bool to_grayscale = false,
                       bool linear = true);

unsigned long int nonzeroes(const Image<int>& img);

double nonzero_ratio(const Image<int>& img);

unsigned long int positives(const Image<double>& img); // positive or zero

double positive_ratio(const Image<double>& img); // positive or zero ratio

unsigned long int negatives(const Image<double>& img); // negative

double negative_ratio(const Image<double>& img); // negative ratio

inline double compute_nu_Brox(unsigned int domain_size, double nu_factor) 
{
    // as proposed by Brox
    return 1.0e-3 * nu_factor * pow(domain_size, 0.7);
}


}; // end namespace lsseg

#include "simple_tools_templates.h"

#endif // _SIMPLE_TOOLS_H

---