Laboratoire RDP » Biophysics Team » lsm3d

CeCILL FREE SOFTWARE LICENSE AGREEMENT

Notice

This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:

    firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users,

    secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.

The authors of the CeCILL1 license are:

Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.

Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.

Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.

Preamble

The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model.

The exercising of these rights is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions.

In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.

In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.

This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.

Article 1 - DEFINITIONS

For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:

Agreement: means this license agreement, and its possible subsequent versions and annexes.

Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement.

Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement.

Modified Software: means the Software modified by at least one Contribution.

Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.

Object Code: means the binary files originating from the compilation of the Source Code.

Holder: means the holder(s) of the economic rights over the Initial Software.

Licensee: means the Software user(s) having accepted the Agreement.

Contributor: means a Licensee having made at least one Contribution.

Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.

Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules.

Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software.

External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run.

Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space.

GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc.

Parties: mean both the Licensee and the Licensor.

These expressions may be used both in singular and plural form.

Article 2 - PURPOSE

The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software.

Article 3 - ACCEPTANCE

3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:

    (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;

    (ii) the first time the Licensee exercises any of the rights granted hereunder.

3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it.

Article 4 - EFFECTIVE DATE AND TERM

4.1 EFFECTIVE DATE

The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.

4.2 TERM

The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.

Article 5 - SCOPE OF RIGHTS GRANTED

The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.

Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.

5.1 RIGHT OF USE

The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:

    permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.

    loading, displaying, running, or storing the Software on any or all medium.

    entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.

5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS

The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software.

The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof.

5.3 RIGHT OF DISTRIBUTION

In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.

The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.

5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION

The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:

    a copy of the Agreement,

    a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,

and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.

5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE

When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.

The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:

    a copy of the Agreement,

    a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,

and that, in the event that only the object code of the Modified Software is redistributed, the Licensee allows future Licensees unhindered access to the full source code of the Modified Software by indicating how to access it, it being understood that the additional cost of acquiring the source code shall not exceed the cost of transferring the data.

5.3.3 DISTRIBUTION OF EXTERNAL MODULES

When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement.

5.3.4 COMPATIBILITY WITH THE GNU GPL

The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL.

The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, and distribute that entire code under the terms of the same version of the GNU GPL.

Article 6 - INTELLECTUAL PROPERTY

6.1 OVER THE INITIAL SOFTWARE

The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.

The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2.

6.2 OVER THE CONTRIBUTIONS

The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.

6.3 OVER THE EXTERNAL MODULES

The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution.

6.4 JOINT PROVISIONS

The Licensee expressly undertakes:

    not to remove, or modify, in any manner, the intellectual property notices attached to the Software;

    to reproduce said notices, in an identical manner, in the copies of the Software modified or not.

The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.

Article 7 - RELATED SERVICES

7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.

However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.

7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.

Article 8 - LIABILITY

8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.

8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.

Article 9 - WARRANTY

9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.

The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.

9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5).

9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.

Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.

9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.

Article 10 - TERMINATION

10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.

10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.

Article 11 - MISCELLANEOUS

11.1 EXCUSABLE EVENTS

Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.

11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.

11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.

11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.

11.5 LANGUAGE

The Agreement is drafted in both French and English and both versions are deemed authentic.

Article 12 - NEW VERSIONS OF THE AGREEMENT

12.1 Any person is authorized to duplicate and distribute copies of this Agreement.

12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.

12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4.

Article 13 - GOVERNING LAW AND JURISDICTION

13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.

13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.

1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)

Version 2.0 dated 2006-09-05.

#! /bin/bash

# 1. Choose an appropriate C++ compiler, that supports OpenMP.

# ============================================================

# For Linux (Default choice):

# --------------------------

CCPP='g++'

# For MacOS X you may want to change it:

# ---------------------------

#CCPP='g++-mp-6'

#CCPP='clang++'  

#CCPP='gcc-4.6'

#For Windows:

# -----------------

# 2. Compiling options, including link to X11 library

# ====================================================

compiling_options='-O2 -lm -lpthread -lX11 -I/usr/X11R6/include -L/usr/X11R6/lib -L/opt/X11/lib -I/opt/X11/include'

# 3. Path to binaries

# ====================

bin_directory='../bin'

# 4. Compile

# ==========

cd src

echo '------------------------------------'

echo 'compiling lsm_contour...'

$CCPP -o $bin_directory/lsm_contour lsm_contour.cpp $compiling_options

echo 'compiling lsm_cells...'

$CCPP -o $bin_directory/lsm_cells lsm_cells.cpp $compiling_options -fopenmp 

echo 'Done!'

cd ..

----------------------------------------------------------------------

			        - lsm3d -

    Tools for segmenting 3D images of plant tissues 

     at multiple scales using the level set method¶

----------------------------------------------------------------------

Copyright 2016 ENS de Lyon, see accompanying file LICENSE.txt

Authors :

Typhaine Moreau, Annamaria Kiss <annamaria.kiss@ens-lyon.fr.fr>

(Laboratoire Reproduction et Développement des Plantes, Univ Lyon, ENS de Lyon, UCB Lyon 1, CNRS, INRA, F-69342, Lyon, France)

----------------------------------------------------------------------

The "lsm3d" tools

-----------------

- lsm_contour --> detects the outer surface of the tissue

- lsm_cells --> used to cellular segmentation or nuclei detection

Dependencies

-------------

The levelset tools make use of the CImg image processing C++ library, which in turn needs Xlib library.

Furthermore, the lsm_cells tool is parallelized using OpenMP.

In particular, if you do not have Xlib on your computer, you may add it:

- on Ubuntu:

    sudo apt-get install libx11-dev

- on MacOS X:

    install xQuartz from www.xquartz.org

Download

--------

In a terminal go to the directory where you wish to download and install the tool

cd Path_to_your_directory

svn checkout http://forge.cbp.ens-lyon.fr/svn/lsm3d

Compile

--------

cd lsm3D

./lsm3D_compile.sh

Troubleshooting if problems with compilation :

In lsm3D_compile.sh

- you might have to choose an appropriate compiler, which supports OpenMP.

- you might need to precise the location of the X11 library in the compilation options.

The following binaries will be generated in the bin directory :

--------------------------------------------------------------

- lsm_contour --> detects the outer surface of the tissue

- lsm_cells --> used to cellular segmentation or nuclei detection

