head	1.16;
access;
symbols
	bobbase:1.13
	bob:1.13.1
	r2_1:1.12
	r2_0:1.12
	r1_1_beta:1.11
	r1_1_alpha:1.10
	r1_0:1.10
	r0_11:1.10
	r0_10:1.7
	r0_9:1.4;
locks
	thoth:1.13.1.2; strict;
comment	@// @;


1.16
date	95.01.11.15.41.23;	author thoth;	state Exp;
branches;
next	1.15;

1.15
date	94.12.28.22.01.56;	author ljr;	state Exp;
branches;
next	1.14;

1.14
date	94.12.12.16.57.26;	author fjsoria;	state Exp;
branches;
next	1.13;

1.13
date	94.10.14.19.07.30;	author ljr;	state Exp;
branches
	1.13.1.1;
next	1.12;

1.12
date	94.08.22.15.20.29;	author thoth;	state Exp;
branches;
next	1.11;

1.11
date	94.07.25.17.24.13;	author thoth;	state Exp;
branches;
next	1.10;

1.10
date	94.03.30.13.53.09;	author thoth;	state Exp;
branches;
next	1.9;

1.9
date	94.03.14.15.50.22;	author thoth;	state Exp;
branches;
next	1.8;

1.8
date	94.02.26.16.03.53;	author thoth;	state Exp;
branches;
next	1.7;

1.7
date	94.01.31.15.42.14;	author thoth;	state Exp;
branches;
next	1.6;

1.6
date	94.01.07.15.10.00;	author thoth;	state Exp;
branches;
next	1.5;

1.5
date	93.12.29.16.57.16;	author thoth;	state Exp;
branches;
next	1.4;

1.4
date	93.11.17.18.20.12;	author thoth;	state Exp;
branches;
next	1.3;

1.3
date	93.10.05.19.33.08;	author thoth;	state Exp;
branches;
next	1.2;

1.2
date	93.09.27.15.50.57;	author thoth;	state Exp;
branches;
next	1.1;

1.1
date	93.09.15.12.53.58;	author thoth;	state Exp;
branches;
next	;

1.13.1.1
date	94.12.28.18.30.51;	author thoth;	state Exp;
branches;
next	1.13.1.2;

1.13.1.2
date	95.01.13.19.37.42;	author thoth;	state Exp;
branches;
next	;


desc
@Image handle class declaration
@


1.16
log
@Template arguments were transposed.
@
text
@// Emacs: -*- C++ -*-

//
//	Copyright 1993, Center for Computer Vision and Visualization,
//	University of Florida.  All rights reserved.
//


//
// $Log: CoreImage.h,v $
// Revision 1.15  1994/12/28  22:01:56  ljr
// Changed friend class IA_CoreImage<IA_Point<double>, T> declaration
// to friend class IA_CoreImage<IA_Point<double>, float>.  Original
// declaration gives BC++ problems, and IAC++ requires only the latter.
//
// Revision 1.14  1994/12/12  16:57:26  fjsoria
// g++ does not allow Template <class x> friend class funct_name;
// changed to friend class IA_FBI<P,P,T,T,T>; and guarded
//
// Revision 1.13  1994/10/14  19:07:30  ljr
// Removed erroneous friend declaration of ostream insertion operator
// for IA_CoreImage<T,P>&.  Though this compiled under cfront, it was
// still an error.
//
// Revision 1.12  1994/08/22  15:20:29  thoth
// DOS-inspired name rework.
//
// Revision 1.11  1994/07/25  17:24:13  thoth
// Name sanitization
//
// Revision 1.10  1994/03/30  13:53:09  thoth
// FBI now has enough class parameters to describe friendliness of
// certain function templates.
// FBI functions are now inlines removing the need for ptrepository
// objects.
//
// Revision 1.9  1994/03/14  15:50:22  thoth
// ValueSet has been replaced by container class Set.
// FBI will eventually contain all image-image ops.
//
// Revision 1.8  1994/02/26  16:03:53  thoth
// operator() of the container now relies upon the contained classes
// to check if p is contained in the domain.  This means that users
// could possibly write an erroneous operator().
//
// Revision 1.7  1994/01/31  15:42:14  thoth
// chi_contains and compositions have been moved into AuxImage.c.
// transpose of a 2D boxy image is now available.
//
// Revision 1.6  1994/01/07  15:10:00  thoth
// Image class is now CoreImage and named image types are
// Image<P,T>.
//
// Revision 1.5  1993/12/29  16:57:16  thoth
// new chi_contains function
// Pixel array constructor.
// pointarray valuearray constructor.
// Improved error handling.
//
// Revision 1.4  1993/11/17  18:20:12  thoth
// translated is now translate.
// extensivep is now extensive.
// CFront bug workaround is now disabled.
// zero_extend is a void function.
//
// Revision 1.3  1993/10/05  19:33:08  thoth
// Move to new Closure naming convention.
//
// Revision 1.2  1993/09/27  15:50:57  thoth
// xlated is now translated.
//
// Revision 1.1  1993/09/15  12:53:58  thoth
// Initial revision
//

