head	1.9;
access;
symbols
	bobbase:1.8
	bob:1.8.1
	r2_1:1.7
	C_8:1.7
	r2_0:1.6
	r1_1_beta:1.6
	r1_1_alpha:1.5
	r1_0:1.5
	r0_11:1.5
	r0_10:1.2;
locks
	thoth:1.8.1.2; strict;
comment	@// @;


1.9
date	94.12.28.21.57.15;	author ljr;	state Exp;
branches;
next	1.8;

1.8
date	94.12.08.21.03.01;	author fjsoria;	state Exp;
branches
	1.8.1.1;
next	1.7;

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

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

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

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

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

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

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

1.8.1.1
date	94.12.28.15.38.25;	author thoth;	state Exp;
branches;
next	1.8.1.2;

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


desc
@declaration of auxiliary image operations.
@


1.9
log
@Guarded CFront hacks that gave BC++ indigestion.
@
text
@// Emacs: -*- C++ -*-

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


//
// $Log: AuxImage.h,v $
// Revision 1.8  1994/12/08  21:03:01  fjsoria
// missing ";" fter template declarations
//
// Revision 1.7  1994/09/16  14:57:59  thoth
// Compositions now live in their own include files.
//
// Revision 1.6  1994/07/25  17:26:39  thoth
// Name sanitization
//
// Revision 1.5  1994/03/30  13:50:38  thoth
// zero_extension should be a template function.
//
// Revision 1.4  1994/03/14  15:48:33  thoth
// ValueSet has been replaced by container class Set.
//
// Revision 1.3  1994/02/26  16:01:09  thoth
// New 3-argument spatial composition functions.  Allow destination
// pointsets to be specified.
//
// Revision 1.2  1994/02/01  17:01:37  thoth
// Fix some screwy instantiation problems.
//
// Revision 1.1  1994/01/31  16:43:38  thoth
// Initial revision
//

#ifndef AuxImage_h_
#define AuxImage_h_

#include "Closure.h"
#include "Bit.h"
#include "Point.h"
#include "Set.h"

template <class P, class T> class IA_CoreImage;
template <class P, class T> class IA_Image;
template <class P,class T> class IA_VectorI;
template <class P,class T> class IA_IVIter;

template <class T>
void zero_extend_vec_scan(const IA_SetStructure &ss,
			  const T **src,
			  T **dest,
			  T zero);

template <class T>
void zero_extend_iter_scan(const IA_SetStructure &ss,
			   IA_IVIter<IA_Point<int>,T> *srciter,
			   T **dest,
			   T zero);

template <class P, class T>
void zero_extend(const IA_CoreImage<P,T> &, const IA_Set<P>&, T*, T);

template <class P, class T>
inline void zero_extend(const IA_Image<P,T> &img, const IA_Set<P> &ps,
			T *vals, T zero) {
    zero_extend((IA_CoreImage<P,T>&)img, ps, vals, zero);
}

//
//

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

// the following two functions should not have to be declared here but
// CFront is busted

#if 0
template <class T> IA_CoreImage<IA_Point<int>, int>
iter_chi_contains(const IA_CoreImage<IA_Point<int>, T> &lhs,
		  const IA_Set<T> &rhs);

template <class T> IA_CoreImage<IA_Point<int>, int>
vec_chi_contains(const IA_VectorI<IA_Point<int>, T> *lhs,
		 const IA_Set<T> &rhs);

#endif

//
//

template <class T> IA_CoreImage<IA_Point<int>,T>
transpose(const IA_CoreImage<IA_Point<int>, T> &);

// the following two functions should not have to be declared here but
// CFront is busted
#ifdef __CFRONT__
template <class T> IA_CoreImage<IA_Point<int>, T>
vec_transpose(const IA_VectorI<IA_Point<int>, T> *img);

template <class T> IA_CoreImage<IA_Point<int>, T>
iter_transpose(const IA_CoreImage<IA_Point<int>, T> &img);
#endif