**** lsm_contour --> detects the outer surface of the tissue

-------------------------------------------------------

Usage : lsm_contour img t_up t_down a b smooth perUp perDown

Examples for parameter values:

------------------------------

img : grayscale image of cells, (.inr or .inr.gz)

Upper threshold : t_up = 20

Down threshold : t_down = 5

Area term : a = 0 (0.5, 1)

Curvature term : b = 0 (1)

Gaussian filter : smooth = 1 (0, if image already filtered)

Stop criteria : the contour evolution is in [perDown,perUp] for 10 consecutive iterations

     perUp = 0.002, perDown = -0.002

Test :

------

lsm_detect_contour sample-stack.inr.gz 20 10 0 0 1 0.002 -0.002

**** lsm_cells --> for cellular segmentation or nuclei detection

-------------------------------------------------------------

Usage : lsm_cells img img_wat img_contour erosion [a b smooth lsm_type]

----------------- 

img : grayscale image of cells, (.inr or .inr.gz)

img_wat : image of seeds, (.inr or .inr.gz)

img_contour : mask, where cells do not evolve, (.inr or .inr.gz)

              if 'None', then cells can evolve on the whole image

erosion : amount of erosion of seeds for initialisation (uint8) --> -2, 0, 2

              if 0, then no erosion or dilation

              if negative, then a dilation is performed

a : area term (float) --> 0 or 0.5 or 1 (the default is 0.5)

              if negative, the object retracts

              if positive, the object inflates

b : curvature term (float) --> 0 or 1 (the default is 0)

gamma : scale parameter (float>0) --> 0.5 or 1 (the default is 1)

smooth : gaussian blur to apply to the image (int) --> 0 or 1 (the default is 0)

lsm_type : image, gradient or hessien based evolution --> 'i', 'g' or 'h' (the default is g)

Test :

------

lsm_cells sample-satck.inr.gz sample-satck-wat.inr.gz 'None' 2 0.3 0 0.2 1 'h'

or

lsm_cells sample-satck.inr.gz sample-satck-wat.inr.gz sample-satck_LSMcont20-10a0b0s1/sample-satck_LSMcont20-10a0b0s1.inr.gz 2 0.3 0 0.2 1 'h'

/*

Level-set Method to detect cell's contours

- Parallel standard version -

       Copyright 2016 ENS de Lyon

       File author(s):

           Typhaine Moreau, Annamaria Kiss <annamaria.kiss@ens-lyon.fr.fr>

       See accompanying file LICENSE.txt

To compile :

 g++ -o lsm_cells lsm_cells.cpp -O2 -L/usr/X11R6/lib -lm -lpthread -lX11 -fopenmp

 Needs CImg.h and lsm_lib.h

To execute :

 ./lsm_cells img img_wat img_contour erosion a b gamma smooth type

 image in .inr or .inr.gz, save in .inr.gz

 img : grayscale image of cells (unsigned char)

 img_wat : watershed 16bits image (unsigned short) with background label 1 and cells labels >1

 img_contour : binary image with background=1, all cells=0 (unsigned char)

 erosion : amount of erosion for each cell in watershed image (int)

 a : area term (float) --> 0 or 0.5 or 1 (the default is 0.5)

             if negative, the object retracts

             if positive, the object inflates

 b : curvature term (float) --> 0 or 1 (the default is 0)

 gamma : scale parameter (float>0) --> 0.5 or 1 (the default is 1)

 smooth : gaussian blur to apply to the image (int) --> 0 or 1 (the default is 0)

 lsm_type : image, gradient or hessien based evolution --> 'i', 'g' or 'h' (the default is g)

*/

#include <iostream>

#include <math.h>

#include <sstream>

#include <vector>

#include <fstream>

#include <omp.h>

#include "CImg.h"

#include "lsm_lib.h"

using namespace cimg_library;

using namespace std;

//Return list of cell label

//---------------------------------------------------------------------

vector<int> index(const CImg<unsigned short> & wat, int nbcells)

{

  vector<int> list;

  vector<bool> test(nbcells,false);

  cimg_forXYZ(wat,x,y,z)

    {

      int ind=wat(x,y,z);

      if((test[ind]==false)and(ind!=1)and(ind!=0))

	{

	  list.push_back(ind);

	  test[ind]=true;

	}

    }

  return list;

}

//Return crop psi image and it's min coordinates for one cell 

//--------------------------------------------------------------------

CImg<float> box_cell(const CImg<unsigned short> & wat, int marge,int erosion, int c0,int indice, int &xmin, int &ymin, int &zmin)

{

  //search box (min and max coordinates with a marge)

  xmin=wat._width;

  ymin=wat._height;

  zmin=wat._depth;

  int xmax=0;

  int ymax=0;

  int zmax=0;

  cimg_forXYZ(wat,x,y,z)

    {

      if(wat(x,y,z)==indice)

	{

	  if(x>xmax){xmax=x;}else if(x<xmin){xmin=x;}

	  if(y>ymax){ymax=y;}else if(y<ymin){ymin=y;}

	  if(z>zmax){zmax=z;}else if(z<zmin){zmin=z;}

	}

    }

  //marge and border conditions

  xmin=xmin-marge;

  if(xmin<0){xmin=0;}

  ymin=ymin-marge;

  if(ymin<0){ymin=0;}

  zmin=zmin-marge;

  if(zmin<0){zmin=0;}

  xmax=xmax+marge;

  if(xmax>=wat._width){xmax=wat._width-1;}

  ymax=ymax+marge;

  if(ymax>=wat._height){ymax=wat._height-1;}

  zmax=zmax+marge;

  if(zmax>=wat._depth){zmax=wat._depth-1;}

  //crop wat image to the size of box, make binary

  CImg<unsigned short>binary=wat.get_crop(xmin,ymin,zmin,0,xmax,ymax,zmax,0);

  cimg_forXYZ(binary,x,y,z)

    {

      if(binary(x,y,z)==indice){binary(x,y,z)=1;}

      else {binary(x,y,z)=0;}

    }

  //erode binary but not completely (vol stay >0)

  int vol=binary.sum();

  int nb_ero=0;

  while((vol>0)and(nb_ero<abs(erosion)))

  {

    CImg<unsigned char> binary_erode=binary.get_erode(3,3,3); 

	if (erosion<0) 

	{

		for(int i=0;i<3;i++)

		{

		binary=binary.get_dilate(2,2,2);

		}

		binary_erode=binary;

	}

      vol=binary_erode.sum();

      if(vol>0)

	{

	  binary=binary_erode;

	  nb_ero+=1;

	}

    }

  //initalize psi

  CImg<float>psi=binary;

  cimg_forXYZ(psi,x,y,z)

    {

      if(binary(x,y,z)==0){psi(x,y,z)=c0;}

      else {psi(x,y,z)=-c0;}

    }

  return psi;

}