#ifndef CoreImage_h_
#define CoreImage_h_

#include <iostream.h>
#include "ia.h"
#include "Point.h"

#include "Set.h"
#include "IntPS.h"
#include "DblPS.h"

#include "BaseI.h"
#include "Pixel.h"


template < class P,class T> class IA_IVIter;
template < class P,class T> class IA_IPIter;

template < class P,class T> class IA_ClosureI;

template < class P,class T> class IA_CoreImage;

template < class P, class Q, class R, class S, class T> class IA_FBI;

template < class P,class T>
ostream& operator <<(ostream&, const IA_CoreImage<P,T>&);


#include "AuxImage.h"

template < class P,class T>
class IA_CoreImage {

#ifndef __NO_FRIEND_TEMPLATE_SUPPORT
  template <class Q, class U>
	friend class IA_FBI;
#else
friend class IA_FBI<P,P,T,T,T>;
#endif
  
  protected:
    
    // INVARIANT:  bip has a value in every image.  The uninitialized
    //		   value is errorDI.
    IA_BaseImage<P,T> *bip;
    
    // Places a valid value in bip and refcounts appropriately.
    void set_and_reference_image(IA_BaseImage<P,T> *i);
    
    // Decrement the BaseDI\'s refcount and delete if necessary.
    void disassociate_image();
    
    // no one else should be tossing BaseDIs around
    IA_CoreImage(IA_BaseImage<P,T> *base) {
	set_and_reference_image(base);
    }
    
    static IA_VectorI<P,T> *sortedPixel_to_VectorI(const IA_Pixel<P,T> *pixels,
						   unsigned count);

  public:
    IA_CoreImage();
    
    // copy constructor
    IA_CoreImage(const IA_CoreImage&);
    
    // const image constructor
    IA_CoreImage(const IA_Set<P>&, const T&);
    
    // vector image constructor
    IA_CoreImage(const IA_Set<P>&, T *, unsigned, int giveaway);
    IA_CoreImage(const IA_Set<P>&, const T *, unsigned);
    IA_CoreImage(const IA_Pixel<P,T> *, unsigned);
    IA_CoreImage(const P*, unsigned, const T *, unsigned);
    IA_CoreImage(const P*, unsigned, T *, unsigned, int giveaway);
    IA_CoreImage(const IA_ClosureI<P,T>& i);
    IA_CoreImage(const IA_Set<P>&, T (*)(const P&));
    IA_CoreImage(const IA_Set<P>&, T (*)(P));
    
    virtual ~IA_CoreImage();
    
    IA_CoreImage& operator =(const IA_CoreImage &);
    
    // keep the domain, but make all values the same
    IA_CoreImage& operator =(const T&);
    
    // what sort of image is this?
    IA::Type type() const { return bip->type(); }
    
    // retrieve a value from the image
    T operator ()(const P& p) const {
	return (*this->bip)(p);
    }
    
    // retrieve a reference to a value in the image
    T& operator [](const P&);

    IA_CoreImage<IA_Point<int>,T> restrict( const IA_Set<IA_Point<int> >&) const;
    IA_CoreImage<P,T> restrict( const IA_Set<IA_Point<double> >&) const;
    IA_CoreImage restrict( const IA_Set<T>&) const;
    // the next one looks gratuitous --thoth
    //IA_CoreImage restrict( int (*)(const P&)) const;
    
