utilities.h

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#ifndef UTILITIES_H
#define UTILITIES_H

#include <stdio.h>
#include "yapi.h"
#include "vya.h"

//
// VYA MODULE   : fork2
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to two outputs
// DOCUMENTS    : n/a
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
// NETWORK      : n/a
// HISTORY      :
//    07/24/00  : Kees van Zon; Created (VYA 0.2)
//    08/07/00  : Kees van Zon; Copied to VYA 0.3
//    09/18/00  : Kees van Zon; Added type() function for YAPI 0.5.0
//    10/13/00  : Kees van Zon; Included in utilities.h

template<class FORK2>

class fork2: public Process
{
public:
    //constructor
    fork2 (
        Id            n,
        In<FORK2>&    inF,
        Out<FORK2>&   out1F,
        Out<FORK2>&   out2F
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    inP(id("in"), inF),
    out1P(id("out1"), out1F),
    out2P(id("out2"), out2F)
{ }
    // member functions
    const char* type() const { return "fork2"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
        }
    }

private:
    // ports
    InPort<FORK2>     inP;
    OutPort<FORK2>    out1P;
    OutPort<FORK2>    out2P;

    //member variable
    FORK2             in;
};

//
// VYA MODULE   : fork3
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to three outputs
// DOCUMENTS    : n/a
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
// NETWORK      :
// HISTORY      :
//    07/24/00  : Kees van Zon; Created (VYA 0.2)
//    08/07/00  : Kees van Zon; Copied to VYA 0.3
//    09/18/00  : Kees van Zon; Added type() function for YAPI 0.5.0
//    10/13/00  : Kees van Zon; Included in utilities.h

template<class FORK3>

class fork3: public Process
{
public:
    //constructor
    fork3 (
        Id            n,
        In<FORK3>&    inF,
        Out<FORK3>&   out1F,
        Out<FORK3>&   out2F,
        Out<FORK3>&   out3F
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    inP(id("in"), inF),
    out1P(id("out1"), out1F),
    out2P(id("out2"), out2F),
    out3P(id("out3"), out3F)
{ }
    // member functions
    const char* type() const { return "fork3"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
        }
    }

private:
    // ports
    InPort<FORK3>     inP;
    OutPort<FORK3>    out1P;
    OutPort<FORK3>    out2P;
    OutPort<FORK3>    out3P;

    //member variable
    FORK3             in;
};

//
// VYA MODULE   : fork4
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to four outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
// NETWORK      :
// HISTORY      :
//    07/24/00  : Kees van Zon; Created (VYA 0.2)
//    08/07/00  : Kees van Zon; Copied to VYA 0.3
//    09/18/00  : Kees van Zon; Added type() function for YAPI 0.5.0
//    10/13/00  : Kees van Zon; Included in utilities.h

template<class FORK4>

class fork4: public Process
{
public:
    //constructor
    fork4 (
        Id             n,
        In<FORK4>&     inF,
        Out<FORK4>&    out1F,
        Out<FORK4>&    out2F,
        Out<FORK4>&    out3F,
        Out<FORK4>&    out4F
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    inP(id("in"), inF),
    out1P(id("out1"), out1F),
    out2P(id("out2"), out2F),
    out3P(id("out3"), out3F),
    out4P(id("out4"), out4F)
{ }

    // member functions
    const char* type() const { return "fork4"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
        }
    }

private:
    // ports
    InPort<FORK4>     inP;
    OutPort<FORK4>    out1P;
    OutPort<FORK4>    out2P;
    OutPort<FORK4>    out3P;
    OutPort<FORK4>    out4P;

    // member variable
    FORK4             in;
};

//
// VYA MODULE   : fork5
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
// NETWORK      :
// HISTORY      :
//    07/24/00  : Kees van Zon; Created (VYA 0.2)
//    08/07/00  : Kees van Zon; Copied to VYA 0.3
//    09/18/00  : Kees van Zon; Added type() function for YAPI 0.5.0
//    10/13/00  : Kees van Zon; Included in utilities.h

template<class FORK5>

class fork5: public Process
{
public:
    //constructor
    fork5 (
        Id             n,
        In<FORK5>&     inF,
        Out<FORK5>&    out1F,
        Out<FORK5>&    out2F,
        Out<FORK5>&    out3F,
        Out<FORK5>&    out4F,
        Out<FORK5>&    out5F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F)
{ }

    // member functions
    const char* type() const { return "fork5"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
        }
    }

private:
    // ports
    InPort<FORK5>     inP;
    OutPort<FORK5>    out1P;
    OutPort<FORK5>    out2P;
    OutPort<FORK5>    out3P;
    OutPort<FORK5>    out4P;
    OutPort<FORK5>    out5P;

    // member variable
    FORK5             in;
};