//LSM segment : edge detection

//---------------------------------------------------------------------

CImg<float> lsm_segment2(CImg<float> psi,CImg<float> const & g,CImgList<float> const & gg,CImg<float> const & h, int lam, float mu,float alf, float beta, float epsilon, int dt, vector<int> min_list)

{

  int timestep_max=2000;

  int evolution_min=1;

  //int evolution_max=-1;

  int it=0;

  int it_stop=0;

  bool contour_evolve=true;

  int backsegm=0;

  CImg<float> psi_old=psi;

  cimg_forXYZ(psi,x,y,z)

    {

      if(psi(x,y,z)>=0){backsegm+=1;}

    }

  while((it<timestep_max)and(contour_evolve==true)and(backsegm>30))

    {

      psi_old=psi;

      //evolution

      psi=evolution_AK2_contour_cells(psi,g,gg,h,lam,mu,alf,beta,epsilon,dt,min_list);

      //new segmentation

      int new_backsegm=0;

      cimg_forXYZ(psi,x,y,z)

	{

	  if(psi(x,y,z)>=0){new_backsegm+=1;}

	}

      //Stop criteria

      // * if the cell would disappear, we stop

      if(new_backsegm==0)

			{psi=psi_old;

		     contour_evolve=false;}

      int bg_evolution=abs(new_backsegm-backsegm);

      // * if the evolution is less then evolution_min 3 consecutive times

      if((it>10) and (bg_evolution<=evolution_min) )

	{

	  it_stop+=1;

	  if(it_stop>3)

	    {contour_evolve=false;}

	}

      else

	{

	  it_stop=0;

	}

      it+=1;

      backsegm=new_backsegm;

    }

  return psi;

}

//Reconstruct full segmented image from cell's images

//---------------------------------------------------------------

CImg<unsigned short> reconstruct(const CImg<unsigned char> & background,const vector<CImg<float> > & psi_list, const vector< vector<int> > & min_list, int nbcells,const vector<int> & list)

{

  CImg<unsigned short> res=background;

  for(int i=0;i<nbcells;i++)

    {

      cimg_forXYZ(psi_list[i],xb,yb,zb)

	{

	  int x=xb+min_list[i][0];

	  int y=yb+min_list[i][1];

	  int z=zb+min_list[i][2];

	  if(psi_list[i](xb,yb,zb)>=0)

	    {res(x,y,z)=list[i];}

	}

    }

  return res;

}

//Reconstruct segmented image from cell's images and treat overlap

//---------------------------------------------------------------

CImg<unsigned short> reconstruct_overlap(CImg<unsigned char> const &  background,const vector<CImg<float> > & psi_list, const vector< vector<int> > & min_list, int nbcells, CImg<unsigned char> &free, const vector<int> & list)

{

  CImg<unsigned short> res=background;

  free=background;

  for(int i=0;i<nbcells;i++)

    {

      cimg_forXYZ(psi_list[i],xb,yb,zb)

	{

	  int x=xb+min_list[i][0];

	  int y=yb+min_list[i][1];

	  int z=zb+min_list[i][2];

	  if(psi_list[i](xb,yb,zb)>=0)

	    {

	      res(x,y,z)=list[i];

	      free(x,y,z)+=1;

	    }

	}

    }

  cimg_forXYZ(free,x,y,z)

    {

      if(free(x,y,z)>1)

	{

	  if(background(x,y,z)==1)

	    {

	      free(x,y,z)=1;

	      res(x,y,z)=1;

	    }

	  else

	    {

	      free(x,y,z)=0;

	      res(x,y,z)=0;

	    }

	}

    }

  return res;

}

//-----------------------------------------------------------------------------------------------

//******************************************  MAIN **********************************************

//-----------------------------------------------------------------------------------------------

int main (int argc, char* argv[])