    // Image Extension -- NOT ASSOCIATIVE!!!
  private:
#define FUNKY_ERROR
    static void vec_vec_2_vec_structcopy (const T **lhs_data,
					  const T **rhs_data,
					  T **dest, const IA_SetStructure &ss);
    static void vec_iter_2_vec_structcopy(const T **lhs_data,
#ifdef FUNKY_ERROR
					  void *rhs_iter,
#else
					  IA_IVIter<P,T> *rhs_iter,
#endif
					  T **dest,
					  const IA_SetStructure &ss);
    static void iter_vec_2_vec_structcopy( //
#ifdef FUNKY_ERROR
	void *lhs_iter,
#else
	IA_IVIter<P,T> *lhs_iter,
#endif
	const T **rhs_data,
	T **dest,
	const IA_SetStructure &ss);
    static void iter_iter_2_vec_structcopy( //
#ifdef FUNKY_ERROR
	void *lhs_iter,
	void *rhs_iter,
#else
	IA_IVIter<P,T> *lhs_iter,
	IA_IVIter<P,T> *rhs_iter,
#endif
	T **dest,
	const IA_SetStructure &ss);
  public:
    IA_CoreImage extend( const IA_CoreImage&) const;

    IA_CoreImage translate( const P &) const;

    IA_Set<P> domain() const { return this->bip->domain(); }

    IA_Set<T> range() const;
    IA_Array<T> value_array() const { return this->bip->value_array(); }
    
    unsigned card() const {
#if 0
	IA_Set<P>	temp = this->domain();
	return temp.card();
#else
	return this->domain().card();
#endif
    }
    
    int extensive() const { return this->bip->extensive(); }
    
    T reduce(T (*)(const T&, const T&),T) const;
    
    T reduce(T (*) (T, T), T) const;

    friend IA_CoreImage<IA_Point<int>,IA_Bit>
	chi_contains(const IA_CoreImage<IA_Point<int>, T> &lhs,
		     const IA_Set<T> &rhs);
    friend IA_CoreImage<IA_Point<int>,T>
	transpose(const IA_CoreImage<IA_Point<int>, T> &lhs);

#include "ImgRestrictAssn.h"

public:
    friend ostream& operator <<(ostream&, const IA_CoreImage<P,T>&);
    
#if 0
    static IA_CoreImage read_IAA(istream &header, istream &values);
    static IA_CoreImage read_IAA(const char *fname1,
			     const char *fname2);
    static IA_CoreImage read_IAA(const char *fname);
    
    void write_IAA(ostream &header, ostream &values) const;
    
    void write_IAA(const char *fname1, const char *fname2) const;
    void write_IAA(const char *fname) const;
#endif

    friend class IA_CoreImage<IA_Point<int>, T>;
//     friend class IA_CoreImage<IA_Point<double>, T>;
    friend class IA_CoreImage<IA_Point<double>, float>;
    friend class IA_IVIter<P,T>;
    friend class IA_IPIter<P,T>;
    
    friend void zero_extend(const IA_CoreImage<P,T> &, const IA_Set<P>&,
			    T*, T);
};

#endif // CoreImage_h_
@


1.15
log
@Changed friend class IA_CoreImage<IA_Point<double>, T> declaration
to friend class IA_CoreImage<IA_Point<double>, float>.  Original
declaration gives BC++ problems, and IAC++ requires only the latter.
@
text
@d11 5
d101 1
a101 1
ostream& operator <<(ostream&, const IA_CoreImage<T,P>&);
@


1.14
log
@g++ does not allow Template <class x> friend class funct_name;
changed to friend class IA_FBI<P,P,T,T,T>; and guarded
@
text
@d11 4
d256 2
a257 1
    friend class IA_CoreImage<IA_Point<double>, T>;
d265 1
a265 1
#endif // Image_h_
@


1.13
log
@Removed erroneous friend declaration of ostream insertion operator
for IA_CoreImage<T,P>&.  Though this compiled under cfront, it was
still an error.
@
text
@d11 5
d94 1
d99 3
a101 1
    template <class Q, class U>