//
// VYA MODULE   : fork6
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
//              : out6: =input
// NETWORK      :
// HISTORY      :
//    06/19/01  : Kees van Zon; Created (VYA 0.3)

template<class FORK6>

class fork6: public Process
{
public:
    //constructor
    fork6 (
        Id             n,
        In<FORK6>&     inF,
        Out<FORK6>&    out1F,
        Out<FORK6>&    out2F,
        Out<FORK6>&    out3F,
        Out<FORK6>&    out4F,
        Out<FORK6>&    out5F,
        Out<FORK6>&    out6F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F),
   out6P(id("out6"), out6F)
{ }

    // member functions
    const char* type() const { return "fork6"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
            write(out6P, in);
        }
    }

private:
    // ports
    InPort<FORK6>     inP;
    OutPort<FORK6>    out1P;
    OutPort<FORK6>    out2P;
    OutPort<FORK6>    out3P;
    OutPort<FORK6>    out4P;
    OutPort<FORK6>    out5P;
    OutPort<FORK6>    out6P;

    // member variable
    FORK6             in;
};

//
// VYA MODULE   : fork7
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
//              : out6: =input
//              : out7: =input
// NETWORK      :
// HISTORY      :
//    06/19/01  : Kees van Zon; Created (VYA 0.3)

template<class FORK7>

class fork7: public Process
{
public:
    //constructor
    fork7 (
        Id             n,
        In<FORK7>&     inF,
        Out<FORK7>&    out1F,
        Out<FORK7>&    out2F,
        Out<FORK7>&    out3F,
        Out<FORK7>&    out4F,
        Out<FORK7>&    out5F,
        Out<FORK7>&    out6F,
        Out<FORK7>&    out7F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F),
   out6P(id("out6"), out6F),
   out7P(id("out7"), out7F)
{ }

    // member functions
    const char* type() const { return "fork7"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
            write(out6P, in);
            write(out7P, in);
       }
    }

private:
    // ports
    InPort<FORK7>     inP;
    OutPort<FORK7>    out1P;
    OutPort<FORK7>    out2P;
    OutPort<FORK7>    out3P;
    OutPort<FORK7>    out4P;
    OutPort<FORK7>    out5P;
    OutPort<FORK7>    out6P;
    OutPort<FORK7>    out7P;

    // member variable
    FORK7             in;
};

//
// VYA MODULE   : fork8
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
//              : out6: =input
//              : out7: =input
//              : out8: =input
// NETWORK      :
// HISTORY      :
//    06/19/01  : Kees van Zon; Created (VYA 0.3)

template<class FORK8>

class fork8: public Process
{
public:
    //constructor
    fork8 (
        Id             n,
        In<FORK8>&     inF,
        Out<FORK8>&    out1F,
        Out<FORK8>&    out2F,
        Out<FORK8>&    out3F,
        Out<FORK8>&    out4F,
        Out<FORK8>&    out5F,
        Out<FORK8>&    out6F,
        Out<FORK8>&    out7F,
        Out<FORK8>&    out8F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F),
   out6P(id("out6"), out6F),
   out7P(id("out7"), out7F),
   out8P(id("out8"), out8F)
{ }

    // member functions
    const char* type() const { return "fork8"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
            write(out6P, in);
            write(out7P, in);
            write(out8P, in);
       }
    }

private:
    // ports
    InPort<FORK8>     inP;
    OutPort<FORK8>    out1P;
    OutPort<FORK8>    out2P;
    OutPort<FORK8>    out3P;
    OutPort<FORK8>    out4P;
    OutPort<FORK8>    out5P;
    OutPort<FORK8>    out6P;
    OutPort<FORK8>    out7P;
    OutPort<FORK8>    out8P;

    // member variable
    FORK8             in;
};

//
// VYA MODULE   : fork9
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
//              : out6: =input
//              : out7: =input
//              : out8: =input
//              : out9: =input
// NETWORK      :
// HISTORY      :
//    06/19/01  : Kees van Zon; Created (VYA 0.3)

template<class FORK9>

class fork9: public Process
{
public:
    //constructor
    fork9 (
        Id             n,
        In<FORK9>&     inF,
        Out<FORK9>&    out1F,
        Out<FORK9>&    out2F,
        Out<FORK9>&    out3F,
        Out<FORK9>&    out4F,
        Out<FORK9>&    out5F,
        Out<FORK9>&    out6F,
        Out<FORK9>&    out7F,
        Out<FORK9>&    out8F,
        Out<FORK9>&    out9F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F),
   out6P(id("out6"), out6F),
   out7P(id("out7"), out7F),
   out8P(id("out8"), out8F),
   out9P(id("out9"), out9F)
{ }