{

  double begin=omp_get_wtime();

  if(argc<5)

    {

    cout<<"!! wrong number of arguments ("<<argc<<")"<<endl;

    cout<<"Usage : lsm_cells img img_wat img_contour erosion [a b smooth lsm_type]"<<endl;

    cout<<"----------------- "<<endl;  

	cout<<"img : grayscale image of cells, (.inr or .inr.gz)"<<endl;

	cout<<"img_wat : image of seeds, (.inr or .inr.gz)"<<endl;

	cout<<"img_contour : mask, where cells do not evolve, (.inr or .inr.gz)"<<endl;

	cout<<"              if 'None', then cells can evolve on the whole image"<<endl;

	cout<<"erosion : amount of erosion of seeds for initialisation (uint8) --> -2, 0, 2"<<endl;

	cout<<"              if 0, then no erosion or dilation"<<endl;

	cout<<"              if negative, then a dilation is performed"<<endl;

	cout<<"a : area term (float) --> 0 or 0.5 or 1 (the default is 0.5)"<<endl;

	cout<<"              if negative, the object retracts"<<endl;

	cout<<"              if positive, the object inflates"<<endl;

	cout<<"b : curvature term (float) --> 0 or 1 (the default is 0)"<<endl;

	cout<<"gamma : scale parameter (float>0) --> 0.5 or 1 (the default is 1)"<<endl;

	cout<<"smooth : gaussian blur to apply to the image (int) --> 0 or 1 (the default is 0)"<<endl;

    cout<<"lsm_type : image, gradient or hessien based evolution --> 'i', 'g' or 'h' (the default is g)"<<endl;  

      return 0;

    }

  //----------------------------------------------read images and check the names

  //Original image

  CImg<char> description;

  float tailleVoxel[3] = {0}; // resolution initialisation

  bool gzipped=false;

  string filename_img=argv[1];

  CImg<unsigned char> img_prev;

  if(filename_img.compare(filename_img.size()-4,4,".inr")==0)

    {

      img_prev.load(filename_img.c_str());

      img_prev.get_load_inr(filename_img.c_str(),tailleVoxel); // reads resolution

    }

  else if(filename_img.compare(filename_img.size()-7,7,".inr.gz")==0)

    {

	  gzipped = true;

      string oldname = filename_img;

      filename_img.erase(filename_img.size()-3);

      string zip="gunzip -c "+oldname+" > "+filename_img;

      if(system(zip.c_str())); // decompress image file

      img_prev.load(filename_img.c_str());

      img_prev.get_load_inr(filename_img.c_str(),tailleVoxel); // reads resolution

      zip="rm "+filename_img;

      if(system(zip.c_str())); //removes decompressed image  

    }

  else

    {cout<<"!! wrong file extension : "<<filename_img<<endl;

      return 0;}

  CImg<float> img=img_prev;

  img_prev.assign();

  cout<<"original image : "<<filename_img<<endl;

  cout<<"size : "<<img.size()<<endl;

  cout<<"size of original image : "<< img._width<<' '<< img._height <<' '<< img._depth<<' '<< endl;

  //Watershed

  string filename=argv[2];

  CImg<unsigned short> wat;

  if(filename.compare(filename.size()-4,4,".inr")==0)

    {

      wat.load(filename.c_str());

    }

  else if(filename.compare(filename.size()-7,7,".inr.gz")==0)

    {

      wat.load_gzip_external(filename.c_str());

      filename.erase(filename.size()-3);

    }

  else

    {cout<<"!! wrong file extension : "<<filename<<endl;

      return 0;}

  cout<<"watershed image : "<<filename<<endl;

cout<<"size : "<<wat.size()<<endl;

  cout<<"size of original image : "<< wat._width<<' '<< wat._height <<' '<< wat._depth<<' '<< endl;

  //Background

  string filename_bg=argv[3];

  CImg<unsigned char> background(img._width, img._height, img._depth,1,0);

   if(filename_bg.compare("None")==0)

    {

       cout<<"!! no background entered !!"<<endl;

    }

    else if(filename_bg.compare(filename_bg.size()-4,4,".inr")==0)

    {

      background.load(filename_bg.c_str());

    }

  else if(filename_bg.compare(filename_bg.size()-7,7,".inr.gz")==0)

    {

      background.load_gzip_external(filename_bg.c_str());

      filename_bg.erase(filename_bg.size()-3);

    }

  else

    {cout<<"!! wrong file extension : "<<filename_bg<<endl;

      return 0;}

  cout<<"background image : "<<filename_bg<<endl;

  if((wat.size()!=img.size())or(background.size()!=img.size()))

    {

      cout<<"!! images are not the same size"<<endl;

      return 0;

    }

  else cout<<"size : "<<img.size()<<endl;

  //---------------------------------------------------------------Parameters

  //model parameters

  int c0=-4;

  int erosion=atoi(argv[4]);

  int marge=10; 

  int lam=10;

  float alf=0.5;

  float beta=0;

  float gamma=1;

  float smooth=0;

  string lsm_type="g";

  string ar=argv[4];

  string insert="_cellLSM-d"+ar;

  if(argc>5)

    {

    alf=atof(argv[5]);

    ar=argv[5];

    insert=insert+"-a"+ar;

    }

  if(argc>6)

    {

    beta=atof(argv[6]);

    ar=argv[6];

    insert+="-b"+ar;

    }

  if(argc>7)

    {

    gamma=atof(argv[7]);

    ar=argv[7];

    insert+="-g"+ar;

	}

  if(argc>8)

    {

    smooth=atof(argv[8]);

    ar=argv[8];

    insert+="-s"+ar;

	}

  if(argc>9)

    {

	lsm_type=argv[9];

	ar=argv[9];

	insert+="-"+ar;

	}

  //numerical parameters

  float epsilon=0.5;

  int dt=1;   //it was 50, changed into 1 the 2015/10/16

  float mu=0.1/dt;

  int timestep_max=10000; // it was 1000, changed into 10000 the 2015/10/16

  //------------------------------------Names and directories

  //new name with arguments

  filename.insert(filename.size()-4,insert);

  //create directories and update names

  size_t test=filename.rfind("/");

  if(test!=filename.npos)

    {filename.erase(0,test+1);}

  string outputdir=filename;

  outputdir.erase(filename.size()-4);

  string mkdir="mkdir -p "+outputdir;

  if(system(mkdir.c_str())); 

  string filename_txt=outputdir+"/"+filename;

  filename_txt.erase(filename_txt.size()-4);

  filename=outputdir+"/"+filename;

  string wat_eroded_name=filename;

  wat_eroded_name.insert(filename.size()-4,"_eroded");

  string edge_detection_name=filename;

  edge_detection_name.insert(filename.size()-4,"_evoEdge");

  string edge_evolve_name=filename;

  edge_evolve_name.insert(filename.size()-4,"_final");

  //txt files 

  ofstream file;

  string txt_name=filename_txt+".txt";

  file.open(txt_name.c_str());

  file<<argv[0]<<endl;

  time_t t;

  struct tm * timeinfo;

  time(&t);

  timeinfo=localtime(&t);

  file<<asctime(timeinfo);

  file<<"image : "<<argv[1]<<endl;

  file<<"watershed : "<<argv[2]<<endl;

  file<<"background : "<<argv[3]<<endl;

  file<<"_________________________________"<<endl;

  file<<"Parameters"<<endl;

  file<<"lsm_type : "<<lsm_type<<endl;

  file<<"lambda : "<<lam<<endl;

  file<<"alpha : "<<alf<<endl;

  file<<"beta : "<<beta<<endl;

  file<<"gamma :"<<gamma<<endl;

  //file<<"alphabis : "<<alfabis<<endl;

  //file<<"betabis : "<<betabis<<endl;

  file<<"erosion : "<<erosion<<endl;

  file<<"marge : "<<marge<<endl;

  file<<"epsilon : "<<epsilon <<endl;

  file<<"mu : "<<mu <<endl;

  file<<"dt : "<<dt <<endl;

  file<<"timestep_max : "<<timestep_max <<endl;

  //-----------------------------------------Image Pre-processing

  //smooth image

  file<<"smooth : "<<smooth<<endl;

  if (smooth>0)

  {

  img.blur(smooth);

  }

  //-------------------------------------Initialization with erosion

  //compute fixed terms

  CImg<float> g;

  if(lsm_type.compare("g")==0)

    {

  g=edge_indicator1(img, gamma);

    }

  else if (lsm_type.compare("h")==0)

   {

  g=edge_indicator2s(img, gamma);

   }

  else if (lsm_type.compare("i")==0)

   {

  g=edge_indicator3(img, gamma);

   }

  else

  cout<<"Wrong lsm type given :'"<<lsm_type<<"'('g' for gradient-based, 'h' for Hessien-based) "<<endl;

  CImgList<float> gg=gradient(g);

  CImg<float> h=g;

  img.assign();

  //initialize psi for every cell

  int maxcells=wat.max()+1; //indice maximum  

  vector<int> list=index(wat,maxcells);

  int nbcells=list.size();

  cout<<"number of cells : "<<nbcells<<endl;

  file<<"number of cells : "<<nbcells<<endl;

  vector<CImg<float> > psi_list(nbcells);

  vector<vector<int> > min_list(nbcells,vector<int>(3,0));

  vector<vector<int> > max_list(nbcells,vector<int>(3,0));

#pragma omp parallel shared(wat,marge,erosion,c0,psi_list,min_list,list)

  {

  int xmin=0;

  int ymin=0;

  int zmin=0;

#pragma omp for schedule(dynamic)

  for(int i=0;i<nbcells;i++) 

    {

      int ind=list[i];

      psi_list[i]=box_cell(wat,marge,erosion,c0,ind,xmin,ymin,zmin);

      min_list[i][0]=xmin;

      min_list[i][1]=ymin;

      min_list[i][2]=zmin;

      cout <<"cell "<<ind<<" initialised."<<endl;

    }

  }

  wat.assign();

  //reconstruct image of eroded cells

  CImg<unsigned short> wat_eroded=reconstruct(background,psi_list,min_list,nbcells,list);

  cout <<"saving file "<<wat_eroded_name<<"..."<<endl;

  wat_eroded.save_inr(wat_eroded_name.c_str(),tailleVoxel);

  string zip="gzip -f "+wat_eroded_name;

  if(system(zip.c_str()));

  cout <<"Eroded watershed segmentation saved in file:"<<wat_eroded_name<<endl;

  //Segmented inital = background segmentation

  CImg<unsigned char> segmented=background;

  double end1=omp_get_wtime();

  double time1=double(end1-begin);

  cout<<"Evolving cells..... "<<endl;

  //---------------------------------------------------------Edge detection

  //evolve each cell one by one, attract to maximal gradient

#pragma omp parallel shared(psi_list,min_list,g,gg,h,lam,mu,alf,beta,epsilon,dt,list)

  {

#pragma omp for schedule(dynamic)

  for(int i=0;i<nbcells;i++) 

    {

      psi_list[i]=lsm_segment2(psi_list[i],g,gg,h,lam,mu,alf,beta,epsilon,dt,min_list[i]);

      cout <<"cell "<<list[i]<<" evolved."<<endl;

    }

  }

  //reconstruct image of edge detection, overlap=not segmented

  CImg<unsigned char>free=background;

  CImg<unsigned short> edge=reconstruct_overlap(background,psi_list,min_list,nbcells,free,list);

  edge.save_inr(edge_detection_name.c_str(),tailleVoxel);

  zip="gzip -f "+edge_detection_name;

  if(system(zip.c_str()));

// time measurements

  double end2=omp_get_wtime();

  double time2=double(end2-begin);

  double end=omp_get_wtime();

  double time=double(end-begin);

  cout<<"total time : "<<time<<"s"<<" (~"<<time/60<<" mn  ~"<<time/60/60<<" h)"<<endl;

  cout<<"-initialization with erosion : "<<time1<<"s"<<endl;

  cout<<"-edge detection : "<<time2<<"s"<<endl;

  file<<"total time : "<<time<<"s"<<" (~"<<time/60<<" mn  ~"<<time/60/60<<" h)"<<endl;

  file<<"-initialization with erosion : "<<time1<<"s"<<endl;

  file<<"-edge detection : "<<time2<<"s"<<endl;

  file.close();

  return 0;

}