d103 4
@


1.13.1.1
log
@restriction and extension are now ROFs.
new reflection ROF
@
text
@a10 9
// Revision 1.14  1994/12/12  16:57:26  fjsoria
// g++ does not allow Template <class x> friend class funct_name;
// changed to friend class IA_FBI<P,P,T,T,T>; and guarded
//
// Revision 1.13  1994/10/14  19:07:30  ljr
// Removed erroneous friend declaration of ostream insertion operator
// for IA_CoreImage<T,P>&.  Though this compiled under cfront, it was
// still an error.
//
a88 1

d93 1
a93 3

#ifndef __NO_FRIEND_TEMPLATE_SUPPORT
  template <class Q, class U>
d95 1
a95 5
#else
friend class IA_FBI<P,P,T,T,T>;
#endif
  
protected:
d152 3
a154 23
    friend IA_CoreImage<IA_Point<int>, T>
	restrict(const IA_CoreImage<P,T> &, const IA_Set<IA_Point<int> >&);
    friend IA_CoreImage<P, T>
	restrict(const IA_CoreImage<P,T> &, const IA_Set<IA_Point<double> >&);

#if 0 // Causes error in CFront

    /*
/local/bin/CC-3.0.3 -D__CFRONT__=3 -g -I. -I../../include      -c  IntDI.c
CC  IntDI.c:
"./CoreImage.h", line 97: error:   IA_CoreImage <class  IA_Point <int >, int > undefined, size not known
"./CoreImage.h", line 97:        error detected during the instantiation of IA_CoreImage <class  IA_Point <int >, int >
"./IntDI.h", line 82:    is the site of the instantiation
1 error
       */
    IA_CoreImage<IA_Point<int>,T>
	inline restrict( const IA_Set<IA_Point<int> >& ps) const {
	    return ::restrict(*this, ps);
	}
    IA_CoreImage<P,T> restrict( const IA_Set<IA_Point<double> >&ps) const { return ::restrict(*this, ps); }
    IA_CoreImage restrict( const IA_Set<T>& s) const { return ::value_restrict(*this, s); }
#endif

d192 1
a193 14
#if 1
    friend IA_CoreImage<P,T> extend(const IA_CoreImage<P,T> &,
				    const IA_CoreImage<P,T> &);
#else
/*
CC  _compose__FPFUc_6IA_RGBRC42IA_CoreImage__pt__22_17IA_Point__pt__2_iUcPC6IA_RGBT3PCUc.c:
"./ImgComp.c", line 18: internal <<USL C++ Language System <3.0.3> 12/01/93>> error: bus error (or something nasty like that)
*/
    IA_CoreImage extend( const IA_CoreImage&rhs) const {
	return ::extend(*this, rhs);
    }
#endif

#if 1
a194 3
#else
    friend IA_CoreImage<P,T> translate(const IA_CoreImage<P,T> &i, const P& p);
#endif
a220 3

    friend IA_CoreImage<P,T>
	reflect(const IA_CoreImage<P, T> &arg);
@


