stage/include/ost/img/image_state/value_holder.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// This file is part of the OpenStructure project <www.openstructure.org>
//
// Copyright (C) 2008-2010 by the OpenStructure authors
// Copyright (C) 2003-2010 by the IPLT authors
//
// This library 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 3.0 of the License, or (at your option)
// any later version.
// This library 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 this library; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//------------------------------------------------------------------------------

/*
  value holder for image state

  Author: Ansgar Philippsen
*/

#ifndef VALUE_HOLDER_H
#define VALUE_HOLDER_H

#include <ost/base.hh>
#include <ost/img/module_config.hh>
#include <ost/img/data_types.hh>
#include <ost/img/size.hh>

#include "type_fw.hh"

namespace value_holder_test {

template <typename V>
void ReleaseAndReconstruct();

}

namespace ost { namespace img { namespace image_state {

/*
  Value Holder

  Provide a dynamically allocated 3D array with
  optimized access, based on a zero based Index, which
  in turn encapsulates an unsigned integer triplet

  Should provide reasonable exception safety, ie an exception
  during construction will not cause a memory leak.
*/
template <typename V>
class TEMPLATE_EXPORT ValueHolder {
public:
  typedef V* VPtr;
  typedef VPtr* VPtrPtr;


  ValueHolder(unsigned int wi, unsigned int he, unsigned int de);

  ValueHolder(const Size& s);

  ValueHolder(const Size& s, const Size& ps);

  ValueHolder(const ValueHolder<V>& h);

  template <typename U>
  ValueHolder(const Size& s, ValueHolder<U>& v):
    width_(s[0]),
    height_(s[1]),
    depth_(s[2]),
    volume_(width_*height_*depth_),
    volume2_(v.GetPhysicalSize()*sizeof(U)/sizeof(V)),
    data_(reinterpret_cast<V*>(v.ReleaseData())),
    row_(0),
    slice_(0)
  {
    try {
      setup();
    } catch(...) {
      delete []data_;
    }
  }



  ValueHolder& operator=(const ValueHolder<V>& h);

  ~ValueHolder();


  VPtr ReleaseData();

  void Swap(ValueHolder& vh);



  // retrieve width, at least 1
  unsigned int GetWidth() const {return width_;}
  // retrieve height, at least 1
  unsigned int GetHeight() const {return height_;}
  // retrieve depth, at least 1
  unsigned int GetDepth() const {return depth_;}
  // retrieve overall size (width*height*depth), at least 1
  unsigned int GetVolume() const {return volume_;}
  // retrieve dimensions as Size object
  Size GetSize() const;

  static DataType GetDataType();

  unsigned int GetPhysicalSize() const {return volume2_;}

  long MemSize() const;




  V& Value(const Index& i);


  const V& Value(const Index& i) const;


  V& Value(unsigned int i);


  const V& Value(unsigned int i) const;


  VPtr GetData() {return data_;}
  const VPtr GetData() const {return data_;}

  int DataCount() const {return volume_;}


  int GetDataCount() const {return volume_;}

  const VPtr GetEnd() const {return &data_[volume_];}

  VPtr* GetRows() {return row_;}
  const VPtr* GetRows() const {return row_;}

  int GetRowCount() const {return width_*height_;}

  VPtrPtr* GetSlices() {return slice_;}
  const VPtrPtr* GetSlices() const {return slice_;}

  int GetSliceCount() const {return width_;}

private:
  unsigned int width_, height_, depth_, volume_;
  // this is a hack to get padding for fftw to work...
  unsigned int volume2_;

  // actual data storage
  V* data_;
  // optimization 
  V** row_;
  // optimization
  V*** slice_;

  void setup();
  void clear();
};

}}} // namespaces

#endif

---