/*

 #

 #  File            : CImg.h

 #                    ( C++ header file )

 #

 #  Description     : The C++ Template Image Processing Toolkit.

 #                    This file is the main component of the CImg Library project.

 #                    ( http://cimg.sourceforge.net )

 #

 #  Project manager : David Tschumperle.

 #                    ( http://tschumperle.users.greyc.fr/ )

 #

 #                    A complete list of contributors is available in file 'README.txt'

 #                    distributed within the CImg package.

 #

 #  Licenses        : This file is 'dual-licensed', you have to choose one

 #                    of the two licenses below to apply.

 #

 #                    CeCILL-C

 #                    The CeCILL-C license is close to the GNU LGPL.

 #                    ( http://www.cecill.info/licences/Licence_CeCILL-C_V1-en.html )

 #

 #                or  CeCILL v2.0

 #                    The CeCILL license is compatible with the GNU GPL.

 #                    ( http://www.cecill.info/licences/Licence_CeCILL_V2-en.html )

 #

 #  This software is governed either by the CeCILL or the CeCILL-C license

 #  under French law and abiding by the rules of distribution of free software.

 #  You can  use, modify and or redistribute the software under the terms of

 #  the CeCILL or CeCILL-C licenses as circulated by CEA, CNRS and INRIA

 #  at the following URL: "http://www.cecill.info".

 #

 #  As a counterpart to the access to the source code and  rights to copy,

 #  modify and redistribute granted by the license, users are provided only

 #  with a limited warranty  and the software's author,  the holder of the

 #  economic rights,  and the successive licensors  have only  limited

 #  liability.

 #

 #  In this respect, the user's attention is drawn to the risks associated

 #  with loading,  using,  modifying and/or developing or reproducing the

 #  software by the user in light of its specific status of free software,

 #  that may mean  that it is complicated to manipulate,  and  that  also

 #  therefore means  that it is reserved for developers  and  experienced

 #  professionals having in-depth computer knowledge. Users are therefore

 #  encouraged to load and test the software's suitability as regards their

 #  requirements in conditions enabling the security of their systems and/or

 #  data to be ensured and,  more generally, to use and operate it in the

 #  same conditions as regards security.

 #

 #  The fact that you are presently reading this means that you have had

 #  knowledge of the CeCILL and CeCILL-C licenses and that you accept its terms.

 #

*/

