BackwardMappingLUTStructs.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef __BackwardMappingLUTStructs_hh__
#define __BackwardMappingLUTStructs_hh__

namespace BIAS {

  /** @enum InterpolationMethod
      @brief accuracy for resampling

      Trilinear averages different pyramid levels based on a local isotropic
      sampling frequency
      Anisotropic is the most expensive and uses the local jacobian for
      anti-aliasing, while preserving texture direction which need
      no smoothing */
  enum InterpolationMethod {
    InterpolationMethod_UNKNOWN=0,
    MapNearestNeighbor=1,
    MapBilinear=2,
    MapBicubic=3,
    MapTrilinear=4,
    MapAnisotropic=5
  };

  /** @class BWM_LUT_Entry_Nearest
      @brief base class for storing precomputed look-up information
      in BackwardMapping */
  class BWM_LUT_Entry_Nearest {
  public:
    /// boolean showing if the pixel can be correctly mapped
    bool mapped;
    /// nearest x,y-position in the source image, written as an index
    int index;
  };

  /** @class BWM_LUT_Entry_Bilinear
      @brief base class for storing precomputed lookup information for bilinear
      interpolation in BackwardMapping */
  class BWM_LUT_Entry_Bilinear {
  public:
    /// boolean showing if the pixel can be correctly mapped
    bool mapped;

    //-------PIXEL INDEXES AND THEIR WEIGHTS-------
    /// PIXEL X-
    ///       --
    /// weight for (1-dx)*(1-dy)
    float xy_weight;
    //index of pixel (floor(x), floor(y)) in the picture
    int index_0_0;

    /// PIXEL --
    ///       X-
    /// weight for (1-dx)*dy
    float xY_weight;
    //index of pixel (floor(x), floor(y+1)) in the picture
    int index_0_1;

    /// PIXEL -X
    ///       --
    /// weight for dx*(1-dy)
    float Xy_weight;
    //index of pixel (floor(x+1), floor(y)) in the picture
    int index_1_0;

    /// PIXEL --
    ///       -X
    /// weight for dx*dy
    float XY_weight;
    //index of pixel (floor(x+1), floor(y+1)) in the picture
    int index_1_1;
    //---------------------------------------------
    /** Returns the content of object into serialized mem.
      * \attention it is assumed that access to mem is valid.
    **/
    float* SerializedOut(float* pointerToHeadOfOutputMem);

    /** Retrieves the content of object from serialized mem.
    * \attention it is assumed that access to mem is valid.
    **/
    const float* SerializedIn(const float* pointerToHeadOfInputMem);
    /** Returns the number of fields that are contained in the
    * serialized output.
    **/
    static int GetSerializedSize();
  };

  /** @class BWM_LUT_Entry_Trilinear
      @brief base class for storing precomputed lookup information for
      trilinear interpolation in BackwardMapping */
  class BWM_LUT_Entry_Trilinear {
  public:
    /// boolean showing if the pixel can be correctly mapped
    bool mapped;

    /// pyr_diff_inv + pyr_diff = 1
    float pyr_diff_inv;
    /// lower pyramid-level-index
    int    pyr_level_low;

    /// pyr_level + pyr_diff = exact pyramid-level of the pixel
    float pyr_diff;
    /// higher pyramid-level-index
    int    pyr_level_high;

    /// pixel values on both lower and higher pyramid levels
    BWM_LUT_Entry_Bilinear stage_0;
    BWM_LUT_Entry_Bilinear stage_1;

    /** Returns the content of object into serialized mem.
      * \attention it is assumed that access to mem is valid.
    **/
    float* SerializedOut(float* pointerToHeadOfOutputMem);

    /** Retrieves the content of object from serialized mem.
    * \attention it is assumed that access to mem is valid.
    **/
    const float* SerializedIn(const float* pointerToHeadOfInputMem);
    /** Returns the number of fields that are contained in the
    * serialized output.
    **/
    static int GetSerializedSize();
  };

  /** @class BWM_LUT_Entry_Anisotropic
      @brief base class for storing precomputed lookup information for
      anisotropic interpolation in BackwardMapping
      @attention NOT IMPLEMENTED */
  class BWM_LUT_Entry_Anisotropic {
  public:
    //range
    //NOT IMPLEMENTED
  };

  /** @class BWM_LUT_Entry_Bicubic
      @brief base class for storing precomputed lookup information for
      bicubic interpolation in BackwardMapping
      @attention NOT IMPLEMENTED */
  class BWM_LUT_Entry_Bicubic {
  public:
    //range
    //NOT IMPLEMENTED
  };

 

} // namespace


#endif