//
//

// spatial composition
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>&,
 const IA_Closure<P, P> &,
 const IA_Set<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(const IA_CoreImage<P,T>&,
			  P (*)(const P&),
			  const IA_Set<P> &);

#include "ImgComp.h"

#endif // AuxImage_h_
@


1.8
log
@missing ";" fter template declarations
@
text
@d11 3
d81 1
d90 2
d100 1
d106 1
@


1.8.1.1
log
@Image extension, and restriction are now friends.
@
text
@a10 3
// Revision 1.8  1994/12/08  21:03:01  fjsoria
// missing ";" fter template declarations
//
d77 1
d81 1
a101 32
#if 0
template <class P, class T>
/*inline*/ IA_CoreImage<P,T> translate(const IA_CoreImage<P,T> &i, const P & p);
#if 0
{
    return i.bip->xlated_by(p);
}
#endif
#endif
//
//

template <class P, class T>
IA_CoreImage<IA_Point<int>, T>
restrict(const IA_CoreImage<P,T> &, const IA_Set<IA_Point<int> >&);

template <class P, class T>
IA_CoreImage<P, T>
restrict(const IA_CoreImage<P,T> &, const IA_Set<IA_Point<double> >&);

template <class P, class T>
IA_CoreImage<P, T>
value_restrict(const IA_CoreImage<P,T> &, const IA_Set<T>&);

//
//

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

//
//
a124 6

//
//

template <class P, class T>
IA_CoreImage<P,T> reflect(const IA_CoreImage<P,T>&);
@


1.8.1.2
log
@CoreImage has been re-merged with Image.  All special stuff should be
friends of FBI now.
@
text
@a10 3
// Revision 1.8.1.1  1994/12/28  15:38:25  thoth
// Image extension, and restriction are now friends.
//
d45 1
a46 1
//template <class P, class T> class IA_Image;
d62 8
a69 5
//template <class P, class T>
//void zero_extend(const IA_Image<P,T> &, const IA_Set<P>&, T*, T);
template <class T>
void zero_extend(const IA_Image<IA_Point<int>,T> &,
		 const IA_Set<IA_Point<int> >&, T*, T);