// Set version number of the library.

#ifndef cimg_version

#define cimg_version 160

/*-----------------------------------------------------------

 #

 # Test and possibly auto-set CImg configuration variables

 # and include required headers.

 #

 # If you find that the default configuration variables are

 # not adapted to your system, you can override their values

 # before including the header file "CImg.h"

 # (use the #define directive).

 #

 ------------------------------------------------------------*/

// Include standard C++ headers.

// This is the minimal set of required headers to make CImg-based codes compile.

#include <cstdio>

#include <cstdlib>

#include <cstdarg>

#include <cstring>

#include <cmath>

#include <ctime>

#include <exception>

// Detect/configure OS variables.

//

// Define 'cimg_OS' to: '0' for an unknown OS (will try to minize library dependencies).

//                      '1' for a Unix-like OS (Linux, Solaris, BSD, MacOSX, Irix, ...).

//                      '2' for Microsoft Windows.

//                      (auto-detection is performed if 'cimg_OS' is not set by the user).

#ifndef cimg_OS

#if defined(unix)        || defined(__unix)      || defined(__unix__) \

 || defined(linux)       || defined(__linux)     || defined(__linux__) \

 || defined(sun)         || defined(__sun) \

 || defined(BSD)         || defined(__OpenBSD__) || defined(__NetBSD__) \

 || defined(__FreeBSD__) || defined (__DragonFly__) \

 || defined(sgi)         || defined(__sgi) \

 || defined(__MACOSX__)  || defined(__APPLE__) \

 || defined(__CYGWIN__)

#define cimg_OS 1

#elif defined(_MSC_VER) || defined(WIN32)  || defined(_WIN32) || defined(__WIN32__) \

   || defined(WIN64)    || defined(_WIN64) || defined(__WIN64__)

#define cimg_OS 2

#else

#define cimg_OS 0

#endif

#elif !(cimg_OS==0 || cimg_OS==1 || cimg_OS==2)

#error CImg Library: Invalid configuration variable 'cimg_OS'.

#error (correct values are '0 = unknown OS', '1 = Unix-like OS', '2 = Microsoft Windows').

#endif

// Disable silly warnings on some Microsoft VC++ compilers.

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable:4311)

#pragma warning(disable:4312)

#pragma warning(disable:4800)

#pragma warning(disable:4804)

#pragma warning(disable:4996)

#define _CRT_SECURE_NO_DEPRECATE 1

#define _CRT_NONSTDC_NO_DEPRECATE 1

#endif

// Include OS-specific headers.

#if cimg_OS==1

#include <sys/types.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <unistd.h>

#elif cimg_OS==2

#ifndef NOMINMAX

#define NOMINMAX

#endif

#include <windows.h>

#ifndef _WIN32_IE

#define _WIN32_IE 0x0400

#endif

#include <shlobj.h>

#include <process.h>

#include <io.h>

#define cimg_snprintf _snprintf

#define cimg_vsnprintf _vsnprintf

#endif

#ifndef cimg_snprintf

#include <stdio.h>

#define cimg_snprintf snprintf

#define cimg_vsnprintf vsnprintf

#endif

// Look for C++11 features

#if !defined(cimg_use_cpp11) && __cplusplus>201100

#define cimg_use_cpp11

#endif

#ifdef cimg_use_cpp11

#include <initializer_list>

#include <utility>

#endif

// Configure filename separator.

//

// Filename separator is set by default to '/', except for Windows where it is '\'.

#ifndef cimg_file_separator

#if cimg_OS==2

#define cimg_file_separator '\\'

#else

#define cimg_file_separator '/'

#endif

#endif

// Configure verbosity of output messages.

//

// Define 'cimg_verbosity' to: '0' to hide library messages (quiet mode).

//                             '1' to output library messages on the console.

//                             '2' to output library messages on a basic dialog window (default behavior).

//                             '3' to do as '1' + add extra warnings (may slow down the code!).

//                             '4' to do as '2' + add extra warnings (may slow down the code!).

//

// Define 'cimg_strict_warnings' to replace warning messages by exception throwns.

//

// Define 'cimg_use_vt100' to allow output of color messages on VT100-compatible terminals.

#ifndef cimg_verbosity

#define cimg_verbosity 2

#elif !(cimg_verbosity==0 || cimg_verbosity==1 || cimg_verbosity==2 || cimg_verbosity==3 || cimg_verbosity==4)

#error CImg Library: Configuration variable 'cimg_verbosity' is badly defined.

#error (should be { 0=quiet | 1=console | 2=dialog | 3=console+warnings | 4=dialog+warnings }).

#endif

// Configure display framework.

//

// Define 'cimg_display' to: '0' to disable display capabilities.

//                           '1' to use the X-Window framework (X11).

//                           '2' to use the Microsoft GDI32 framework.

#ifndef cimg_display

#if cimg_OS==0

#define cimg_display 0

#elif cimg_OS==1

#if defined(__MACOSX__) || defined(__APPLE__)

#define cimg_display 1

#else

#define cimg_display 1

#endif

#elif cimg_OS==2

#define cimg_display 2

#endif

#elif !(cimg_display==0 || cimg_display==1 || cimg_display==2)

#error CImg Library: Configuration variable 'cimg_display' is badly defined.

#error (should be { 0=none | 1=X-Window (X11) | 2=Microsoft GDI32 }).

#endif

// Include display-specific headers.

#if cimg_display==1

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/keysym.h>

#include <pthread.h>

#ifdef cimg_use_xshm

#include <sys/ipc.h>

#include <sys/shm.h>

#include <X11/extensions/XShm.h>

#endif

#ifdef cimg_use_xrandr

#include <X11/extensions/Xrandr.h>

#endif

#endif

#ifndef cimg_appname

#define cimg_appname "CImg"

#endif

// Configure OpenMP support.

// (http://www.openmp.org)

//

// Define 'cimg_use_openmp' to enable OpenMP support.

//

// OpenMP directives may be used in a (very) few CImg functions to get

// advantages of multi-core CPUs.

#ifdef cimg_use_openmp

#include <omp.h>

#endif

// Configure OpenCV support.

// (http://opencv.willowgarage.com/wiki/)