1.13.1.2
log
@CoreImage has been re-merged with Image.  All special stuff should be
friends of FBI now.
@
text
@d10 1
a10 5
// $Log: Image.h,v $
// Revision 1.13.1.1  1994/12/28  18:30:51  thoth
// restriction and extension are now ROFs.
// new reflection ROF
//
d91 1
a91 1
template < class P,class T> class IA_Image;
d95 3
d102 1
a102 1
class IA_Image {
d124 1
a124 1
    IA_Image(IA_BaseImage<P,T> *base) {
d132 1
a132 1
    IA_Image();
d135 1
a135 1
    IA_Image(const IA_Image&);
d138 1
a138 1
    IA_Image(const IA_Set<P>&, const T&);
d141 8
a148 8
    IA_Image(const IA_Set<P>&, T *, unsigned, int giveaway);
    IA_Image(const IA_Set<P>&, const T *, unsigned);
    IA_Image(const IA_Pixel<P,T> *, unsigned);
    IA_Image(const P*, unsigned, const T *, unsigned);
    IA_Image(const P*, unsigned, T *, unsigned, int giveaway);
    IA_Image(const IA_ClosureI<P,T>& i);
    IA_Image(const IA_Set<P>&, T (*)(const P&));
    IA_Image(const IA_Set<P>&, T (*)(P));
d150 1
a150 1
    virtual ~IA_Image();
d152 1
a152 1
    IA_Image& operator =(const IA_Image &);
d155 1
a155 1
    IA_Image& operator =(const T&);
d168 4
a171 4
    friend IA_Image<IA_Point<int>, T>
	restrict(const IA_Image<P,T> &, const IA_Set<IA_Point<int> >&);
    friend IA_Image<P, T>
	restrict(const IA_Image<P,T> &, const IA_Set<IA_Point<double> >&);
d178 2
a179 2
"./Image.h", line 97: error:   IA_Image <class  IA_Point <int >, int > undefined, size not known
"./Image.h", line 97:        error detected during the instantiation of IA_Image <class  IA_Point <int >, int >
d183 1
a183 1
    IA_Image<IA_Point<int>,T>
d187 2
a188 2
    IA_Image<P,T> restrict( const IA_Set<IA_Point<double> >&ps) const { return ::restrict(*this, ps); }
    IA_Image restrict( const IA_Set<T>& s) const { return ::value_restrict(*this, s); }
d192 1
a192 1
    //IA_Image restrict( int (*)(const P&)) const;
d230 2
a231 2
    friend IA_Image<P,T> extend(const IA_Image<P,T> &,
				    const IA_Image<P,T> &);
d234 1
a234 1
CC  _compose__FPFUc_6IA_RGBRC42IA_Image__pt__22_17IA_Point__pt__2_iUcPC6IA_RGBT3PCUc.c:
d237 1
a237 1
    IA_Image extend( const IA_Image&rhs) const {
d243 1
a243 1
    IA_Image translate( const P &) const;
d245 1
a245 1
    friend IA_Image<P,T> translate(const IA_Image<P,T> &i, const P& p);
d268 2
a269 2
    friend IA_Image<IA_Point<int>,IA_Bit>
	chi_contains(const IA_Image<IA_Point<int>, T> &lhs,
d271 2
a272 2
    friend IA_Image<IA_Point<int>,T>
	transpose(const IA_Image<IA_Point<int>, T> &lhs);
d274 2
a275 2
    friend IA_Image<P,T>
	reflect(const IA_Image<P, T> &arg);
d280 1
a280 1
    friend ostream& operator <<(ostream&, const IA_Image<P,T>&);
d283 2
a284 2
    static IA_Image read_IAA(istream &header, istream &values);
    static IA_Image read_IAA(const char *fname1,
d286 1
a286 1
    static IA_Image read_IAA(const char *fname);
d294 2
a295 2
    friend class IA_Image<IA_Point<int>, T>;
    friend class IA_Image<IA_Point<double>, T>;
d299 1
a299 1
    friend void zero_extend(const IA_Image<P,T> &, const IA_Set<P>&,
d303 1
a303 1
#endif // CoreImage_h_
@


1.12
log
@DOS-inspired name rework.
@
text
@d11 3
d87 1
a87 1
friend ostream& operator <<(ostream&, const IA_CoreImage<T,P>&);
@


1.11
log
@Name sanitization
@
text
@d11 3
d67 2
a68 2
#include "IntPointSet.h"
#include "DoublePointSet.h"
@


1.10
log
@FBI now has enough class parameters to describe friendliness of
certain function templates.
FBI functions are now inlines removing the need for ptrepository
objects.
@
text
@d11 6
d65 1
a65 1
#include "FloatPointSet.h"
d136 1
a136 1
    IA_ImageType type() const { return bip->type(); }
d146 2
a147 2
    IA_CoreImage<IA_IntPoint,T> restrict( const IA_Set<IA_IntPoint>&) const;
    IA_CoreImage<P,T> restrict( const IA_Set<IA_FloatPoint>&) const;
d210 2
a211 2
    friend IA_CoreImage<IA_IntPoint,IA_Bit>
	chi_contains(const IA_CoreImage<IA_IntPoint, T> &lhs,
d213 2
a214 2
    friend IA_CoreImage<IA_IntPoint,T>
	transpose(const IA_CoreImage<IA_IntPoint, T> &lhs);
@


1.9
log
@ValueSet has been replaced by container class Set.
FBI will eventually contain all image-image ops.
@
text
@d11 4
d72 1
a72 1
template < class P,class T> class IA_FBI;
a234 1

@


1.8
log
@operator() of the container now relies upon the contained classes
to check if p is contained in the domain.  This means that users
could possibly write an erroneous operator().
@
text
@d11 5
a51 1
#include "ValueSet.h"
d68 2
d77 2
d138 1
a138 1
    IA_CoreImage restrict( const IA_ValueSet<T>&) const;
d182 1
a182 1
    IA_ValueSet<T> range() const;
d202 1
a202 1
		     const IA_ValueSet<T> &rhs);
@


1.7
log
@chi_contains and compositions have been moved into AuxImage.c.
transpose of a 2D boxy image is now available.
@
text
@d11 4
a121 3
	if (!domain().contains(p)) {
	    ia_throw(IA::IMAGE_POINT_OUTSIDE_DOMAIN, __FILE__,__LINE__);
	}
@


1.6
log
@Image class is now CoreImage and named image types are
Image<P,T>.
@
text
@d10 5
a14 1
// $Log: CoreCoreImage.h,v $
a61 10
template <class P, class T>
IA_CoreImage<P,int> chi_contains(const IA_CoreImage<P, T> &lhs,
			     const IA_ValueSet<T> &rhs);
// the following two functions should not have to be declared here but
// CFront is busted
template <class P, class T> IA_CoreImage<P, int>
iter_chi_contains(IA_CoreImage<P, T> lhs, const IA_ValueSet<T> &rhs);
template <class P,class T> class IA_VectorI;
template <class P, class T> IA_CoreImage<P, int>
vec_chi_contains(const IA_VectorI<P, T> *lhs, const IA_ValueSet<T> &rhs)
d63 1
d191 7
a197 2
    friend IA_CoreImage<P,int> chi_contains(const IA_CoreImage<P, T> &lhs,
					const IA_ValueSet<T> &rhs);
d199 1
a222 22
#include "Closure.h"

template <class P, class T>
IA_CoreImage<P,T> compose
(const IA_CoreImage<P,T>&,
 const IA_Closure<P, P> &);

template <class P, class T>
IA_CoreImage<P,T> compose(const IA_CoreImage<P,T>&,
			    P (*)(const P&));

template <class P, class T>
IA_CoreImage<P,T> compose(T (*)(T), const IA_CoreImage<P,T> &);

template <class P, class S, class T>
IA_CoreImage<P,S> compose(S (*)(T), const IA_CoreImage<P,T> &, const S*);

template <class P, class R, class S, class T>
IA_CoreImage<P,R> compose(R (*)(S), const IA_CoreImage<P,T> &, const R*, const S*);

template <class P, class Q, class R, class S, class T>
IA_CoreImage<P,Q> compose(R (*)(S), const IA_CoreImage<P,T> &, const Q*, const R*, const S*);
@


1.5
log
@new chi_contains function
Pixel array constructor.
pointarray valuearray constructor.
Improved error handling.
@
text
@d10 7
a16 1
// $Log: Image.h,v $
d33 2
a34 2
#ifndef Image_h_
#define Image_h_
d54 1
a54 1
template < class P,class T> class IA_Image;
d57 1
a57 1
friend ostream& operator <<(ostream&, const IA_Image<T,P>&);
d59 1
a59 1
IA_Image<P,int> chi_contains(const IA_Image<P, T> &lhs,
d63 2
a64 2
template <class P, class T> IA_Image<P, int>
iter_chi_contains(IA_Image<P, T> lhs, const IA_ValueSet<T> &rhs);
d66 1
a66 1
template <class P, class T> IA_Image<P, int>
d71 1
a71 1
class IA_Image {
d85 1
a85 1
    IA_Image(IA_BaseImage<P,T> *base) {
d93 1
a93 1
    IA_Image();
d96 1
a96 1
    IA_Image(const IA_Image&);
d99 1
a99 1
    IA_Image(const IA_Set<P>&, const T&);
d102 8
a109 8
    IA_Image(const IA_Set<P>&, T *, unsigned, int giveaway);
    IA_Image(const IA_Set<P>&, const T *, unsigned);
    IA_Image(const IA_Pixel<P,T> *, unsigned);
    IA_Image(const P*, unsigned, const T *, unsigned);
    IA_Image(const P*, unsigned, T *, unsigned, int giveaway);
    IA_Image(const IA_ClosureI<P,T>& i);
    IA_Image(const IA_Set<P>&, T (*)(const P&));
    IA_Image(const IA_Set<P>&, T (*)(P));
d111 1
a111 1
    virtual ~IA_Image();
d113 1
a113 1
    IA_Image& operator =(const IA_Image &);
d116 1
a116 1
    IA_Image& operator =(const T&);
d132 3
a134 3
    IA_Image<IA_IntPoint,T> restrict( const IA_Set<IA_IntPoint>&) const;
    IA_Image<P,T> restrict( const IA_Set<IA_FloatPoint>&) const;
    IA_Image restrict( const IA_ValueSet<T>&) const;
d136 1
a136 1
    //IA_Image restrict( int (*)(const P&)) const;
d172 1
a172 1
    IA_Image extend( const IA_Image&) const;
d174 1
a174 1
    IA_Image translate( const P &) const;
d196 1
a196 1
    friend IA_Image<P,int> chi_contains(const IA_Image<P, T> &lhs,
d199 1
a199 1
    friend ostream& operator <<(ostream&, const IA_Image<P,T>&);
d202 2
a203 2
    static IA_Image read_IAA(istream &header, istream &values);
    static IA_Image read_IAA(const char *fname1,
d205 1
a205 1
    static IA_Image read_IAA(const char *fname);
d213 2
a214 2
    friend class IA_Image<IA_Point<int>, T>;
    friend class IA_Image<IA_Point<double>, T>;
d218 1
a218 1
    friend void zero_extend(const IA_Image<P,T> &, const IA_Set<P>&,
d225 2
a226 2
IA_Image<P,T> compose
(const IA_Image<P,T>&,
d230 1
a230 1
IA_Image<P,T> compose(const IA_Image<P,T>&,
d234 1
a234 1
IA_Image<P,T> compose(T (*)(T), const IA_Image<P,T> &);
d237 1
a237 1
IA_Image<P,S> compose(S (*)(T), const IA_Image<P,T> &, const S*);
d240 1
a240 1
IA_Image<P,R> compose(R (*)(S), const IA_Image<P,T> &, const R*, const S*);
d243 1
a243 1
IA_Image<P,Q> compose(R (*)(S), const IA_Image<P,T> &, const Q*, const R*, const S*);
@


1.4
log
@translated is now translate.
extensivep is now extensive.
CFront bug workaround is now disabled.
zero_extend is a void function.
@
text
@d11 6
d40 1
d48 2
d52 10
d83 3
d98 3
d103 1
d118 1
a118 2
	    cerr << "operator(): point not in image domain" << endl;
	    abort();		// throw
d189 4
a192 1
    
@


1.3
log
@Move to new Closure naming convention.
@
text
@d11 3
d143 1
a143 1
    IA_Image translated( const P &) const;
d150 2
a151 1
    int card() const {
d154 3
a156 1
	// return this->domain().card();
d159 1
a159 1
    int extensivep() const { return this->bip->extensivep(); }
d184 2
a185 2
    friend zero_extend(const IA_Image<P,T> &, const IA_Set<P>&,
		       T*, T);
@


1.2
log
@xlated is now translated.
@
text
@d11 3
d36 1
a36 1
template < class P,class T> class IA_OtherI;
d73 1
a73 1
    IA_Image(const IA_OtherI<P,T>& i);
d89 1
a99 1
    //IA_Image<IA_IntPoint,T> restrict(const IA_Set<IA_IntPoint>&) const;
@


1.1
log
@Initial revision
@
text
@d10 4
a13 1
// $Log:	DiscreteImage.h,v $
d136 3
a138 3
    
    IA_Image xlated( const P &) const;
    
d140 1
a140 1
    
@