    // member functions
    const char* type() const { return "fork9"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
            write(out6P, in);
            write(out7P, in);
            write(out8P, in);
            write(out9P, in);
       }
    }

private:
    // ports
    InPort<FORK9>     inP;
    OutPort<FORK9>    out1P;
    OutPort<FORK9>    out2P;
    OutPort<FORK9>    out3P;
    OutPort<FORK9>    out4P;
    OutPort<FORK9>    out5P;
    OutPort<FORK9>    out6P;
    OutPort<FORK9>    out7P;
    OutPort<FORK9>    out8P;
    OutPort<FORK9>    out9P;

    // member variable
    FORK9             in;
};

//
// VYA MODULE   : fork10
// AUTHOR(S)    : Kees van Zon (based on Tmux.h by Rob Vogelaar)
// FUNCTION     : copies input to five outputs
// DOCUMENTS    : none
// INPUTS       : in:   input
// OUTPUTS      : out1: =input
//              : out2: =input
//              : out3: =input
//              : out4: =input
//              : out5: =input
//              : out6: =input
//              : out7: =input
//              : out8: =input
//              : out9: =input
//              : out10:=input
// NETWORK      :
// HISTORY      :
//    06/19/01  : Kees van Zon; Created (VYA 0.3)

template<class FORK10>

class fork10: public Process
{
public:
    //constructor
    fork10 (
        Id              n,
        In<FORK10>&     inF,
        Out<FORK10>&    out1F,
        Out<FORK10>&    out2F,
        Out<FORK10>&    out3F,
        Out<FORK10>&    out4F,
        Out<FORK10>&    out5F,
        Out<FORK10>&    out6F,
        Out<FORK10>&    out7F,
        Out<FORK10>&    out8F,
        Out<FORK10>&    out9F,
        Out<FORK10>&    out10F
    )
:
    // member initialisation
    // process network
    Process(n),

   // ports
   inP(id("in"), inF),
   out1P(id("out1"), out1F),
   out2P(id("out2"), out2F),
   out3P(id("out3"), out3F),
   out4P(id("out4"), out4F),
   out5P(id("out5"), out5F),
   out6P(id("out6"), out6F),
   out7P(id("out7"), out7F),
   out8P(id("out8"), out8F),
   out9P(id("out9"), out9F),
   out10P(id("out10"), out10F)
{ }

    // member functions
    const char* type() const { return "fork10"; }
    void main() {
        while(true) {
            read(inP, in);
            write(out1P, in);
            write(out2P, in);
            write(out3P, in);
            write(out4P, in);
            write(out5P, in);
            write(out6P, in);
            write(out7P, in);
            write(out8P, in);
            write(out9P, in);
            write(out10P, in);
       }
    }

private:
    // ports
    InPort<FORK10>     inP;
    OutPort<FORK10>    out1P;
    OutPort<FORK10>    out2P;
    OutPort<FORK10>    out3P;
    OutPort<FORK10>    out4P;
    OutPort<FORK10>    out5P;
    OutPort<FORK10>    out6P;
    OutPort<FORK10>    out7P;
    OutPort<FORK10>    out8P;
    OutPort<FORK10>    out9P;
    OutPort<FORK10>    out10P;

    // member variable
    FORK10             in;
};

//
// VYA MODULE   : sink
// AUTHOR(S)    : Kees van Zon (based on Tdrop.h by Rob Vogelaar)
// FUNCTION     : sinks dummy inputs
// DOCUMENTS    : n/a
// INPUTS       : In:    input token
// NETWORK      : n/a
// HISTORY      :
//    06/28/00  : Kees van Zon; Adopted from TDROP.h (VYA 0.2)
//    07/24/00  : Kees van Zon; Removed tabs
//    08/07/00  : Kees van Zon; Copied to VYA 0.3
//    09/19/00  : Kees van Zon; Added type() function for YAPI 0.5.0
//    10/13/00  : Kees van Zon; Included in utilities.h

template<class SINK>