//

// Define 'cimg_use_opencv' to enable OpenCV support.

//

// OpenCV library may be used to access images from cameras

// (see method 'CImg<T>::load_camera()').

#ifdef cimg_use_opencv

#ifdef True

#undef True

#define _cimg_redefine_True

#endif

#ifdef False

#undef False

#define _cimg_redefine_False

#endif

#include <cstddef>

#include "cv.h"

#include "highgui.h"

#endif

// Configure LibPNG support.

// (http://www.libpng.org)

//

// Define 'cimg_use_png' to enable LibPNG support.

//

// PNG library may be used to get a native support of '.png' files.

// (see methods 'CImg<T>::{load,save}_png()'.

#ifdef cimg_use_png

extern "C" {

#include "png.h"

}

#endif

// Configure LibJPEG support.

// (http://en.wikipedia.org/wiki/Libjpeg)

//

// Define 'cimg_use_jpeg' to enable LibJPEG support.

//

// JPEG library may be used to get a native support of '.jpg' files.

// (see methods 'CImg<T>::{load,save}_jpeg()').

#ifdef cimg_use_jpeg

extern "C" {

#include "jpeglib.h"

#include "setjmp.h"

}

#endif

// Configure LibTIFF support.

// (http://www.libtiff.org)

//

// Define 'cimg_use_tiff' to enable LibTIFF support.

//

// TIFF library may be used to get a native support of '.tif' files.

// (see methods 'CImg[List]<T>::{load,save}_tiff()').

#ifdef cimg_use_tiff

extern "C" {

#define uint64 uint64_hack_

#define int64 int64_hack_

#include "tiffio.h"

#undef uint64

#undef int64

}

#endif

// Configure LibMINC2 support.

// (http://en.wikibooks.org/wiki/MINC/Reference/MINC2.0_File_Format_Reference)

//

// Define 'cimg_use_minc2' to enable LibMINC2 support.

//

// MINC2 library may be used to get a native support of '.mnc' files.

// (see methods 'CImg<T>::{load,save}_minc2()').

#ifdef cimg_use_minc2

#include "minc_io_simple_volume.h"

#include "minc_1_simple.h"

#include "minc_1_simple_rw.h"

#endif

// Configure FFMPEG support.

// (http://www.ffmpeg.org)

//

// Define 'cimg_use_ffmpeg' to enable FFMPEG lib support.

//

// Avcodec and Avformat libraries from FFMPEG may be used

// to get a native support of various video file formats.

// (see methods 'CImg[List]<T>::load_ffmpeg()').

#ifdef cimg_use_ffmpeg

#if (defined(_STDINT_H) || defined(_STDINT_H_)) && !defined(UINT64_C)

#warning "__STDC_CONSTANT_MACROS has to be defined before including <stdint.h>, this file will probably not compile."

#endif

#ifndef __STDC_CONSTANT_MACROS

#define __STDC_CONSTANT_MACROS // ...or stdint.h wont' define UINT64_C, needed by libavutil

#endif

extern "C" {

#include <libavformat/avformat.h>

#include <libavcodec/avcodec.h>

#include <libswscale/swscale.h>

}

#endif

// Configure Zlib support.

// (http://www.zlib.net)

//

// Define 'cimg_use_zlib' to enable Zlib support.

//

// Zlib library may be used to allow compressed data in '.cimgz' files

// (see methods 'CImg[List]<T>::{load,save}_cimg()').

#ifdef cimg_use_zlib

extern "C" {

#include "zlib.h"

}

#endif

// Configure Magick++ support.

// (http://www.imagemagick.org/Magick++)

//

// Define 'cimg_use_magick' to enable Magick++ support.

//

// Magick++ library may be used to get a native support of various image file formats.

// (see methods 'CImg<T>::{load,save}()').

#ifdef cimg_use_magick

#include "Magick++.h"

#endif

// Configure FFTW3 support.

// (http://www.fftw.org)

//

// Define 'cimg_use_fftw3' to enable libFFTW3 support.

//

// FFTW3 library may be used to efficiently compute the Fast Fourier Transform

// of image data, without restriction on the image size.

// (see method 'CImg[List]<T>::FFT()').

#ifdef cimg_use_fftw3

extern "C" {

#include "fftw3.h"

}

#endif

// Configure LibBoard support.

// (http://libboard.sourceforge.net/)

//

// Define 'cimg_use_board' to enable Board support.

//

// Board library may be used to draw 3d objects in vector-graphics canvas

// that can be saved as '.ps' or '.svg' files afterwards.

// (see method 'CImg<T>::draw_object3d()').

#ifdef cimg_use_board

#ifdef None

#undef None

#define _cimg_redefine_None

#endif

#include "Board.h"

#endif

// Configure OpenEXR support.

// (http://www.openexr.com/)

//

// Define 'cimg_use_openexr' to enable OpenEXR support.

//

// OpenEXR library may be used to get a native support of '.exr' files.

// (see methods 'CImg<T>::{load,save}_exr()').

#ifdef cimg_use_openexr

#include "ImfRgbaFile.h"

#include "ImfInputFile.h"

#include "ImfChannelList.h"

#include "ImfMatrixAttribute.h"

#include "ImfArray.h"

#endif

// Lapack configuration.

// (http://www.netlib.org/lapack)

//

// Define 'cimg_use_lapack' to enable LAPACK support.

//

// Lapack library may be used in several CImg methods to speed up

// matrix computations (eigenvalues, inverse, ...).

#ifdef cimg_use_lapack

extern "C" {

  extern void sgetrf_(int*, int*, float*, int*, int*, int*);

  extern void sgetri_(int*, float*, int*, int*, float*, int*, int*);

  extern void sgetrs_(char*, int*, int*, float*, int*, int*, float*, int*, int*);

  extern void sgesvd_(char*, char*, int*, int*, float*, int*, float*, float*, int*, float*, int*, float*, int*, int*);

  extern void ssyev_(char*, char*, int*, float*, int*, float*, float*, int*, int*);

  extern void dgetrf_(int*, int*, double*, int*, int*, int*);

  extern void dgetri_(int*, double*, int*, int*, double*, int*, int*);

  extern void dgetrs_(char*, int*, int*, double*, int*, int*, double*, int*, int*);

  extern void dgesvd_(char*, char*, int*, int*, double*, int*, double*, double*,

                      int*, double*, int*, double*, int*, int*);

  extern void dsyev_(char*, char*, int*, double*, int*, double*, double*, int*, int*);

  extern void dgels_(char*, int*,int*,int*,double*,int*,double*,int*,double*,int*,int*);

  extern void sgels_(char*, int*,int*,int*,float*,int*,float*,int*,float*,int*,int*);

}