d74 2
a75 2
template <class T> IA_Image<IA_Point<int>,IA_Bit>
chi_contains(const IA_Image<IA_Point<int>, T> &lhs,
d80 2
a81 2
template <class T> IA_Image<IA_Point<int>, IA_Bit>
iter_chi_contains(const IA_Image<IA_Point<int>, T> &lhs,
d83 1
a83 1
template <class T> IA_Image<IA_Point<int>, IA_Bit>
d90 2
a91 2
template <class T> IA_Image<IA_Point<int>,T>
transpose(const IA_Image<IA_Point<int>, T> &);
d95 1
a95 1
template <class T> IA_Image<IA_Point<int>, T>
d98 2
a99 2
template <class T> IA_Image<IA_Point<int>, T>
iter_transpose(const IA_Image<IA_Point<int>, T> &img);
d105 1
a105 1
/*inline*/ IA_Image<P,T> translate(const IA_Image<P,T> &i, const P & p);
d116 2
a117 2
IA_Image<IA_Point<int>, T>
restrict(const IA_Image<P,T> &, const IA_Set<IA_Point<int> >&);
d120 2
a121 2
IA_Image<P, T>
restrict(const IA_Image<P,T> &, const IA_Set<IA_Point<double> >&);
d124 2
a125 2
IA_Image<P, T>
value_restrict(const IA_Image<P,T> &, const IA_Set<T>&);
d131 1
a131 1
IA_Image<P,T> extend(const IA_Image<P,T> &,const IA_Image<P,T> &);
d138 2
a139 2
IA_Image<P,T> compose
(const IA_Image<P,T>&,
d143 2
a144 2
IA_Image<P,T> compose
(const IA_Image<P,T>&,
d149 1
a149 1
IA_Image<P,T> compose(const IA_Image<P,T>&,
d153 1
a153 1
IA_Image<P,T> compose(const IA_Image<P,T>&,
d163 1
a163 10
IA_Image<P,T> reflect(const IA_Image<P,T>&);

//
//

template < class P,class T>
inline ostream& operator <<(ostream& o, const IA_Image<P,T>&im) {
    return o << *(im.bip);
}

@


1.7
log
@Compositions now live in their own include files.
@
text
@d11 3
d51 1
a51 1
			  T zero)
d57 1
a57 1
			   T zero)
d77 1
d81 1
d84 1
a84 1
		 const IA_Set<T> &rhs)
@


1.6
log
@Name sanitization
@
text
@d11 3
d119 1
a119 22
// value composition
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*);

template <class P, class R, class S, class T>
inline IA_CoreImage<P,R> compose(R (*f)(S), const IA_CoreImage<P,T> &i, const R*, const S*) { return compose(f, i, (const R*)0, (const R*)0, (const S*)0); }

template <class P, class S, class T>
inline IA_CoreImage<P,S> compose(S (*f)(T), const IA_CoreImage<P,T> &i, const S*) { return compose(f, i, (const S*)0, (const S*)0, (const T*)0); }

template <class P, class T>
inline IA_CoreImage<P,T> compose(T (*f)(T), const IA_CoreImage<P,T> &i) { return compose(f, i, (const T*)0, (const T*)0, (const T*)0); }



#include "Closure.h"

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

template <class P, class R, class S, class T>
inline IA_CoreImage<P,R> compose(const IA_Closure<S,R>&f, const IA_CoreImage<P,T> &i) { return compose(f, i, (const R*)0); }
@


1.5
log
@zero_extension should be a template function.
@
text
@d11 3
d49 1
a49 1
			   IA_IVIter<IA_IntPoint,T> *srciter,
d65 2
a66 2
template <class T> IA_CoreImage<IA_IntPoint,IA_Bit>
chi_contains(const IA_CoreImage<IA_IntPoint, T> &lhs,
d71 2
a72 2
template <class T> IA_CoreImage<IA_IntPoint, int>
iter_chi_contains(const IA_CoreImage<IA_IntPoint, T> &lhs,
d74 2
a75 2
template <class T> IA_CoreImage<IA_IntPoint, int>
vec_chi_contains(const IA_VectorI<IA_IntPoint, T> *lhs,
d81 2
a82 2
template <class T> IA_CoreImage<IA_IntPoint,T>
transpose(const IA_CoreImage<IA_IntPoint, T> &);
d86 2
a87 2
template <class T> IA_CoreImage<IA_IntPoint, T>
vec_transpose(const IA_VectorI<IA_IntPoint, T> *img);
d89 2
a90 2
template <class T> IA_CoreImage<IA_IntPoint, T>
iter_transpose(const IA_CoreImage<IA_IntPoint, T> &img);
@


1.4
log
@ValueSet has been replaced by container class Set.
@
text
@d11 3
d34 1
d36 25
@


1.3
log
@New 3-argument spatial composition functions.  Allow destination
pointsets to be specified.
@
text
@d11 4
a27 1
#include "ValueSet.h"
d35 1
a35 1
	     const IA_ValueSet<T> &rhs);
d41 1
a41 1
		  const IA_ValueSet<T> &rhs);
d44 1
a44 1
		 const IA_ValueSet<T> &rhs)
@


1.2
log
@Fix some screwy instantiation problems.
@
text
@d11 3
d67 6
d74 6
a79 1
			    P (*)(const P&));
@


1.1
log
@Initial revision
@
text
@d10 4
a13 1
// $Log: CoreImage.h,v $
d18 1
d21 2
a25 3
template <class T> class IA_ValueSet;

template <class I, class O> class IA_Closure;
@