class sink : public Process
{
public:
    //constructor
    sink (
        Id           n,
        In<SINK>&    InF
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    InP(id("InP"), InF)
{ }
    // member functions
    const char* type() const { return "sink"; }
    void main() {
        while(true) {
            read(InP, in);
        }
    }

private:
    // port
    InPort<SINK> InP;

    // member variable
    SINK in;
};

//
// VYA MODULE   : source
// AUTHOR(S)    : Erwin de Kock
// FUNCTION     : source to dummy input
// DOCUMENTS    : n/a
// OUTPUTS      : Out:    not used
// NETWORK      : n/a
// HISTORY      :
//    06/15/05  : Erwin de Kock; Created

template<class SOURCE>

class source : public Process
{
public:
    //constructor
    source (
        Id           n,
        Out<SOURCE>& OutF
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    OutP(id("OutP"), OutF)
{ }
    // member functions
    const char* type() const { return "source"; }
    void main() { }

private:
    // port
    OutPort<SOURCE> OutP;
};

//
// VYA MODULE   : pass
// AUTHOR(S)    : Erwin de Kock
// FUNCTION     : pass input to output
// DOCUMENTS    : n/a
// OUTPUTS      : Out: copy of input
// NETWORK      : n/a
// HISTORY      :
//    06/15/05  : Erwin de Kock; Created

template<class PASS>

class pass : public Process
{
public:
    //constructor
    pass (
        Id            n,
        In<PASS>&   InF,
        Out<PASS>& OutF
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    InP(id("InP"), InF),
    OutP(id("OutP"), OutF)
{ }
    // member functions
    const char* type() const { return "pass"; }
    void main() {
        while(true) {
            read(InP, in);
            write(OutP, in);
        }
    }

private:
    // port
    InPort<PASS> InP;
    OutPort<PASS> OutP;

    // member variable
    PASS in;
};

//
// VYA MODULE   : i2l
// AUTHOR       : Karl Wittig
// FUNCTION     : Converts image size information to line length information.
// DOCUMENTS    : n/a
// INPUTS       : imgWin        -- input image width
//                imgHin        -- input image height
// OUTPUTS      : lineLout      -- output line length
// NETWORK      : n/a
// HISTORY      :
//    09/29/00  : Karl Wittig;  Created
//    10/13/00  : Kees van Zon; Included in utilities.h

class i2l : public Process
{
public:
    // constructor
    i2l(
        Id                     n,
        In<VYAimageWidth>&     imgWinF,
        In<VYAimageHeight>&    imgHinF,
        Out<VYAlineLength>&    lineLoutF
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    imgWinP(id("imgWin"), imgWinF),
    imgHinP(id("imgHin"), imgHinF),
    lineLoutP(id("lineLout"), lineLoutF)
{ }

    // member functions
    const char* type() const { return "i2l"; }
    void main() {
        while (true) {
           read(imgWinP, imgWin);
           read(imgHinP, imgHin);
           lineLout = imgWin;
           for (int i=0; i < (int)imgHin; i++)
              write(lineLoutP, lineLout);
        }
    }

private:
    // ports
    InPort<VYAimageWidth>     imgWinP;
    InPort<VYAimageHeight>    imgHinP;
    OutPort<VYAlineLength>    lineLoutP;

    // member variables
    VYAimageWidth             imgWin;
    VYAimageHeight            imgHin;
    VYAlineLength             lineLout;
};

//
// VYA MODULE   : l2i
// AUTHOR       : Karl Wittig
// FUNCTION     : Converts line length information to image size information.
// DOCUMENTS    : n/a
// INPUTS       : lineLin       -- input line length
//                imgHin        -- input image height
// OUTPUTS      : imgWout       -- output image width
// NETWORK      : n/a
// HISTORY      :
//    09/29/00  : Karl Wittig;  Created
//    10/13/00  : Kees van Zon; Included in utilities.h

class l2i : public Process
{
public:
    // constructor
    l2i(
        Id                      n,
        In<VYAlineLength>&      lineLinF,
        In<VYAimageHeight>&     imgHinF,
        Out<VYAimageWidth>&     imgWoutF
    )
:
    // member initialisation
    // process network
    Process(n),

    // ports
    lineLinP(id("lineLin"), lineLinF),
    imgHinP(id("imgHin"), imgHinF),
    imgWoutP(id("imgWout"), imgWoutF)
{ }

    // member functions
    const char* type() const { return "l2i"; }
    void main() {
        while (true) {
            read(imgHinP, imgHin);
            read(lineLinP, lineLin);
            imgWout = lineLin;
            write(imgWoutP, imgWout);

            for (int i=1; i < (int)imgHin; i++)
                read(lineLinP, lineLin);
        }
    }

private:
    // ports
    InPort<VYAlineLength>     lineLinP;
    InPort<VYAimageHeight>    imgHinP;
    OutPort<VYAimageWidth>    imgWoutP;

    // member variables
    VYAimageWidth             imgWout;
    VYAimageHeight            imgHin;
    VYAlineLength             lineLin;
};


#endif  // UTILITIES_H

---