#endif

// Check if min/max/PI macros are defined.

//

// CImg does not compile if macros 'min', 'max' or 'PI' are defined,

// because it redefines functions min(), max() and const variable PI in the cimg:: namespace.

// so it '#undef' these macros if necessary, and restore them to reasonable

// values at the end of this file.

#ifdef min

#undef min

#define _cimg_redefine_min

#endif

#ifdef max

#undef max

#define _cimg_redefine_max

#endif

#ifdef PI

#undef PI

#define _cimg_redefine_PI

#endif

// Define 'cimg_library' namespace suffix.

//

// You may want to add a suffix to the 'cimg_library' namespace, for instance if you need to work

// with several versions of the library at the same time.

#ifdef cimg_namespace_suffix

#define __cimg_library_suffixed(s) cimg_library_##s

#define _cimg_library_suffixed(s) __cimg_library_suffixed(s)

#define cimg_library_suffixed _cimg_library_suffixed(cimg_namespace_suffix)

#else

#define cimg_library_suffixed cimg_library

#endif

/*------------------------------------------------------------------------------

  #

  # Define user-friendly macros.

  #

  # These CImg macros are prefixed by 'cimg_' and can be used safely in your own

  # code. They are useful to parse command line options, or to write image loops.

  #

  ------------------------------------------------------------------------------*/

// Macros to define program usage, and retrieve command line arguments.

#define cimg_usage(usage) cimg_library_suffixed::cimg::option((char*)0,argc,argv,(char*)0,usage,false)

#define cimg_help(str) cimg_library_suffixed::cimg::option((char*)0,argc,argv,str,(char*)0)

#define cimg_option(name,defaut,usage) cimg_library_suffixed::cimg::option(name,argc,argv,defaut,usage)

#define cimg_argument(pos) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv)

#define cimg_argument1(pos,s0) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,1,s0)

#define cimg_argument2(pos,s0,s1) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,2,s0,s1)

#define cimg_argument3(pos,s0,s1,s2) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,3,s0,s1,s2)

#define cimg_argument4(pos,s0,s1,s2,s3) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,4,s0,s1,s2,s3)

#define cimg_argument5(pos,s0,s1,s2,s3,s4) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,5,s0,s1,s2,s3,s4)

#define cimg_argument6(pos,s0,s1,s2,s3,s4,s5) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,6,s0,s1,s2,s3,s4,s5)

#define cimg_argument7(pos,s0,s1,s2,s3,s4,s5,s6) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,7,s0,s1,s2,s3,s4,s5,s6)

#define cimg_argument8(pos,s0,s1,s2,s3,s4,s5,s6,s7) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,8,s0,s1,s2,s3,s4,s5,s6,s7)

#define cimg_argument9(pos,s0,s1,s2,s3,s4,s5,s6,s7,s8) \

  cimg_library_suffixed::cimg::argument(pos,argc,argv,9,s0,s1,s2,s3,s4,s5,s6,s7,s8)

// Macros to define and manipulate local neighborhoods.

#define CImg_2x2(I,T) T I[4]; \

                      T& I##cc = I[0]; T& I##nc = I[1]; \

                      T& I##cn = I[2]; T& I##nn = I[3]; \

                      I##cc = I##nc = \

                      I##cn = I##nn = 0

#define CImg_3x3(I,T) T I[9]; \

                      T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; \

                      T& I##pc = I[3]; T& I##cc = I[4]; T& I##nc = I[5]; \

                      T& I##pn = I[6]; T& I##cn = I[7]; T& I##nn = I[8]; \

                      I##pp = I##cp = I##np = \

                      I##pc = I##cc = I##nc = \

                      I##pn = I##cn = I##nn = 0

#define CImg_4x4(I,T) T I[16]; \

                      T& I##pp = I[0]; T& I##cp = I[1]; T& I##np = I[2]; T& I##ap = I[3]; \

                      T& I##pc = I[4]; T& I##cc = I[5]; T& I##nc = I[6]; T& I##ac = I[7]; \

                      T& I##pn = I[8]; T& I##cn = I[9]; T& I##nn = I[10]; T& I##an = I[11]; \

                      T& I##pa = I[12]; T& I##ca = I[13]; T& I##na = I[14]; T& I##aa = I[15]; \

                      I##pp = I##cp = I##np = I##ap = \

                      I##pc = I##cc = I##nc = I##ac = \

                      I##pn = I##cn = I##nn = I##an = \

                      I##pa = I##ca = I##na = I##aa = 0

#define CImg_5x5(I,T) T I[25]; \

                      T& I##bb = I[0]; T& I##pb = I[1]; T& I##cb = I[2]; T& I##nb = I[3]; T& I##ab = I[4]; \

                      T& I##bp = I[5]; T& I##pp = I[6]; T& I##cp = I[7]; T& I##np = I[8]; T& I##ap = I[9]; \

                      T& I##bc = I[10]; T& I##pc = I[11]; T& I##cc = I[12]; T& I##nc = I[13]; T& I##ac = I[14]; \

                      T& I##bn = I[15]; T& I##pn = I[16]; T& I##cn = I[17]; T& I##nn = I[18]; T& I##an = I[19]; \

                      T& I##ba = I[20]; T& I##pa = I[21]; T& I##ca = I[22]; T& I##na = I[23]; T& I##aa = I[24]; \

                      I##bb = I##pb = I##cb = I##nb = I##ab = \

                      I##bp = I##pp = I##cp = I##np = I##ap = \

                      I##bc = I##pc = I##cc = I##nc = I##ac = \

                      I##bn = I##pn = I##cn = I##nn = I##an = \

                      I##ba = I##pa = I##ca = I##na = I##aa = 0

#define CImg_2x2x2(I,T) T I[8]; \

                      T& I##ccc = I[0]; T& I##ncc = I[1]; \

                      T& I##cnc = I[2]; T& I##nnc = I[3]; \

                      T& I##ccn = I[4]; T& I##ncn = I[5]; \