Provided by: paraview_3.14.1-1ubuntu1_amd64 bug


       icetStrategy -- set the strategy used to composite images.


       #include <IceT.h>

       void icetStrategy(   IceTEnum   strategy  );


       The  IceT API comes packaged with several algorithms for compositing images. The algorithm
       to use is determined by selecting a strategy.  The strategy is selected with icetStrategy.
       A strategy must be selected before icetDrawFrame is called.

       A strategy is chosen from one of the following provided enumerated values:

               Basically  applies a ``traditional'' single tile composition (such as binary swap)
              to each tile in the order they were defined. Because each process must take part in
              the composition of each tile regardless of whether they draw into it, this strategy
              is usually inefficient when compositing for more than one tile, but is  recommended
              for  the  single  tile case because it bypasses some of the communication necessary
              for the other multi-tile strategies.

               As each process renders an image for a tile, that image is sent  directly  to  the
              process  that  will  display  that  tile.  This  usually results in a few processes
              receiving and processing the majority of the data,  and  is  therefore  usually  an
              inefficient strategy.

               Like ICET_STRATEGY_DIRECT, except that the tiles are split up, and each process is
              assigned a piece of a tile in such a way that each  process  receives  and  handles
              about  the  same  amount of data. This strategy is often very efficient, but due to
              the large amount of messages passed, it has not  proven  to  be  very  scalable  or

               A two phase algorithm. In the first phase, tile images are redistributed such that
              each process has one image for one tile. In the  second  phase,  a  ``traditional''
              single  tile composition is performed for each tile. Since each process contains an
              image for only one tile, all these compositions may happen simultaneously. This  is
              a  well rounded strategy that seems to perform well in a wide variety of multi-tile
              applications. (However, in the special case where only one  tile  is  defined,  the
              sequential strategy is probably better.)

               An  extension  to  the  binary  tree  algorithm  for  image composition. Sets up a
              ``virtual'' composition tree for each tile image. Processes that belong to multiple
              trees  (because  they  render  to  more than one tile) are allowed to float between
              trees. This strategy is not quite as well load balanced as ICET_STRATEGY_REDUCE  or
              ICET_STRATEGY_SPLIT, but has very well behaved network communication.

       Not  all  of  the strategies support ordered image composition.  ICET_STRATEGY_SEQUENTIAL,
       ICET_STRATEGY_DIRECT, and  ICET_STRATEGY_REDUCE  do  support  ordered  image  composition.
       ICET_STRATEGY_SPLIT  and  ICET_STRATEGY_VTREE do not support ordered image composition and
       will ignore ICET_ORDERED_COMPOSITE if it is enabled.

       Some of the strategies, namely ICET_STRATEGY_SEQUENTIAL and  ICET_STRATEGY_REDUCE,  use  a
       sub-strategy  that  composites the image for a single tile. This single image strategy can
       also be specified with icetSingleImageStrategy.


               The strategy argument does not represent a valid strategy.




       None known.


       Copyright (C)2003 Sandia Corporation

       Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
       retains certain rights in this software.

       This source code is released under the New BSD License.

See Also

       icetDrawFrame(3), icetGetStrategyName(3) icetSingleImageStrategy(3)

IceT Reference                           August  9, 2010                          icetStrategy(3)