head	1.3;
access;
symbols
	r0_10:1.3
	Eglin_alpha_1:1.3;
locks; strict;
comment	@// @;


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

1.2
date	93.01.19.14.56.36;	author jnw;	state Exp;
branches;
next	1.1;

1.1
date	92.10.05.11.50.57;	author jnw;	state Exp;
branches;
next	;


desc
@Initial revision
@


1.3
log
@Copyright Notices
@
text
@// Emacs: -*- C++ -*-

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


// $Log:	LazyDI.h,v $
// Revision 1.2  93/01/19  14:56:36  jnw
// Modified to support IA_ naming convention
// 
// Revision 1.1  92/10/05  11:50:57  jnw
// Initial revision
// 

#ifndef LazyDI_h_
#define LazyDI_h_

#include "ia.h"
#include "BaseDI.h"

template <class T>
class IA_LazyBinaryDI: public IA_BaseDI<T>{
protected:
    IA_DiscreteImage<T> left_op, right_op;
public:

    IA_LazyBinaryDI( const IA_DiscreteImage<T> &l,
		     const IA_DiscreteImage<T> &r)
    :left_op(l), right_op(r), IA_BaseDI<T>(l.domain()) {
	if (l.domain() != r.domain()) {
	    ia_throw(IA::PSET_MISMATCH, __FILE__, __LINE__);
	}
    }

    int extensivep() const { return 0; }

    virtual ~IA_LazyBinaryDI() {}

    // T operator ()(const IA_IntPoint& p) is still virtual

    // IA_DiscreteImageType type() is still virtual

    // int equal(IA_BaseDI<T>*) is still virtual

    // IA_BaseDI* clone_self_extensively() is still virtual

    // ostream& print_this(ostream&) is still virtual
};

template <class T>
class IA_LazyUnaryDI: public IA_BaseDI<T>{
protected:
    IA_DiscreteImage<T> op;
public:

    IA_LazyUnaryDI( const IA_DiscreteImage<T> &arg)
    :op(arg), IA_BaseDI<T>(arg.domain()) {}

    int extensivep() const { return 0; }

    virtual ~IA_LazyUnaryDI() {}

    // T operator ()(IntPoint& p) is still virtual

    // DiscreteImageType type() is still virtual

    // int equal(BaseDI<T>*) is still virtual

    // BaseDI* clone_self_extensively() is still virtual

    // ostream& print_this(ostream&) is still virtual
};




#endif
@


1.2
log
@Modified to support IA_ naming convention
@
text
@d3 6
d10 3
@


1.1
log
@Initial revision
@
text
@d3 4
a6 1
// $Log$
d15 1
a15 1
class LazyBinaryDI: public BaseDI<T>{
d17 1
a17 1
    DiscreteImage<T> left_op, right_op;
d20 3
a22 2
    LazyBinaryDI( const DiscreteImage<T> &l, const DiscreteImage<T> &r)
    :left_op(l), right_op(r), BaseDI<T>(l.domain()) {
d30 1
a30 1
    virtual ~LazyBinaryDI() {}
d32 1
a32 1
    // T operator ()(const IntPoint& p) is still virtual
d34 1
a34 1
    // DiscreteImageType type() is still virtual
d36 1
a36 1
    // int equal(BaseDI<T>*) is still virtual
d38 1
a38 1
    // BaseDI* clone_self_extensively() is still virtual
d44 1
a44 1
class LazyUnaryDI: public BaseDI<T>{
d46 1
a46 1
    DiscreteImage<T> op;
d49 2
a50 2
    LazyUnaryDI( const DiscreteImage<T> &arg)
    :op(arg), BaseDI<T>(arg.domain()) {}
d54 1
a54 1
    virtual ~LazyUnaryDI() {}
@
